// Spike web UI: pipeline list + run detail over the live WebSocket protocol. // Deliberately small and DOM-only (no framework, no build step). Every value // that came from the server is set with textContent, never innerHTML. import { PipelinesClient, ProtocolError } from "./client.js"; import { PipelinesRepository, SHELL_OUTPUT_LIMIT, newChatOperationId } from "./repository.js"; import { PROTOCOL_VERSION, Protocol, ChatKeys } from "./protocol.js"; import { validateServerUrl, resolveArtifactUrl } from "./serverUrl.js"; import { ForegroundAction, bannerState, foregroundAction, liveBadgeState, protocolMismatch, serverBuildLabel, stateBadge, } from "./connection.js"; import { SERVER_URL_HELPER, SERVER_URL_PLACEHOLDER, TEMPLATES_CARD_LABEL, TEMPLATES_CARD_SECONDARY, TRUST_BODY, TRUST_TITLE, WORKSPACE_HELPER, WORKSPACE_PLACEHOLDER, canSaveWorkspace, connectionActionKind, connectionActions, connectionCard, readServerUrl, readWorkspace, savedWorkspaceLine, workspaceErrorText, writeServerUrl, writeWorkspace, } from "./settings.js"; import { ArtifactKind, artifactCaptureNotes, artifactGroups, artifactKind, artifactKindLabel, artifactsHeader, artifactsSummary, artifactViewerPositionLabel, displayVisit, humanBytes, pagedArtifacts, pagedIndex, presentedArtifacts, resolvedArtifactUrl, sessionExportArtifact, viewerIndexByUrl, } from "./artifacts.js"; import { PIPELINE_GRAPH_EMPTY, RUN_GRAPH_MISSING, RUN_GRAPH_NOTE, layoutGraph, mount as mountGraph, } from "./graph.js"; import { DEFAULT_ROUTE, parseRoute, serializeRoute } from "./routes.js"; import { PIPELINE_SORTS, PIPELINE_DETAIL_TABS, RUN_PRESENCES, RUN_STATUS_FILTERS, EMPTY_PIPELINE_FILTERS, filterPipelines, graphNote, latestRunByPipeline, pipelineFilterCount, pipelineListEmptyState, pipelineSubtitle, pipelineUpdatedLine, runBadge, runBadgeMetaLine, sortPipelines, summaryFields, versionRow, } from "./pipelines.js"; import { RUN_STATES, RUN_TIME_RANGES, RUN_SORTS, DEFAULT_RUN_SORT, runStateOf, runIdentity, versionLabel, progressText, metaText, formatDuration, localDayKey, filterRuns, groupRunsByDay, runComparator, pipelineFilterOptions, runListEntries, defaultRunFilters, runFiltersActiveCount, } from "./runs.js"; import { CREATE_ACTION_LABEL, CREATE_NAME_LABEL, CREATE_NOTE, createConfirmLabel, createDismissLabel, createFormTitle, createFormValid, createSuccessMessage, createdPipelineName, effectiveStageType, templateCard, templateDetailName, templateGalleryName, templateGraphNote, templateStageCountLabel, templateStageSummary, TEMPLATE_UNPARSED_SOURCE_NOTE, } from "./templates.js"; import { RENDERED_RUN_TABS, EMPTY_INPUT_MESSAGE, EMPTY_OUTPUT_MESSAGE, EMPTY_TIMELINE_MESSAGE, NO_STAGE_DETAILS_MESSAGE, fieldSections, summaryRows, runIdentityLine, runLabelFor, runDurationText, runTimeline, runGraphState, nodeLabel, headlineFields, runStepFields, stageSectionSpecs, clampVisitIndex, referencedVerdictArtifacts, verdictReasonSegments, outcomeColorToken, stateGlyph, } from "./runDetail.js"; import { BINARY_DIFF_MESSAGE, NO_LINE_CHANGES_MESSAGE, TRUNCATED_PATCH_NOTE, ChangeKind, changeKindLabel, changeKindTitle, changePositionLabel, changeRowMeta, changeStat, changesListSummary, diffLineClass, diffLineSymbol, entryHasPatch, gutterText, gutterWidth, noChangeDetail, parseUnifiedPatch, patchUnavailableReason, runChanges, runChangesHeader, runChangesNote, } from "./changes.js"; import { ATTENTION_STORAGE_KEY, AttentionKind, attentionBadgeLabel, attentionDismissAll, attentionDismiss, attentionDismissalSnapshot, attentionEntries, attentionRowDescription, decodeAttentionDismissals, encodeAttentionDismissals, } from "./attention.js"; import { NOTIFICATION_RATIONALE, NOTIFY_STORAGE_KEY, createAlertLedger, decodeNotificationSettings, encodeNotificationSettings, notificationEnvironment, notificationPermissionState, } from "./notify.js"; import { DEFAULT_SEARCH_KIND, DEFAULT_SEARCH_SORT, SEARCH_DEBOUNCE_MS, SEARCH_KINDS, SEARCH_SORTS, SearchSequencer, filterSearchResults, resolveRunTarget, searchControlsSummary, searchFailureText, searchPanelBody, searchPanelProgress, searchQuerySendable, searchResultKindLabel, searchRow, searchTarget, sortSearchResults, } from "./search.js"; import { ACTION_FAILED_OK, ACTION_FAILED_TITLE, CANCEL_CONFIRM, CANCEL_DIALOG_MESSAGE, DECISION_ACTION, DECISION_CANCEL, DECISION_CARD_TITLE, DECISION_CONFIRM, DECISION_SENDING, DISMISS_KEEP, DecisionDraft, FEEDBACK_LABEL, RENAME_ACTION, RENAME_CANCEL, RENAME_FIELD_LABEL, RENAME_SAVE, RESTART_CONFIRM, RESTART_DIALOG_MESSAGE, RETRY_CONFIRM, RETRY_DIALOG_MESSAGE, canCancel, canRetry, cancelDialogTitle, decisionCardMeta, decisionSheetMeta, decisionSheetTitle, optionTargetText, pendingDecision, restartDialogTitle, retryDialogTitle, retryRequestKey, } from "./actions.js"; import { BACKGROUND_TASKS_TITLE, CHAT_ACTIONS_LABEL, CHAT_ATTACH_LABEL, CHAT_COMMAND_DISMISS_LABEL, CHAT_COMMAND_GLYPH, CHAT_COMPOSER_PLACEHOLDER, CHAT_CREATE_BACK_LABEL, CHAT_CREATE_CANCEL, CHAT_CREATE_CONFIRM, CHAT_CREATE_LOADING, CHAT_CREATE_MODEL_NOTE, CHAT_CREATE_PROMPT, CHAT_CREATE_TITLE, CHAT_EMPTY, CHAT_FOLLOW_THRESHOLD_PX, CHAT_HIDE_ACTION, CHAT_LOADING, CHAT_NEW_ACTION, CHAT_NO_MATCH_ACTION, CHAT_QUEUED_NOTICE, CHAT_REMOVED_MESSAGE, CHAT_RENAME_ACTION, CHAT_RENAME_DISMISS, CHAT_RENAME_FIELD_LABEL, CHAT_RENAME_HELPER, CHAT_RENAME_SAVE, CHAT_RENAME_TITLE, CHAT_SEARCH_LABEL, CHAT_SEND_LABEL, CHAT_STOP_LABEL, CHAT_TAB_TITLE, CHAT_UNDO_ACTION, CLOSED_CHIP_LABEL, CLOSED_SECTION_LABEL, CLOSE_CHAT_ACTION, CLOSE_CHAT_CONFIRM, CLOSE_CHAT_DISMISS, CLOSE_CHAT_TITLE, COMPOSER_SEND, COMPOSER_STOP, CONVERSATION_EMPTY, CONVERSATION_LOADING, LOAD_OLDER_ACTION, REOPEN_ACTION, SELECT_CHAT_HINT, APPROVAL_CONTROL_ALWAYS, APPROVAL_CONTROL_ONCE, APPROVAL_CONTROL_REJECT, DECISION_ALWAYS, DECISION_ONCE, DECISION_REJECT, RISK_REVIEW_LABEL, WAITING_FOR_APPROVAL_LABEL, SHELL_DETAILS_LABEL, SHELL_OUTPUT_EMPTY, SHELL_OUTPUT_ERROR, SHELL_OUTPUT_LABELS, SHELL_OUTPUT_LOADING, SHELL_OUTPUT_READY, SHELL_OUTPUT_UNAVAILABLE, SHELL_ROW_LABEL, applyChatEvent, applyChatOverrides, applyChatPermission, appendChatNotice, approvalCard, attachmentDisplayName, attachmentError, attachmentFiles, backgroundTasksRunningLabel, chatBottomDistancePx, chatCommandEffect, chatCommandHelp, chatCommandSuggestions, chatCreateFailed, chatCreateSucceeded, chatFirstScroll, chatFollowsAt, chatHeaderMeta, chatNoMatchMessage, chatNoticeLabel, chatOpensAtNewest, chatShowJumpToLatest, chatStartInLabel, chatStreamState, closeChatConfirmation, composerAction, composerCanSend, composerSendEnabled, composerSubmit, decodeChatOverrides, decodeChatSeen, defaultDirectoryChoice, directoryChoices, directoryLabel, dismissChatNotice as dismissChatNoticeModel, emptyChatOverrides, emptyChatSeen, encodeChatOverrides, encodeChatSeen, filterSessions, groupSessionsByDirectory, hideChatOverride, historyResync, isChatSessionUnseen, makeChatNotice, markChatUnseen, mergeHistoryPage, mergeShellFrame, newChatCreateState, newChatThread, parseChatInput, queuedAfterFrame, readChatSeen, reasoningLabel, renameChatOverride, restoreChatOverride, resumedThread, runningAfterFrame, runningBackgroundShells, runningToolElapsedMillis, seedChatSeen, sessionActivity, sessionActivityBadge, sessionChipLabel, sessionMeta, sessionStatusLabel, selectChatDirectory as selectChatDirectoryModel, sessionTitle, sessionWorkLabel, settledThread, shellCommandSummary, shellOutputState, shellsLoaded, takeChatNoticeOffer as takeChatNoticeOfferModel, formatToolDuration, threadElapsedMillis, threadPhase, threadRunningTools, threadToolElapsedMillis, TURN_PHASE_WAITING, toolCallCount, toolCallRow, toolCallsAnnouncement, toolCallsLabel, toolDetail, toolFailed, toolLabel, toolLongRunning, toolRunning, toolsRunning, transcriptRows, turnElapsedMillis, turnPhaseLabel, } from "./chat.js"; import { codeBlockLabel, parseInline, parseMarkdown } from "./markdown.js"; /** * The per-session chat scroll positions (C14). Persisted in localStorage, the * browser analogue of the Android `ChatThread.scroll`: a position the operator * deliberately left — including the very top — is restored, while an absent one * opens the conversation at its newest message. */ const CHAT_SCROLL_STORAGE_KEY = "pipelines.web.chatScroll.v1"; /** * The per-chat composer drafts (C8). Mirrored into localStorage, the browser * analogue of the Android store's per-device draft: a draft survives a reload, * keyed by session id (attachments are memory-only — a File handle cannot be * serialised). The in-memory `thread.draft` is the source of truth while the page * is open; this is only the persistence beside it. */ const CHAT_DRAFT_STORAGE_KEY = "pipelines.web.chatDraft.v1"; /** * The operator's own chat changes (C13): local renames and hidden session ids, * the web analogue of Android's `chat_overrides` preference. One JSON value: * `{titles:{"":""},hidden:["<id>"]}`. A local title wins over the * server's on every later list refresh; a hidden id only disappears here. */ const CHAT_OVERRIDES_STORAGE_KEY = "pipelines.web.chatOverrides.v1"; /** * What the operator has already seen of the session list (C13), the web analogue * of Android's `chat_seen` preference. One JSON value: * `{seenAt:{"<id>":<updated_at ms>},unseen:["<id>"]}`. The watermark is advanced * only by opening a chat (or first-sight seeding), never by a stale list. */ const CHAT_SEEN_STORAGE_KEY = "pipelines.web.chatSeen.v1"; /** Shown where tiles exist but the configured server URL cannot resolve them. */ const ARTIFACT_SERVER_HINT = "Set the server URL in Settings to open or copy artifact links."; /** * The page is normally served by serve.mjs, which also proxies /connect to the * Pipelines server. Defaulting to this page's own origin therefore points at * that proxy and keeps the page and the WebSocket same-origin — the server * rejects a cross-origin upgrade with 403. Nothing is hardcoded: the value is * derived from wherever the page was loaded, and the user can override it. */ function defaultServerUrl() { if (typeof location === "undefined" || !location.host) return ""; const scheme = location.protocol === "https:" ? "wss" : "ws"; return `${scheme}://${location.host}/connect`; } const client = new PipelinesClient(); const repo = new PipelinesRepository(client); // Read the persisted settings once: the server URL falls back to the page's own // proxy endpoint when unset, and the workspace starts blank when unset. Both the // configured value and the draft start from storage. const initialWorkspace = readWorkspace(localStorage); const state = { view: "pipelines", url: readServerUrl(localStorage) || defaultServerUrl(), // The server URL's own validation message (Android's `urlError`), shown as the // Settings field's supporting text and cleared as soon as the field is edited. urlError: "", // The workspace the operator configured (L1), the analogue of SettingsRepository's // `workspace` preference. `workspaceDraft` is the field's live value; Save copies // it into `workspace` and localStorage. Both start from the persisted value. workspace: initialWorkspace, workspaceDraft: initialWorkspace, connection: client.state, // The last `pong` reply is remembered so the banner can name a stale server // build and warn about a protocol mismatch (T5) without re-pinging. serverBuild: null, serverProtocol: null, // The `pong` reply's server time (L1), shown in the Settings connection card. serverTime: null, pipelines: [], runs: [], usage: null, pipelineDetail: null, runDetail: null, selectedPipelineId: null, selectedRunId: null, // The version the selected pipeline detail was requested at (0 = latest), and // the stage whose definition pane is open. Both are part of the URL route. pipelineRequestedVersion: 0, pipelineGraphSelection: null, // The URL route model (L6): the route currently rendered, the one pending until // the first successful connection opens it, whether that first connection has // happened, and a re-entrancy guard for popstate-driven application. route: { ...DEFAULT_ROUTE }, pendingRoute: null, routeFirstConnect: false, routeApplying: false, popPending: false, // Pipelines view: client-side filter/sort/detail-tab state. The run history is // fetched alongside the pipelines so the list can show each pipeline's last // run; runsLoaded tells a genuinely empty history apart from one not in hand. pipelineFilters: { ...EMPTY_PIPELINE_FILTERS }, pipelineSort: "server_order", pipelineMenu: null, pipelineTab: "summary", // The mounted workflow graph (P6) and whether its panel is expanded. The // handle is dropped on every re-render so its listeners can never leak. pipelineGraph: null, pipelineGraphExpanded: false, // The mounted run-mode graph (R5) on the run detail's Graph tab. Dropped on // every re-render and on a run change, so its wheel/pointer/resize listeners // and its elapsed timer can never leak. runGraph: null, versionsExpanded: false, pipelinesLoaded: false, runsLoaded: false, templates: [], templateLoading: false, // key -> graph|null: the parsed definition, cached once per template key. A // failed/absent validate stores null so the card/detail say "unavailable". templateGraphs: new Map(), selectedTemplateKey: null, templateTab: "summary", // The create-from-template dialog (P5): whether it is open, the name being // typed, whether a validate+submit is in flight, the server's refusal text and // the created pipeline's name (null until a success, which is also what makes // Cancel read Close and the field lock). The dialog validates the template's // source first, then submits it create-only; nothing runs. templateCreateOpen: false, templateCreateName: "", templateCreateSending: false, templateCreateError: "", templateCreateCreated: null, loading: false, error: "", runFilters: defaultRunFilters(), runSort: DEFAULT_RUN_SORT, openMenu: null, // Run detail: the selected tab (Summary by default) and the per-run // expand/collapse choices for the input/output field sections and the summary // artifacts section. The stage pane is the timeline's per-visit panel; its // section expansion is reseeded each time a pane is opened. runTab: "summary", runSections: new Set(), runStagePane: null, runStageSections: new Set(), // The attention / "Needs you" surface (R15). `attentionDismissed` is the set // of `{runId}:{kind}` identities the operator has explicitly dealt with, loaded // once at boot from localStorage. `attentionSheetOpen` drives the sheet and // `attentionSnapshot` holds the entries captured when it opened, so Clear all // only ever removes identities the operator actually saw. attentionDismissed: new Set(), attentionSheetOpen: false, attentionSnapshot: null, // Notifications (L5): whether the operator has already been asked, loaded once // at boot from localStorage. The browser owns the permission itself; this flag // only changes the honest wording in Settings and is never a claim of consent. notifyAsked: false, // Omni-search (S1/S2): the field/panel state, kept beside the view it never // changes, plus the pure debounce/stale-token sequencer. Opening or closing the // search leaves state.view, the selection and the loaded data untouched. searchOpen: false, searchQuery: "", searchKind: DEFAULT_SEARCH_KIND, searchSort: DEFAULT_SEARCH_SORT, searchResults: [], searchLoading: false, searchError: "", searchLoaded: false, searchFocusPending: false, searchSequencer: new SearchSequencer(), // Run-level operator actions (R11–R14): the decision the open sheet renders // (retained across a refused send so the server's own reason can be shown even // after a refresh), the sheet's draft/sending/error, the action awaiting a // confirm dialog, the in-progress rename title (null when not editing) and the // one shared Action-failed dialog. runDecision: null, decisionOpen: false, decisionDraft: new DecisionDraft(), decisionSending: false, decisionError: "", confirmKind: null, renameValue: null, renameBusy: false, actionError: "", // Chat (C1/C3/C4/C7/C14): the server's operator-session list and its load // state, the operator's narrowing, one open thread per session id and the // active one. The transcript is untrusted model output, so every server string // is set with textContent and the markdown renderer builds DOM nodes, never // innerHTML. chatSessions: [], // The verification chats this page itself created (C2's automation flag). The // server deliberately never lists them; the page keeps its own in-memory row so // the creator can keep working with the chat it just opened. The set is // memory-only, so a reload cannot turn one into a permanent list entry. chatEphemeralIds: new Set(), chatLoading: false, chatLoaded: false, chatError: "", chatQuery: "", chatThreads: new Map(), chatActiveId: null, chatPlaced: null, chatFollowing: true, chatReasoning: new Set(), // The tool-call panel (C6): the turns whose panel is open and the individual // rows the operator has expanded, both keyed the same way as chatReasoning so // a re-render keeps them. chatToolPanels: new Set(), chatToolRows: new Set(), chatScroll: readChatScrollStore(), // The scroll restore across a prepended older page, the position captured // from the live transcript just before a re-render (so a dialog, a refresh or // the loading frame of a paging fetch never loses the operator's place), and // the debounced save. chatAnchor: null, chatPending: null, chatScrollTimer: null, // True only while the operator's own gesture (wheel/pointer/touch) is the // reason the transcript moved, so a programmatic placement or follow can never // be mistaken for the operator leaving the bottom. chatUserIntent: false, // The session awaiting the Close chat? confirm, and the shared Action-failed // report for a refused close/reopen. chatClose: null, chatBusy: false, // C13: this device's local titles/hidden ids and the seen watermarks, both // persisted as one JSON value each. `chatMenu` is the row whose Chat actions // menu is open, `chatRename` the session whose Rename chat dialog is open, and // `chatSnackbar` the one in-flight hide report (`{id, sessionId}`) with the // timer that auto-dismisses it. A new hide replaces the previous report. chatOverrides: readChatOverridesStore(), chatSeen: readChatSeenStore(), chatMenu: null, chatRename: null, chatSnackbar: null, chatSnackbarSeq: 0, chatSnackbarTimer: null, // C5: the session ids this connection currently has subscribed to their shared // live stream. The server detaches a subscription when the connection closes // (there is no chat_unsubscribe), so this is cleared on every socket drop and // re-established for the open chat on reconnect. A refused subscription simply // never joins the set, so the badge reads "not live" honestly. chatSubscriptions: new Set(), // C2: the create flow. `chatCreate` is the ChatCreateState analogue (null until // the New chat entry point is used); the directory reply is cached so cancelling // and reopening does not re-ask, and a failed load keeps its own reason. chatDirectories: [], chatDirectoriesLoading: false, chatDirectoriesLoaded: false, chatDirectoriesError: "", chatCreate: null, }; // The run-notification ledger (L5). It is seeded from the authoritative run list // and from the subscribe snapshot, then observes pushed `run_event` frames; it // never feeds the runs list (that is R10's separate fold). const runAlerts = createAlertLedger(); let runPoll = null; // One shared live clock for the runs list: it ticks only while a shown run is // executing, and each running row reads its elapsed from it rather than starting // a timer of its own. Elapsed is derived from the server's start timestamp, so // it stays correct after a reconnect; a finished history never ticks. let listClock = null; let listNow = Date.now(); // The run detail's own live clock: it ticks only while the shown run is // executing, updating just the Duration row in place (never a full re-render, so // an open stage pane is not torn down), exactly as the runs list does. let detailClock = null; let detailNow = Date.now(); // The chat running indicator's own live clock (C5): it ticks once a second only // while the open conversation has a turn in flight, updating just the indicator // in place (never a full re-render), so the transcript's scroll is not disturbed. let chatClock = null; let chatNow = Date.now(); // --------------------------------------------------------------------------- // DOM helpers // --------------------------------------------------------------------------- function h(tag, props = {}, ...children) { const node = document.createElement(tag); for (const [key, value] of Object.entries(props)) { if (value == null || value === false) continue; if (key === "class") node.className = value; else if (key === "text") node.textContent = value; else if (key.startsWith("on") && typeof value === "function") { node.addEventListener(key.slice(2).toLowerCase(), value); } else node.setAttribute(key, value === true ? "" : String(value)); } for (const child of children.flat()) { if (child == null || child === false) continue; node.append(child instanceof Node ? child : document.createTextNode(String(child))); } return node; } function isExecuting(run) { return Boolean(run && run.executing); } // --------------------------------------------------------------------------- // Rendering // --------------------------------------------------------------------------- const header = h("header", { class: "topbar" }); // The full-width omni-search panel sits directly under the top bar (and so under // the search control that lives in it), above the connection banner so it can // never be mistaken for a status strip. const searchHost = h("div", { id: "searchHost", class: "search-host" }); // The persistent connection banner sits in normal document flow directly under // the header (never fixed/overlaying), so it can never cover the content. const connBanner = h("div", { id: "connBanner", class: "conn-banner", hidden: true }); const content = h("main", { id: "content" }); // The attention sheet lives in its own layer so it can overlay any view without // being torn down by a content re-render; renderAttentionSheet rebuilds it. const attentionLayer = h("div", { id: "attentionLayer" }); document.body.append(header, searchHost, connBanner, content, attentionLayer); // The pending debounce timer and the edit it belongs to. Both are dropped the // moment the query is sent, cleared or superseded. let searchTimer = null; let searchEdit = null; /** Whether the URL field currently holds a usable endpoint for Reconnect. */ function endpointConfigured() { return validateServerUrl(state.url).valid; } /** * The one server-URL draft (Android's `serverUrlDraft`). Both the header field and * the Settings `Server URL` field edit this same value and are mirrored in place * without a re-render, so the two can never show different endpoints while typing * (and neither loses focus). Editing also clears the field's own error, exactly as * AppViewModel.updateServerUrlDraft does. */ function setServerUrlDraft(value, sourceId) { state.url = value; clearServerUrlError(); for (const id of ["url", "settingsServerUrl"]) { if (id === sourceId) continue; const other = document.getElementById(id); if (other && other.value !== value) other.value = value; } // The Settings field mirrors this value even when the edit came from the header, // so its own supporting text, error tint and aria-invalid must be refreshed from // the same draft state too: a corrected URL can never leave the field announced // as invalid (or keep the stale "That is not a valid URL." message) just because // the correction happened in the header field. if (document.getElementById("settingsServerUrl")) refreshServerUrlError(); } /** * Clear the server-URL validation error, wherever it was surfaced: the Settings * field's own error always, and — when the invalid Connect came from another view * — the matching page-level banner too, so an edit never leaves a stale message * claiming the URL is still bad. */ function clearServerUrlError() { if (!state.urlError) return; const message = state.urlError; state.urlError = ""; if (state.error === message) { state.error = ""; for (const banner of document.querySelectorAll("#content .banner.error")) { if ((banner.textContent ?? "").includes(message)) banner.remove(); } } } function renderHeader() { const info = bannerState(state.connection, { hasEndpoint: endpointConfigured() }); const controls = [ ...searchHeaderControls(), h("input", { id: "url", type: "text", placeholder: "ws://HOST:PORT/connect", value: state.url, spellcheck: "false", oninput: (e) => { setServerUrlDraft(e.target.value, "url"); }, }), ]; // The manual reconnect control (T3) sits beside the URL field and is offered // whenever the connection state asks for one. if (info.action) { controls.push( h("button", { id: "reconnectBtn", class: "ghost", text: info.action, onclick: onReconnectClicked }), ); } controls.push( h("button", { id: "connectBtn", text: state.connection.kind === "connected" ? "Disconnect" : "Connect", onclick: onConnectClicked, }), h("span", { class: "state", id: "stateBadge" }, connectionLabel()), ); header.replaceChildren( h( "div", { class: "brand" }, h("strong", { text: "Pipelines" }), h("span", { class: "muted", text: "web spike" }), renderAttentionBell(), ), h("div", { class: "connbar" }, ...controls), ); // Autofocus the field only for the render that opened it, so a later // connection-state re-render never steals the operator's focus. if (state.searchOpen && state.searchFocusPending) { document.getElementById("searchInput")?.focus(); state.searchFocusPending = false; } } /** * The top bar's search control: the Search button while closed, and the query * field with its Close control while open. The field's value is always read back * from `state.searchQuery`, so a re-render can never desync the two. */ function searchHeaderControls() { if (!state.searchOpen) { return [ h("button", { id: "searchToggle", class: "ghost search-toggle", type: "button", title: "Search", text: "Search", onclick: openSearch, }), ]; } return [ h("input", { id: "searchInput", class: "search-input", type: "text", placeholder: "Search pipelines, runs and artifacts", value: state.searchQuery, spellcheck: "false", autocomplete: "off", "aria-label": "Search", oninput: (event) => onSearchInput(event.target.value), onkeydown: (event) => { if (event.key === "Enter") { event.preventDefault(); sendSearchNow(); } }, }), h("button", { id: "searchClose", class: "ghost search-close", type: "button", text: "Close search", onclick: closeSearch, }), ]; } /** * The attention bell action, shown in the top bar on every view (R15). Its * accessible name comes from `attentionBadgeLabel`; the visible badge is drawn * only when something genuinely needs the operator, and the count comes from the * same pure model the sheet reads. */ function renderAttentionBell() { const count = attentionCount(); const label = attentionBadgeLabel(count); const button = h("button", { id: "attentionBell", class: "attention-bell", type: "button", "aria-label": label, title: label, onclick: openAttentionSheet, }); button.append(h("span", { class: "attention-bell-glyph", "aria-hidden": "true", text: "\uD83D\uDD14" })); if (count > 0) { button.append( h("span", { class: "attention-badge", "aria-hidden": "true", "data-count": String(count), text: String(count), }), ); } return button; } /** The number of entries the attention surface currently holds. */ function attentionCount() { return attentionEntries(state.runs, state.attentionDismissed).length; } /** * Update the bell in place after the run list (which the surface derives from) * loads, without rebuilding the header and disturbing the URL field. */ function refreshAttentionBell() { const button = document.querySelector("#attentionBell"); if (!button) return; const count = attentionCount(); const label = attentionBadgeLabel(count); button.setAttribute("aria-label", label); button.title = label; let badge = button.querySelector(".attention-badge"); if (count > 0) { if (!badge) { badge = h("span", { class: "attention-badge", "aria-hidden": "true" }); button.append(badge); } badge.dataset.count = String(count); badge.textContent = String(count); } else if (badge) { badge.remove(); } } /** * The persistent connection banner. Its copy/tone come from the pure * `bannerState`, and it also carries the last server build and a protocol * mismatch warning (T5). Every server string is set with textContent. */ function renderBanner() { const info = bannerState(state.connection, { hasEndpoint: endpointConfigured() }); connBanner.className = `conn-banner conn-${info.tone}`; connBanner.hidden = false; const nodes = [ h("span", { class: "conn-banner-dot", "aria-hidden": "true" }), h("span", { class: "conn-banner-text", text: info.text }), ]; const build = serverBuildLabel(state.serverBuild); if (build) nodes.push(h("span", { class: "conn-build", text: build })); const warning = protocolMismatch(PROTOCOL_VERSION, state.serverProtocol); if (warning) nodes.push(h("span", { class: "conn-warning", text: warning })); connBanner.replaceChildren(...nodes); } function connectionLabel() { const info = stateBadge(state.connection); return h("span", { class: `dot ${info.tone}`, text: info.text }); } // --- Attention / "Needs you" surface (R15) --------------------------------- /** * The attention sheet: the ordered list from the pure `attentionEntries` model, * opened from the bell in the top bar. It is a single managed dialog — Escape, * a backdrop click and the Close button all close it — with the exact app * wording: title `Needs you`, rows of status icon + the run label + the * `{pipeline} · {detail}` line + a trailing `Dismiss`, and the empty state * `Nothing needs you right now.` with no Clear all. * * `state.attentionSnapshot` is captured only when the sheet opens and kept until * it closes, so Clear all acts on what the operator actually saw and an entry * that arrives while it is open is shown but not cleared. */ function renderAttentionSheet() { if (!state.attentionSheetOpen) { attentionLayer.replaceChildren(); return; } const entries = attentionEntries(state.runs, state.attentionDismissed); const overlay = h("div", { class: "attention-sheet", role: "dialog", "aria-modal": "true", "aria-label": "Needs you", }); overlay.addEventListener("click", (event) => { if (event.target === overlay) closeAttentionSheet(); }); const head = h( "div", { class: "attention-sheet-head" }, h("h2", { class: "attention-sheet-title", text: "Needs you" }), h("button", { class: "attention-sheet-close", type: "button", text: "Close", onclick: () => closeAttentionSheet(), }), ); const body = h("div", { class: "attention-sheet-body" }); if (entries.length === 0) { body.append(h("p", { class: "attention-empty", text: "Nothing needs you right now." })); } else { body.append( h("button", { class: "attention-clear", type: "button", text: "Clear all", onclick: clearAttentionSheet, }), ); for (const entry of entries) body.append(renderAttentionRow(entry)); } const sheet = h("div", { class: "attention-sheet-panel", tabindex: "-1" }, head, body); overlay.append(sheet); attentionLayer.replaceChildren(overlay); } /** One attention row: status icon, the two text lines, and a trailing Dismiss. */ function renderAttentionRow(entry) { const glyphState = entry.kind === AttentionKind.Decision ? "waiting" : "failed"; const open = h( "button", { class: "attention-row-open", type: "button", "data-run-id": String(entry.runId), "data-kind": entry.kind.name.toLowerCase(), onclick: () => activateAttentionEntry(entry), }, h("span", { class: `attention-icon chip-${glyphState}`, "aria-hidden": "true", text: stateGlyph(glyphState), }), h( "span", { class: "attention-text" }, h("span", { class: "attention-label", text: entry.label }), h("span", { class: "attention-desc", text: attentionRowDescription(entry) }), ), ); const dismiss = h("button", { class: "attention-dismiss", type: "button", "aria-label": "Dismiss", title: "Dismiss", onclick: (event) => { // The trailing control must never activate the row it sits in. event.stopPropagation(); dismissAttentionEntries([entry]); }, }); dismiss.append(h("span", { "aria-hidden": "true", text: "\u2715" })); return h("div", { class: "attention-row", "data-key": entry.key }, open, dismiss); } /** Open the sheet, capturing the dismissal snapshot it will act on. */ function openAttentionSheet() { state.attentionSheetOpen = true; state.attentionSnapshot = attentionDismissalSnapshot( attentionEntries(state.runs, state.attentionDismissed), ); render(); document.querySelector(".attention-sheet-close")?.focus(); } /** Close the sheet, dropping the snapshot; focus returns to the bell. */ function closeAttentionSheet({ restoreFocus = true } = {}) { if (!state.attentionSheetOpen) return; state.attentionSheetOpen = false; state.attentionSnapshot = null; render(); if (restoreFocus) document.querySelector("#attentionBell")?.focus(); } /** Dismiss one or more entries for good, persisting the identity set. */ function dismissAttentionEntries(entries) { if (!entries?.length) return; let next = new Set(state.attentionDismissed); for (const entry of entries) next = attentionDismiss(next, entry.key); persistAttentionDismissed(next); render(); } /** Clear all applies only the identities captured when the sheet opened. */ function clearAttentionSheet() { const snapshot = state.attentionSnapshot ?? []; const next = attentionDismissAll(state.attentionDismissed, snapshot); persistAttentionDismissed(next); render(); } /** * Activating a row closes the sheet and opens the run. A Failed row is dismissed * first (opening it is the operator dealing with it); a Decision row is not — * only answering the decision clears it. */ function activateAttentionEntry(entry) { if (entry.kind === AttentionKind.Failed) { persistAttentionDismissed(attentionDismiss(state.attentionDismissed, entry.key)); } state.attentionSheetOpen = false; state.attentionSnapshot = null; state.view = "runs"; render(); selectRun(entry.runId); } /** Store the dismissed identities as one JSON array under one localStorage key. */ function persistAttentionDismissed(next) { state.attentionDismissed = next; try { localStorage.setItem(ATTENTION_STORAGE_KEY, encodeAttentionDismissals(next)); } catch { // Storage disabled or full: the in-memory set still applies for this session. } } /** The dismissed identities from storage at boot; anything unreadable is empty. */ function loadAttentionDismissed() { try { return decodeAttentionDismissals(localStorage.getItem(ATTENTION_STORAGE_KEY)); } catch { return new Set(); } } /** * Fold one pushed `run_event` frame into the notification ledger (L5). It does * not touch the runs list (R10's fold is separate); it only decides whether this * transition raises exactly one notification. A run already failed/waiting when * seeded, a duplicate frame, a non-qualifying status and a key the operator * dismissed all produce nothing. */ function onRunAlertFrame(frame) { const alert = runAlerts.observe(frame, { dismissed: state.attentionDismissed }); if (!alert || !notificationsAllowed()) return; try { const notification = new Notification(alert.title, { body: alert.body, tag: alert.key }); notification.onclick = () => { window.focus(); state.view = "runs"; render(); selectRun(alert.runId); }; } catch { // Some browsers can throw even with permission granted; the in-page Needs // you surface remains the only honest channel and nothing is faked. } } /** True only when a real browser notification can be constructed right now. */ function notificationsAllowed() { return ( typeof globalThis.Notification === "function" && globalThis.isSecureContext === true && globalThis.Notification.permission === "granted" ); } /** Persist only the asked flag; never a permission claim, endpoint or credential. */ function persistNotifyAsked(asked) { state.notifyAsked = Boolean(asked); try { localStorage.setItem(NOTIFY_STORAGE_KEY, encodeNotificationSettings({ asked })); } catch { // Storage disabled or full: the in-memory flag still applies for this session. } } /** The asked flag from storage at boot; anything unreadable means never asked. */ function loadNotifyAsked() { try { return decodeNotificationSettings(localStorage.getItem(NOTIFY_STORAGE_KEY)).asked; } catch { return false; } } /** * Start the run-event watch for this connected epoch: seed from the list that is * already in hand, treat the subscribe snapshot as seeds too (the server writes * it before the ack), then observe deltas. A refused subscribe only means no * pushes; the page keeps working and Settings stays honest. */ async function startRunAlertWatch() { runAlerts.seed(state.runs); runAlerts.beginSeed(); try { await repo.subscribeRuns(); } catch { // No live watch: notifications simply cannot raise on this connection. } finally { runAlerts.endSeed(); } } function render() { renderHeader(); renderBanner(); renderSearch(); renderContent(); renderAttentionSheet(); } function renderContent() { // The graph owns wheel/pointer/resize listeners; drop the previous mount // before rebuilding the DOM so a re-render, tab switch or view switch never // leaves an observer or listener behind. if (state.pipelineGraph) { state.pipelineGraph.unmount(); state.pipelineGraph = null; } if (state.runGraph) { state.runGraph.unmount(); state.runGraph = null; } const nodes = []; if (state.error) { nodes.push(h("div", { class: "banner error" }, h("strong", { text: "Error: " }), state.error)); } nodes.push( h( "nav", { class: "tabs" }, tabButton("pipelines", `Pipelines (${state.pipelines.length})`), tabButton("runs", `Runs (${state.runs.length})`), tabButton("templates", "Templates"), tabButton("chat", CHAT_TAB_TITLE), tabButton("settings", "Settings"), h("span", { class: "spacer" }), h("button", { class: "ghost", text: "Refresh", onclick: () => loadCurrentView(true) }), ), ); // Settings is a single-pane destination (not the list/detail split): the // app's own settings page is one scrolled column. if (state.view === "settings") { nodes.push(renderSettingsView()); } else { const split = h("div", { class: "split" }); if (state.view === "pipelines") { split.append(renderPipelineList(), renderPipelineDetail()); } else if (state.view === "runs") { split.append(renderRunList(), renderRunDetail()); } else if (state.view === "chat") { // While the create flow is open it owns the detail pane; the session list // stays visible beside it, exactly as the app's two-pane chat stack does. split.append(renderChatList(), state.chatCreate ? renderChatCreate() : renderChatConversation()); } else { split.append(renderTemplateGallery(), renderTemplateDetail()); } nodes.push(split); } // Capture the live transcript's position before it is replaced, so the very // next render can put the operator back exactly where they were (a dialog, a // refresh or a paging frame must not move them). captureChatPosition(); content.replaceChildren(...nodes); if (state.view === "chat") { afterChatRender(); stopListClock(); stopDetailClock(); refreshChatClock(); return; } stopChatClock(); if (state.view === "runs") { refreshListClock(); refreshDetailClock(); } else { stopListClock(); stopDetailClock(); } } function tabButton(view, label) { return h("button", { class: `tab${state.view === view ? " active" : ""}`, text: label, onclick: () => { // A top-level tab is a real destination: it updates the URL and lets one // route application set the view, selection and any list load. Pushing // first means a load failure can still replace the URL honestly. const route = { kind: view }; pushRoute(route); applyRoute(route); }, }); } // --- Settings (L1) --------------------------------------------------------- /** * The Settings destination: the app's three sections (Connection, Workspace, * Templates) in one pane. It is wiring only — every string, the workspace * validation and the connection card's lines come from the pure `settings.js`, * and the connection controls drive the page's existing single client through * the same handlers the header uses (no second socket or path). Every * server-derived string is set with textContent. */ function renderSettingsView() { const pane = h("div", { class: "settings" }); pane.append( renderSettingsConnection(), renderSettingsWorkspace(), renderSettingsNotifications(), renderSettingsTemplates(), ); return pane; } function renderSettingsConnection() { const section = h("section", { class: "settings-section" }); section.append(h("h2", { class: "settings-title", text: "Connection" })); section.append( h( "label", { class: "settings-field", for: "settingsServerUrl" }, h("span", { class: "settings-field-label", text: "Server URL" }), h("input", { id: "settingsServerUrl", type: "text", placeholder: SERVER_URL_PLACEHOLDER, value: state.url, spellcheck: "false", autocomplete: "off", "aria-describedby": "settingsUrlHelper", "aria-invalid": state.urlError ? "true" : null, oninput: (event) => { setServerUrlDraft(event.target.value, "settingsServerUrl"); }, }), ), ); // Android's `urlError ?: helper` supporting text. The error clears on the next // edit (AppViewModel.updateServerUrlDraft) and is announced as the field's own // invalid state rather than as a page-level banner. section.append( h( "p", { id: "settingsUrlHelper", class: `settings-helper${state.urlError ? " settings-helper-error" : ""}`, role: state.urlError ? "alert" : null, }, serverUrlSupportingText(), ), ); const actions = connectionActions(state.connection); section.append( h( "div", { class: "settings-actions" }, h("button", { id: "settingsPrimary", class: "primary", type: "button", text: actions.primary, onclick: () => runConnectionAction(actions.primary), }), h("button", { id: "settingsSecondary", class: "ghost", type: "button", text: actions.secondary, onclick: () => runConnectionAction(actions.secondary), }), ), ); const tone = bannerState(state.connection, { hasEndpoint: endpointConfigured() }).tone; const card = h("div", { class: `settings-status status-${tone}` }); const lines = connectionCard(state.connection, { version: state.serverBuild?.version, commit: state.serverBuild?.commit, serverTime: state.serverTime, }); lines.forEach((line, index) => { // Android's Connecting card leads its one line with a CircularProgressIndicator; // the shared spinner is drawn only for that state, inline with the text, so the // other three stay plain text. if (index === 0 && state.connection.kind === "connecting") { const row = h("div", { class: "settings-status-head" }); row.append(h("span", { class: "spinner settings-status-spinner", "aria-hidden": "true" })); row.append(h("p", { class: "settings-status-line", text: line })); card.append(row); return; } card.append(h("p", { class: "settings-status-line", text: line })); }); section.append(card, renderTrustWarning()); return section; } /** * The Notifications section (L5). The Android rationale is shown verbatim; the * status line is the pure permission view for this page's real browser facts. * Only the explicit control asks for permission, never page load. When the API * is unavailable, the page is insecure or permission is denied, the wording says * plainly that the in-app Needs you surface is the only channel — no fake * notification is ever drawn. */ function renderSettingsNotifications() { const view = notificationPermissionState({ ...notificationEnvironment(), asked: state.notifyAsked, }); const section = h("section", { class: "settings-section", id: "settingsNotifications" }); section.append(h("h2", { class: "settings-title", text: "Notifications" })); section.append(h("p", { class: "settings-helper", text: NOTIFICATION_RATIONALE })); section.append( h("p", { id: "settingsNotificationState", class: `settings-notify-state settings-notify-${view.state}`, role: "status", text: view.body, }), ); if (view.canRequest) { section.append( h( "div", { class: "settings-actions" }, h("button", { id: "settingsEnableNotifications", class: "primary", type: "button", text: view.actionLabel, onclick: requestNotifications, }), ), ); } return section; } /** * Ask for notification permission from the operator's explicit click. The asked * flag is persisted first and the page re-renders from the browser's real answer; * a refused/dismissed prompt leaves the honest default/denied wording in place. */ function requestNotifications() { persistNotifyAsked(true); const ctor = globalThis.Notification; if (typeof ctor !== "function" || !globalThis.isSecureContext) { renderContent(); return; } try { const result = ctor.requestPermission(); if (result && typeof result.then === "function") { result.then( () => renderContent(), () => renderContent(), ); return; } } catch { // A browser that refuses the request keeps the honest fallback wording. } renderContent(); } /** The trusted-network warning card, SettingsScreen.kt's TrustWarning verbatim. */ function renderTrustWarning() { return h( "div", { class: "settings-warning" }, h("p", { class: "settings-warning-title", text: TRUST_TITLE }), h("p", { class: "settings-warning-body", text: TRUST_BODY }), ); } /** * Route a Settings connection control through the page's existing single client, * mirroring AppViewModel: Disconnect closes the shared socket, Connect is * connect-only (validate + persist + open — never the header's toggle), and * Reconnect re-opens the same validated endpoint now. Nothing here opens a second * connection. */ function runConnectionAction(label) { const kind = connectionActionKind(label); if (kind === "disconnect") { repo.disconnect(); stopRunPoll(); return; } if (kind === "reconnect") { onReconnectClicked(); return; } // The `Connect` label must never fall through to the header's toggle: while // connected that would tear the live socket down (Android's connect() is // connect-only). openConfiguredEndpoint(); } /** Android's `urlError ?: helper` supporting text for the Server URL field. */ function serverUrlSupportingText() { return state.urlError || SERVER_URL_HELPER; } /** * Update the Server URL field's own error state in place (supporting text, * aria-invalid and the error tint) so an invalid Connect never needs a full * re-render and the field being typed in is never rebuilt. */ function refreshServerUrlError() { const field = document.getElementById("settingsServerUrl"); const helper = document.getElementById("settingsUrlHelper"); if (field) { if (state.urlError) field.setAttribute("aria-invalid", "true"); else field.removeAttribute("aria-invalid"); } if (helper) { helper.textContent = serverUrlSupportingText(); helper.classList.toggle("settings-helper-error", Boolean(state.urlError)); if (state.urlError) helper.setAttribute("role", "alert"); else helper.removeAttribute("role"); } } function renderSettingsWorkspace() { const section = h("section", { class: "settings-section" }); section.append(h("h2", { class: "settings-title", text: "Workspace" })); section.append( h( "label", { class: "settings-field", for: "settingsWorkspace" }, h("span", { class: "settings-field-label", text: "Workspace path (on the server)" }), h("input", { id: "settingsWorkspace", type: "text", placeholder: WORKSPACE_PLACEHOLDER, value: state.workspaceDraft, spellcheck: "false", autocomplete: "off", "aria-describedby": "workspaceHelper", "aria-invalid": workspaceErrorText(state.workspaceDraft) ? "true" : null, oninput: (event) => { state.workspaceDraft = event.target.value; refreshWorkspaceControls(); }, }), ), ); section.append( h( "p", { id: "workspaceHelper", class: `settings-helper${workspaceErrorText(state.workspaceDraft) ? " settings-helper-error" : ""}`, }, workspaceSupportingText(), ), ); section.append( h("button", { id: "saveWorkspace", class: "primary settings-save", type: "button", text: "Save workspace", disabled: !canSaveWorkspace(state.workspaceDraft), onclick: saveWorkspace, }), ); section.append(h("p", { id: "savedWorkspace", class: "settings-saved", text: savedWorkspaceLine(state.workspace) })); return section; } /** Android's `workspaceError ?: helper` supporting text for the workspace field. */ function workspaceSupportingText() { return workspaceErrorText(state.workspaceDraft) || WORKSPACE_HELPER; } /** * Update the workspace field's dependent controls in place (the helper/error line * and the Save button's enabled state) so typing never re-renders — and so never * blurs — the field being typed in. */ function refreshWorkspaceControls() { const helper = document.getElementById("workspaceHelper"); const invalid = Boolean(workspaceErrorText(state.workspaceDraft)); if (helper) { helper.textContent = workspaceSupportingText(); helper.classList.toggle("settings-helper-error", invalid); } const field = document.getElementById("settingsWorkspace"); if (field) { if (invalid) field.setAttribute("aria-invalid", "true"); else field.removeAttribute("aria-invalid"); } const save = document.getElementById("saveWorkspace"); if (save) save.disabled = !canSaveWorkspace(state.workspaceDraft); } /** Persist the workspace (trimmed) and update the `Saved workspace:` line. */ function saveWorkspace() { if (!canSaveWorkspace(state.workspaceDraft)) return; state.workspace = writeWorkspace(localStorage, state.workspaceDraft); state.workspaceDraft = state.workspace; // Show the trimmed value that was actually stored, in the field as well as the // saved line (both updated in place so the keyboard focus is not disturbed). const field = document.getElementById("settingsWorkspace"); if (field) field.value = state.workspace; const saved = document.getElementById("savedWorkspace"); if (saved) saved.textContent = savedWorkspaceLine(state.workspace); } /** * Reset the template detail/create state that belongs to a selection. Shared by * selecting a template and opening the gallery from Settings, so the two lists of * fields can never drift. */ function resetTemplateCreateState() { state.templateTab = "summary"; // A different template reseeds the create dialog, so a name typed for one // template can never be submitted against another. state.templateCreateOpen = false; state.templateCreateName = ""; state.templateCreateSending = false; state.templateCreateError = ""; state.templateCreateCreated = null; } /** Clear the selection and everything that belongs to it. */ function resetTemplateSelection() { state.selectedTemplateKey = null; resetTemplateCreateState(); } /** * Open the existing Templates gallery (L1's one card): switch the view, clear any * selection/detail left from a previous visit and render. The gallery itself is * unchanged — this is the same destination the Templates tab opens. */ function openTemplatesFromSettings() { const route = { kind: "templates" }; pushRoute(route); applyRoute(route); } function renderSettingsTemplates() { const section = h("section", { class: "settings-section" }); section.append(h("h2", { class: "settings-title", text: "Templates" })); const card = h( "button", { id: "browseTemplates", class: "card settings-card", type: "button", onclick: openTemplatesFromSettings, }, // SettingsScreen.kt's row idiom: a leading glyph, the label and secondary // line, then a forward chevron. h("span", { class: "settings-card-glyph", "aria-hidden": "true", text: "\u25a4" }), h( "span", { class: "settings-card-text" }, h("span", { class: "card-name", text: TEMPLATES_CARD_LABEL }), h("span", { class: "card-desc", text: TEMPLATES_CARD_SECONDARY }), ), h("span", { class: "settings-card-chevron", "aria-hidden": "true", text: "\u203a" }), ); section.append(card); return section; } function renderPipelineList() { const list = h("div", { class: "list" }); list.append(renderPipelineControls()); const rows = h("div", { id: "pipelineRows" }); fillPipelineRows(rows); list.append(rows); return list; } /** * The list's filter + sort toolbar and (when open) the matching menu panel. The * rows themselves live in the separate `#pipelineRows` container so a keystroke * in the name filter can refresh just the rows without rebuilding (and so * blurring) the input the operator is typing in. */ function renderPipelineControls() { const filters = state.pipelineFilters; const count = pipelineFilterCount(filters); const panel = state.pipelineMenu; const controls = h( "div", { class: "list-controls" }, h( "div", { class: "list-toolbar" }, h( "button", { id: "filterToggle", class: `control${panel === "filter" ? " active" : ""}`, onclick: () => { state.pipelineMenu = panel === "filter" ? null : "filter"; renderContent(); }, }, h("span", { text: "Filter" }), h("span", { id: "filterCount", class: "count", text: count ? ` (${count})` : "" }), ), h("button", { id: "sortToggle", class: `control${panel === "sort" ? " active" : ""}`, text: `Sort: ${pipelineSortLabel(state.pipelineSort)}`, onclick: () => { state.pipelineMenu = panel === "sort" ? null : "sort"; renderContent(); }, }), h("button", { id: "clearFilters", class: "ghost clear", text: "Clear filters", hidden: count === 0, onclick: clearPipelineFilters, }), ), ); if (panel === "filter") controls.append(renderFilterPanel()); if (panel === "sort") controls.append(renderSortPanel()); return controls; } function renderFilterPanel() { const filters = state.pipelineFilters; const panel = h("div", { class: "menu-panel filter-panel" }); panel.append(h("div", { class: "filter-section", text: "Name" })); panel.append( h( "label", { class: "filter-field" }, h("span", { class: "filter-field-label", text: "Pipeline name contains" }), h("input", { id: "pipelineNameFilter", type: "text", value: filters.name, spellcheck: "false", oninput: (e) => { state.pipelineFilters = { ...state.pipelineFilters, name: e.target.value }; // Targeted refresh: the input keeps focus and its value while the // list narrows behind it. refreshPipelineRows(); }, }), ), ); panel.append(h("div", { class: "filter-section", text: "Runs" })); for (const presence of RUN_PRESENCES) { panel.append( h( "label", { class: "filter-item" }, h("input", { type: "radio", name: "runPresence", checked: filters.presence === presence.key, onchange: () => { state.pipelineFilters = { ...state.pipelineFilters, presence: presence.key }; renderContent(); }, }), h("span", { text: presence.label }), ), ); } panel.append(h("div", { class: "filter-section", text: "Last run status" })); for (const status of RUN_STATUS_FILTERS) { panel.append( h( "label", { class: "filter-item" }, h("input", { id: `status-${status}`, type: "checkbox", checked: filters.lastRunStatuses.includes(status), onchange: (e) => { const next = e.target.checked ? [...state.pipelineFilters.lastRunStatuses, status] : state.pipelineFilters.lastRunStatuses.filter((s) => s !== status); state.pipelineFilters = { ...state.pipelineFilters, lastRunStatuses: next }; renderContent(); }, }), h("span", { text: status }), ), ); } panel.append( h("div", { class: "filter-actions" }, h("button", { class: "ghost", text: "Clear filters", onclick: clearPipelineFilters })), ); return panel; } function renderSortPanel() { const panel = h("div", { class: "menu-panel sort-panel" }); for (const option of PIPELINE_SORTS) { panel.append( h("button", { class: `sort-option${state.pipelineSort === option.key ? " active" : ""}`, text: option.label, onclick: () => { state.pipelineSort = option.key; state.pipelineMenu = null; renderContent(); }, }), ); } panel.append( h( "div", { class: "filter-actions" }, h("button", { class: "ghost", text: "Reset", onclick: () => { state.pipelineSort = "server_order"; state.pipelineMenu = null; renderContent(); }, }), ), ); return panel; } /** Re-renders the rows and the toolbar's active-filter badge after a filter change. */ function refreshPipelineRows() { const rows = document.getElementById("pipelineRows"); if (rows) fillPipelineRows(rows); const count = pipelineFilterCount(state.pipelineFilters); const badge = document.getElementById("filterCount"); if (badge) badge.textContent = count ? ` (${count})` : ""; const clear = document.getElementById("clearFilters"); if (clear) clear.hidden = count === 0; } /** Sorts, filters and renders the pipeline rows (or the matching empty state) into `rowsEl`. */ function fillPipelineRows(rowsEl) { const latestRuns = latestRunByPipeline(state.runs); const runsKnown = state.runsLoaded; const now = Date.now(); const nodes = []; if (state.loading && !state.pipelines.length) { nodes.push(h("div", { class: "muted pad", text: "Loading pipelines…" })); } else if (!state.pipelinesLoaded) { nodes.push(h("div", { class: "muted pad", text: "Connect to the server to load pipelines." })); } else { const sorted = sortPipelines(state.pipelines, state.pipelineSort, latestRuns); const items = filterPipelines(sorted, state.pipelineFilters, latestRuns, runsKnown); if (items.length) { for (const pipeline of items) nodes.push(renderPipelineRow(pipeline, latestRuns, runsKnown, now)); } else { const empty = pipelineListEmptyState(state.pipelines, items, state.pipelineFilters); const box = h("div", { class: "empty pad" }, h("div", { class: "muted", text: empty.message })); if (empty.clearAction) { box.append(h("button", { class: "ghost", text: empty.clearAction, onclick: clearPipelineFilters })); } nodes.push(box); } } rowsEl.replaceChildren(...nodes); } function renderPipelineRow(pipeline, latestRuns, runsKnown, now) { const children = [ h("span", { class: "row-title", text: pipeline.name || `pipeline ${pipeline.id}` }), h("span", { class: "row-meta", text: pipelineSubtitle(pipeline) }), ]; const updated = pipelineUpdatedLine(pipeline); if (updated) children.push(h("span", { class: "row-meta", text: updated })); if (runsKnown) { const run = latestRuns.get(pipeline.id); if (!run) { children.push(h("span", { class: "row-meta muted", text: "no runs recorded" })); } else { const badge = runBadge(run, now); children.push( h( "span", { class: "row-run" }, h("span", { class: `chip chip-${badge.state}`, text: badge.state }), h("span", { class: "row-meta", text: runBadgeMetaLine(badge) }), ), ); } } return h( "button", { class: `row${state.selectedPipelineId === pipeline.id ? " selected" : ""}`, onclick: () => selectPipeline(pipeline) }, ...children, ); } function renderPipelineDetail() { const d = state.pipelineDetail; const pane = h("div", { class: "detail" }); if (!d) { pane.append(h("div", { class: "muted pad", text: "Select a pipeline." })); return pane; } pane.append(h("h2", { text: d.name || `pipeline ${d.id}` })); pane.append( h( "div", { class: "detail-tabs" }, ...PIPELINE_DETAIL_TABS.map((tab) => h("button", { class: `detail-tab${state.pipelineTab === tab.key ? " active" : ""}`, text: tab.label, onclick: () => { state.pipelineTab = tab.key; renderContent(); }, }), ), ), ); if (state.pipelineTab === "graph") { pane.append(h("p", { class: "graph-note muted", text: graphNote() })); const stages = d.graph?.stages ?? []; if (!stages.length) { pane.append(h("div", { class: "muted pad", text: PIPELINE_GRAPH_EMPTY })); return pane; } const host = h("div", { class: "graph-host" }); pane.append(host); state.pipelineGraph = mountGraph(host, d.graph, { expanded: state.pipelineGraphExpanded, selectedKey: state.pipelineGraphSelection, onSelectionChange: (key) => { // The graph has already opened or closed its own definition pane; record // the destination in the URL without rebuilding the graph. state.pipelineGraphSelection = key; const id = state.selectedPipelineId; if (!id) return; const version = state.pipelineRequestedVersion ?? 0; pushRoute( key ? { kind: "pipelineStage", id, version, stageKey: key } : { kind: "pipeline", id, version }, ); }, onExpandedChange: (value) => { state.pipelineGraphExpanded = value; }, }); return pane; } if (state.pipelineTab === "source") { pane.append(h("pre", { class: "source-code" }, h("code", { text: d.source || "" }))); return pane; } pane.append(h("div", { class: "detail-subtitle muted", text: pipelineSubtitle({ ...d, stages: d.graph?.stages?.length ?? d.stages }) })); const rows = h("div", { class: "kv" }); for (const field of summaryFields(d)) { rows.append( h( "div", { class: "kv-row" }, h("span", { class: "kv-key", text: field.key }), h("span", { class: `kv-val${field.monospace ? " monospace" : ""}`, text: field.value }), ), ); } pane.append(rows); pane.append( h( "button", { class: "section-toggle", onclick: () => { state.versionsExpanded = !state.versionsExpanded; renderContent(); }, }, h("span", { class: "chevron", text: state.versionsExpanded ? "\u25be" : "\u25b8" }), h("span", { text: "Versions" }), ), ); if (state.versionsExpanded) { const versions = d.versions ?? []; const body = h("div", { class: "section-body versions-list" }); if (!versions.length) { body.append(h("div", { class: "muted", text: "No versions recorded." })); } else { for (const version of versions) { const row = versionRow(version); body.append( h( "div", { class: "version-row" }, h("span", { class: "version-title", text: row.versionLabel }), h("span", { class: "muted", text: row.stagesText }), row.createdText ? h("span", { class: "muted", text: row.createdText }) : null, ), ); } } pane.append(body); } return pane; } // --- Templates ------------------------------------------------------------- /** The cached parsed graph for a template key, or null when it did not parse. */ function templateGraphFor(key) { return state.templateGraphs.has(key) ? state.templateGraphs.get(key) : null; } function renderTemplateGallery() { const pane = h("div", { class: "list gallery" }); pane.append( h( "div", { class: "pane-head" }, h("h2", { text: "Templates" }), h("button", { class: "ghost", text: "Refresh templates", onclick: () => loadTemplates(true) }), ), ); if (state.templateLoading && !state.templates.length) { pane.append(h("div", { class: "muted pad", text: "Loading templates…" })); return pane; } if (!state.templates.length) { pane.append(h("div", { class: "muted pad", text: "No templates are available on this server." })); return pane; } const cards = h("div", { class: "cards" }); for (const entry of state.templates) { const card = templateCard(entry, templateGraphFor(entry.key)); cards.append( h( "button", { class: `card${state.selectedTemplateKey === entry.key ? " selected" : ""}`, onclick: () => selectTemplate(entry.key), }, h("span", { class: "card-name", text: templateGalleryName(card.name) }), h("span", { class: "card-desc", text: card.description }), h("span", { class: "card-meta", text: templateStageCountLabel(card.stageCount) }), ), ); } pane.append(cards); return pane; } function renderTemplateDetail() { const pane = h("div", { class: "detail" }); const entry = state.templates.find((t) => t.key === state.selectedTemplateKey); if (!entry) { pane.append(h("div", { class: "muted pad", text: "Select a template." })); return pane; } const graph = templateGraphFor(entry.key); pane.append(renderTemplateDetailActions()); pane.append( h( "div", { class: "tabstrip" }, templateTabButton("summary", "Summary"), templateTabButton("graph", "Graph"), templateTabButton("source", "Source"), ), ); if (state.templateTab === "graph") pane.append(renderTemplateGraphTab(graph)); else if (state.templateTab === "source") pane.append(renderTemplateSourceTab(entry, graph)); else pane.append(renderTemplateSummaryTab(entry, graph)); if (state.templateCreateOpen) pane.append(renderTemplateCreateDialog(entry)); return pane; } /** * The template detail's action row: the one "Create pipeline from this * template" action (P5), matching the app's top-bar add action. It opens the * dialog; it never submits on its own. */ function renderTemplateDetailActions() { return h( "div", { class: "detail-actions" }, h("button", { class: "ghost template-create-open", type: "button", text: CREATE_ACTION_LABEL, onclick: () => openTemplateCreateDialog(), }), ); } /** Open the create dialog with a fresh, empty name; nothing is sent until Create. */ function openTemplateCreateDialog() { state.templateCreateOpen = true; state.templateCreateName = ""; state.templateCreateSending = false; state.templateCreateError = ""; state.templateCreateCreated = null; renderContent(); document.querySelector(".template-create-name")?.focus(); } /** Dismiss the create dialog (never while a validate+submit is in flight). */ function closeTemplateCreateDialog() { if (state.templateCreateSending) return; state.templateCreateOpen = false; state.templateCreateName = ""; state.templateCreateError = ""; state.templateCreateCreated = null; renderContent(); } /** * The create dialog (P5): the title, the one required name field, the note, the * server's refusal text or the success line, and Create/Cancel (Cancel reads * Close after a success). Create is disabled while the name is blank or while * sending; the field locks while sending and after a success. Every server * string is set with textContent. */ function renderTemplateCreateDialog(entry) { const title = createFormTitle(entry); const overlay = h("div", { class: "template-create-dialog", role: "dialog", "aria-modal": "true", "aria-label": title, }); overlay.addEventListener("click", (event) => { if (event.target === overlay) closeTemplateCreateDialog(); }); const panel = h("div", { class: "template-create-panel" }); panel.append(h("h2", { class: "template-create-title", text: title })); const field = h("label", { class: "template-create-field" }); field.append(h("span", { class: "template-create-label", text: CREATE_NAME_LABEL })); field.append( h("input", { class: "template-create-name", type: "text", value: state.templateCreateName, spellcheck: "false", autocomplete: "off", disabled: state.templateCreateSending || state.templateCreateCreated != null, oninput: (event) => { // Update in place (no re-render) so the field keeps focus and its caret; // only the confirm button's enabled state depends on the name. state.templateCreateName = event.target.value; const confirm = overlay.querySelector(".template-create-confirm"); if (confirm) { confirm.disabled = !createFormValid(state.templateCreateName, { sending: state.templateCreateSending, created: state.templateCreateCreated, }); } }, }), ); panel.append(field); panel.append(h("p", { class: "template-create-note muted", text: CREATE_NOTE })); if (state.templateCreateError) { panel.append(h("div", { class: "template-create-error bad", text: state.templateCreateError })); } if (state.templateCreateCreated != null) { panel.append( h("div", { class: "template-create-success", text: createSuccessMessage(state.templateCreateCreated), }), ); } const actions = h("div", { class: "template-create-actions" }); actions.append( h("button", { class: "ghost template-create-cancel", type: "button", text: createDismissLabel(state.templateCreateCreated), disabled: state.templateCreateSending, onclick: closeTemplateCreateDialog, }), ); actions.append( h("button", { class: "template-create-confirm", type: "button", text: createConfirmLabel(state.templateCreateSending), disabled: !createFormValid(state.templateCreateName, { sending: state.templateCreateSending, created: state.templateCreateCreated, }), onclick: () => createFromTemplate(entry), }), ); panel.append(actions); overlay.append(panel); return overlay; } /** * The P5 submit flow, exactly the app's: validate the template's source first * and, when the server refuses to parse it, show its own error in the dialog and * send nothing; otherwise submit the source create-only with the chosen name. On * success remember the created name, refresh the pipeline list so the new row is * visible and leave the dialog open (Cancel now reads Close); on failure show * the server's error without closing. */ async function createFromTemplate(entry) { if ( !createFormValid(state.templateCreateName, { sending: state.templateCreateSending, created: state.templateCreateCreated, }) ) { return; } const name = state.templateCreateName; state.templateCreateSending = true; state.templateCreateError = ""; renderContent(); try { await repo.validate(entry.source); } catch (error) { state.templateCreateSending = false; state.templateCreateError = describeError(error); renderContent(); return; } try { const detail = await repo.submit(name, entry.source); state.templateCreateSending = false; state.templateCreateCreated = createdPipelineName(detail, name); await refreshPipelines(); } catch (error) { state.templateCreateSending = false; state.templateCreateError = describeError(error); } renderContent(); } /** * Refresh just the pipeline summaries after a create so the new row appears when * the operator returns to the Pipelines list. A failed refresh keeps the created * name and is surfaced through the banner rather than discarded. */ async function refreshPipelines() { try { state.pipelines = await repo.listPipelines(); state.pipelinesLoaded = true; } catch (error) { state.error = describeError(error); } } function templateTabButton(tab, label) { return h("button", { class: `minitab${state.templateTab === tab ? " active" : ""}`, text: label, onclick: () => { state.templateTab = tab; renderContent(); }, }); } function renderTemplateSummaryTab(entry, graph) { const wrap = h("div", { class: "tabbody" }); wrap.append(h("h2", { text: templateDetailName(entry) })); if ((entry.description ?? "").trim()) { wrap.append(h("p", { class: "body", text: entry.description })); } wrap.append(h("div", { class: "kv" }, kvMono("Key", entry.key))); wrap.append( h("div", { class: "meta-line", text: templateStageCountLabel(graph?.stages?.length ?? null) }), ); if (entry.scheduled) wrap.append(h("div", { class: "meta-line", text: "Includes a schedule" })); const summary = templateStageSummary(graph); if (summary.note) { wrap.append(h("div", { class: "muted pad", text: summary.note })); return wrap; } wrap.append(h("h3", { text: "Stages" })); const ul = h("ul", { class: "stages" }); for (const stage of summary.stages) { ul.append( h( "li", {}, h("code", { text: stage.key }), h("span", { class: "chip", text: effectiveStageType(stage.type) }), ), ); } wrap.append(ul); return wrap; } function renderTemplateGraphTab(graph) { const wrap = h("div", { class: "tabbody" }); wrap.append(h("p", { class: "muted", text: templateGraphNote(graph) })); return wrap; } function renderTemplateSourceTab(entry, graph) { const wrap = h("div", { class: "tabbody" }); if (graph == null) { wrap.append(h("p", { class: "muted", text: TEMPLATE_UNPARSED_SOURCE_NOTE })); } wrap.append( h( "div", { class: "codeblock" }, h("div", { class: "codeblock-label", text: "Definition source" }), h("pre", { class: "codeblock-body", text: entry.source ?? "" }), ), ); return wrap; } function pipelineSortLabel(key) { return (PIPELINE_SORTS.find((option) => option.key === key) ?? PIPELINE_SORTS[0]).label; } function clearPipelineFilters() { state.pipelineFilters = { ...EMPTY_PIPELINE_FILTERS }; renderContent(); } function renderRunList() { const pane = h("div", { class: "list runs" }); pane.append(renderRunToolbar()); const scroll = h("div", { class: "run-scroll" }); if (state.loading && !state.runs.length) { scroll.append(h("div", { class: "muted pad", text: "Loading…" })); pane.append(scroll); return pane; } const filters = state.runFilters; const today = localDayKey(new Date()); const filtered = filterRuns(state.runs, filters, today); const groups = groupRunsByDay(filtered, today, undefined, runComparator(state.runSort)); const entries = runListEntries( state.usage, state.runs.length === 0, filtered.length === 0 && state.runs.length > 0, groups, "", ); for (const entry of entries) { switch (entry.kind) { case "usage": scroll.append(renderUsage(entry.usage)); break; case "empty": scroll.append(renderEmptyState(entry)); break; case "day": scroll.append(h("div", { class: "day-header", text: entry.label })); break; case "run": scroll.append(renderRunRow(entry.run)); break; case "error": scroll.append(h("div", { class: "run-list-error", text: entry.message })); break; } } pane.append(scroll); return pane; } function renderUsage(usage) { const metrics = h("div", { class: "metrics" }); metrics.append(metric("Total", String(usage.total ?? 0), "total")); if ((usage.average_seconds ?? 0) > 0) { metrics.append(metric("Average", formatDuration(usage.average_seconds), "average")); } metrics.append(metric("Succeeded", String(usage.succeeded ?? 0), "succeeded")); metrics.append(metric("Failed", String(usage.failed ?? 0), "failed")); metrics.append(metric("Canceled", String(usage.canceled ?? 0), "canceled")); metrics.append(metric("Interrupted", String(usage.interrupted ?? 0), "interrupted")); metrics.append(metric("Active", String(usage.active ?? 0), "active")); return metrics; } function metric(label, value, cls) { return h( "div", { class: `metric metric-${cls}` }, h("span", { class: "metric-value", text: value }), h("span", { class: "metric-label", text: label }), ); } function renderEmptyState(entry) { const wrap = h("div", { class: "empty-state" }, h("span", { text: entry.message })); if (entry.actionLabel) { wrap.append(h("button", { class: "ghost", text: entry.actionLabel, onclick: clearRunFilters })); } return wrap; } /** * One run row, in the app's exact hierarchy: status chip (+ spinner while * executing); primary line = stored title else pipeline name, carrying the * version chip when there is no title; the pipeline name + version chip on a * second line only when a title exists; the progress line; the meta line; and * the diagnostic line, in the error colour only on a failure. Every * server-provided string is set with textContent. */ function renderRunRow(run) { const status = runStateOf(run.status); const identity = runIdentity(run.title, run.name); const row = h("button", { class: `row run-row${state.selectedRunId === run.id ? " selected" : ""}`, onclick: () => selectRun(run.id), }); const head = h("span", { class: "run-row-head" }); head.append(h("span", { class: `chip chip-${status}`, text: status })); if (run.executing) head.append(h("span", { class: "spinner", "aria-hidden": "true" })); head.append(h("span", { class: "run-row-title", text: identity.label })); if (identity.pipeline == null) head.append(versionChip(run.version)); row.append(head); if (identity.pipeline != null) { row.append( h( "span", { class: "run-row-pipeline" }, h("span", { class: "run-row-pipeline-name", text: identity.pipeline }), versionChip(run.version), ), ); } row.append(h("span", { class: "run-row-progress", text: progressText(run) })); row.append( h("span", { class: "run-row-meta", "data-run-id": String(run.id), text: metaText(run, listNow), }), ); if (String(run.diagnostic ?? "").trim()) { row.append( h("span", { class: `run-row-diag${status === "failed" ? " error" : ""}`, text: run.diagnostic, }), ); } return row; } function versionChip(version) { return h("span", { class: "version-chip", text: versionLabel(version) }); } function renderRunToolbar() { const activeCount = runFiltersActiveCount(state.runFilters); const filterLabel = activeCount > 0 ? `Filter (${activeCount})` : "Filter"; const sortLabel = (RUN_SORTS.find((s) => s.value === state.runSort) ?? RUN_SORTS[0]).label; const toolbar = h("div", { class: "run-toolbar" }); toolbar.append( h( "div", { class: "menu-anchor" }, h("button", { id: "runFilterBtn", class: `ghost filter-btn${activeCount > 0 ? " active" : ""}`, title: activeCount > 0 ? `${activeCount} active filter${activeCount === 1 ? "" : "s"}` : "Filter runs", text: filterLabel, "data-active-count": String(activeCount), onclick: () => toggleMenu("filter"), }), state.openMenu === "filter" ? renderFilterMenu() : null, ), h( "div", { class: "menu-anchor" }, h("button", { id: "runSortBtn", class: "ghost sort-btn", title: "Sort runs", text: `Sort: ${sortLabel}`, onclick: () => toggleMenu("sort"), }), state.openMenu === "sort" ? renderSortMenu() : null, ), h("span", { class: "spacer" }), renderLiveBadge(liveBadgeState({ executing: state.runs.some((run) => run.executing) }, state.connection)), ); return toolbar; } /** One small live-stream badge (LiveBadge.kt): a dot plus the honest word. */ function renderLiveBadge(info) { return h( "span", { class: `live-badge live-${info.tone}`, title: info.title ?? "Live run stream" }, h("span", { class: "live-dot", "aria-hidden": "true" }), h("span", { class: "live-word", text: info.label }), ); } function renderFilterMenu() { const filters = state.runFilters; const menu = h("div", { class: "menu filter-menu", id: "runFilterMenu" }); menu.append(h("div", { class: "menu-section", text: "Status" })); for (const status of RUN_STATES) { menu.append( filterCheck(status, filters.statuses.has(status), () => toggleStatusFilter(status), { "data-status": status, }), ); } menu.append(h("div", { class: "menu-divider" })); menu.append(h("div", { class: "menu-section", text: "Pipeline" })); menu.append( filterCheck("Any pipeline", filters.pipelineId == null, () => setPipelineFilter(null), { "data-pipeline": "any", }), ); for (const option of pipelineFilterOptions(state.runs)) { menu.append( filterCheck(option.name, filters.pipelineId === option.id, () => setPipelineFilter(option.id), { "data-pipeline": String(option.id), }), ); } menu.append(h("div", { class: "menu-divider" })); menu.append(h("div", { class: "menu-section", text: "Time range" })); for (const range of RUN_TIME_RANGES) { menu.append( filterCheck(range.label, filters.timeRange === range.value, () => setTimeRangeFilter(range.value), { "data-time": range.value, }), ); } menu.append( h( "div", { class: "menu-actions" }, h("button", { class: "ghost", text: "Clear filters", onclick: clearRunFilters }), h("button", { class: "ghost", text: "Done", onclick: closeMenu }), ), ); return menu; } function filterCheck(label, checked, onclick, data = {}) { return h( "label", { class: "filter-check" }, h("input", { type: "checkbox", checked: checked ? "checked" : null, onchange: onclick, ...data, }), h("span", { text: label }), ); } function renderSortMenu() { const menu = h("div", { class: "menu sort-menu", id: "runSortMenu" }); for (const option of RUN_SORTS) { menu.append( h("button", { class: `menu-item${state.runSort === option.value ? " selected" : ""}`, text: option.label, onclick: () => { state.runSort = option.value; closeMenu(); }, }), ); } menu.append(h("div", { class: "menu-divider" })); menu.append( h("button", { class: "menu-item", text: "Reset", onclick: () => { state.runSort = DEFAULT_RUN_SORT; closeMenu(); }, }), ); return menu; } function toggleStatusFilter(status) { const next = new Set(state.runFilters.statuses); if (next.has(status)) next.delete(status); else next.add(status); state.runFilters = { ...state.runFilters, statuses: next }; renderContent(); } function setPipelineFilter(pipelineId) { state.runFilters = { ...state.runFilters, pipelineId }; closeMenu(); } function setTimeRangeFilter(timeRange) { state.runFilters = { ...state.runFilters, timeRange }; closeMenu(); } function clearRunFilters() { state.runFilters = defaultRunFilters(); closeMenu(); } function toggleMenu(name) { state.openMenu = state.openMenu === name ? null : name; renderContent(); } function closeMenu() { state.openMenu = null; renderContent(); } /** * The run detail: a tab strip (Summary / Graph / Input / Output / Timeline) over * the selected tab's body, wired from the pure helpers in runDetail.js. Summary * is the default and carries the run's identity, key/value rows and diagnostic; * the Graph tab mounts the shared workflow graph in run mode; Input/Output are * one collapsed section per recorded field; the Timeline is one compact row per * visit that opens the stage pane. Every server string is set with textContent, * never innerHTML. */ function renderRunDetail() { const d = state.runDetail; const pane = h("div", { class: "detail run-detail" }); if (!d) { pane.append(h("div", { class: "muted pad", text: "Select a run." })); return pane; } // A run parked on a person surfaces its decision above the tabs, exactly where // the Android run detail does, so opening the run is enough — no tab hunt. const decision = pendingDecision(d); if (decision) pane.append(renderDecisionCard(decision)); const actions = renderRunActions(d); if (actions) pane.append(actions); pane.append( h( "div", { class: "detail-tabs" }, ...RENDERED_RUN_TABS.map((tab) => h("button", { class: `detail-tab${state.runTab === tab.key ? " active" : ""}`, text: tab.label, onclick: () => { state.runTab = tab.key; renderContent(); }, }), ), ), ); if (state.runTab === "graph") { pane.append(renderRunGraphTab(d)); } else if (state.runTab === "input") { pane.append(renderRunFieldTab(d.input, "input", EMPTY_INPUT_MESSAGE)); } else if (state.runTab === "output") { pane.append(renderRunFieldTab(d.output, "output", EMPTY_OUTPUT_MESSAGE)); } else if (state.runTab === "steps") { pane.append(renderRunTimelineTab(d)); } else { pane.append(renderRunSummaryTab(d)); } if (state.runStagePane) pane.append(renderStagePane(d)); if (state.decisionOpen && state.runDecision) pane.append(renderDecisionSheet(state.runDecision)); const confirm = renderConfirmDialog(d); if (confirm) pane.append(confirm); if (state.actionError) pane.append(renderActionFailedDialog()); return pane; } /** * The Graph tab (R5): the run's own guidance note plus the shared workflow graph * mounted in run mode, or the app's exact missing-graph sentence when the server * sent no stages. The active stage pulses with its elapsed time while the run * executes; clicking a stage opens the existing visit pane at that stage's most * recent visit. The mount handle is tracked in `state.runGraph` so a re-render * (or a tab/run change) always unmounts the previous wheel/pointer/resize * listeners and the elapsed timer. */ function renderRunGraphTab(d) { const wrap = h("div", { class: "run-tab-body" }); const stages = d.graph?.stages ?? []; if (!stages.length) { wrap.append(h("div", { class: "run-empty muted", text: RUN_GRAPH_MISSING })); return wrap; } wrap.append(h("p", { class: "graph-note muted", text: RUN_GRAPH_NOTE })); const host = h("div", { class: "graph-host" }); wrap.append(host); state.runGraph = mountGraph(host, d.graph, { runState: runGraphState(d), onStageTap: (key) => openStagePane(key, latestVisitIndex(d, key)), }); return wrap; } /** * The visit index the graph opens for a stage: its most recent recorded visit * (`visits.size - 1`, never negative), exactly as RunGraphTab computes it. */ function latestVisitIndex(d, key) { const visits = runTimeline(d.steps ?? []).visitsByStage.get(key) ?? []; return Math.max(0, visits.length - 1); } /** The Summary tab: identity, chip row, key/value rows, diagnostic and gallery. */ function renderRunSummaryTab(d) { const wrap = h("div", { class: "run-tab-body" }); wrap.append(renderRunTitleRow(d)); const status = runStateOf(d.status); const chips = h("div", { class: "run-chip-row" }); chips.append(h("span", { class: `chip chip-${status}`, text: d.status || status })); if (String(d.outcome ?? "").trim()) chips.append(h("span", { class: "muted", text: `outcome ${d.outcome}` })); if (d.executing) chips.append(h("span", { class: "muted", text: "executing" })); chips.append(renderLiveBadge(liveBadgeState(d, state.connection))); wrap.append(chips); wrap.append(h("div", { class: "run-identity muted", text: runIdentityLine(d) })); const rows = h("div", { class: "kv" }); for (const row of summaryRows(d, detailNow)) { if (row.kind === "wait") rows.append(h("div", { class: "run-wait", text: row.value })); else if (row.kind === "duration") rows.append(renderDurationRow(d, row)); else if (row.kind === "block") rows.append(renderCodeBlock(row.key, row.value)); else rows.append(renderKvRow(row)); } wrap.append(rows); // The run-level artifacts gallery (parity R8), collapsed by default like the // Android summary. Its header alone says what was captured until expanded. wrap.append( renderCollapsible("summary-artifacts", artifactsHeader(d.steps ?? [], isExecuting(d)), () => renderArtifactGallery(d.steps ?? []), ), ); // The run-level Changes (parity R4), collapsed by default like the Android // summary: the observed workspace diff. Its header alone states the file count // and aggregate stat until expanded, and every file row opens the diff viewer. const changes = runChanges(d.steps ?? []); wrap.append( renderCollapsible("summary-changes", runChangesHeader(changes), () => renderChangesBody(changes)), ); return wrap; } /** The Duration row, tagged so the detail clock can update it in place. */ function renderDurationRow(d, row) { return h( "div", { class: "kv-row" }, h("span", { class: "kv-key", text: row.key }), h("span", { class: "kv-val run-duration", "data-run-id": String(d.id), text: row.value }), ); } /** One key/value row from a summary row model. */ function renderKvRow(row) { return h( "div", { class: "kv-row" }, h("span", { class: "kv-key", text: row.key }), h("span", { class: `kv-val${row.monospace ? " monospace" : ""}`, text: row.value }), ); } /** A themed monospace block with a label header. */ function renderCodeBlock(label, text) { return h( "div", { class: "codeblock" }, h("div", { class: "codeblock-label", text: label }), h("pre", { class: "codeblock-body", text }), ); } /** One stage-pane field as either the code card (blocks) or a key/value row. */ function renderStageField(field) { if (field.block) return renderCodeBlock(field.label, field.value); return h( "div", { class: "kv-row" }, h("span", { class: "kv-key", text: field.label }), h("span", { class: `kv-val${field.mono ? " monospace" : ""}`, text: field.value }), ); } /** One collapsible input/output field section (expanded body is a code block). */ function renderRunFieldTab(map, keyPrefix, emptyMessage) { const wrap = h("div", { class: "run-tab-body" }); const sections = fieldSections(map, keyPrefix); if (!sections.length) { wrap.append(h("div", { class: "run-empty muted", text: emptyMessage })); return wrap; } for (const section of sections) { const key = `${keyPrefix}-${section.key}`; wrap.append( renderCollapsible(key, section.title, () => h("pre", { class: "field-block" }, h("code", { text: section.value })), ), ); } return wrap; } /** * One collapsible section of the run detail's field/summary body. Expanded state * is keyed in `state.runSections`, so the operator's choices survive a re-render. */ function renderCollapsible(key, title, bodyFn) { const expanded = state.runSections.has(key); const wrap = h("div", { class: "collapsible" }); wrap.append( h( "button", { class: "section-toggle", type: "button", "aria-expanded": expanded ? "true" : "false", onclick: () => { state.runSections = new Set(state.runSections); if (state.runSections.has(key)) state.runSections.delete(key); else state.runSections.add(key); renderContent(); }, }, h("span", { class: "chevron", text: expanded ? "\u25be" : "\u25b8" }), h("span", { class: "section-title", text: title }), ), ); if (expanded) wrap.append(h("div", { class: "section-body" }, bodyFn())); return wrap; } // --- Changes (parity R4) --------------------------------------------------- /** * The Changes section body: the file-list summary line, the honest capture note * (when the capture was not complete) and then either the no-change detail or * one clickable row per changed file in first-seen order. Every server string is * set as text, never as markup. */ function renderChangesBody(changes) { const body = h("div", { class: "changes" }); body.append(h("div", { class: "changes-summary", text: changesListSummary(changes) })); const note = runChangesNote(changes); if (note.trim() !== "") body.append(h("div", { class: "changes-note muted", text: note })); if (changes.files.length === 0) { body.append(h("div", { class: "changes-empty muted", text: noChangeDetail(changes) })); return body; } const list = h("div", { class: "changes-list" }); changes.files.forEach((entry, index) => list.append(renderChangeRow(entry, index, changes.files))); body.append(list); return body; } /** The tone class for a file's kind: added green, deleted red, else neutral. */ function changeKindTone(kind) { if (kind === ChangeKind.Added) return "ok"; if (kind === ChangeKind.Deleted) return "bad"; return "muted"; } /** * One changed-file row: the kind word in its hue, the path in monospace, the * `+N -M` stat and the `changed by …` meta line. Clicking (or Enter/Space) opens * the diff viewer on this file, whose position there confirms which row it is. */ function renderChangeRow(entry, index, files) { const open = () => openChangeViewer(files, index); const row = h("div", { class: "change-row", role: "button", tabindex: "0", "data-change-index": String(index), "aria-label": `Open ${entry.path}`, }); row.addEventListener("click", open); row.addEventListener("keydown", (event) => { if (event.key === "Enter" || event.key === " ") { event.preventDefault(); open(); } }); row.append(h("span", { class: `change-kind ${changeKindTone(entry.kind)}`, text: changeKindLabel(entry.kind) })); const main = h("div", { class: "change-main" }); main.append(h("div", { class: "change-path monospace", text: entry.path })); main.append(h("div", { class: "change-meta muted", text: changeRowMeta(entry) })); row.append(main); const stat = h("div", { class: "change-stat" }); if (entry.added > 0) stat.append(h("span", { class: "stat-add", text: `+${entry.added}` })); if (entry.removed > 0) stat.append(h("span", { class: "stat-del", text: `-${entry.removed}` })); row.append(stat); return row; } let changeViewerOverlay = null; let changeViewerKeydown = null; let changeViewerIndex = null; /** Close the diff viewer, returning focus to the row that opened it. */ function closeChangeViewer() { if (changeViewerKeydown) { document.removeEventListener("keydown", changeViewerKeydown); changeViewerKeydown = null; } const index = changeViewerIndex; changeViewerOverlay?.remove(); changeViewerOverlay = null; changeViewerIndex = null; if (index != null) { document.querySelector(`.change-row[data-change-index="${index}"]`)?.focus(); } } /** * The full-screen diff viewer for one changed file. It pages through the run's * changed files exactly as the artifact viewer pages through a gallery's media * (one shared index, previous/next affordances, Escape/the close button/backdrop * dismissing), and shows both forms the brief requires, switchable from one * control row: the **Rendered** reading (each hunk's `@@` header, the shared * diff line language and the old/new gutter numbers) and the **Raw patch** (the * server's unified patch verbatim in monospace). A file the server could not * give a patch for (binary, truncated, or a capture that recorded none) shows the * honest reason in place of a diff rather than a fabricated one. */ function openChangeViewer(files, startIndex) { closeChangeViewer(); if (!files?.length) return; let index = Math.min(Math.max(Number(startIndex) || 0, 0), files.length - 1); let form = "rendered"; const overlay = h("div", { class: "change-viewer", role: "dialog", "aria-modal": "true", "aria-label": "Diff viewer", }); overlay.addEventListener("click", (event) => { if (event.target === overlay) closeChangeViewer(); }); const renderViewer = () => { const entry = files[index]; changeViewerIndex = index; const stat = changeStat(entry.added, entry.removed); const hasPatch = entryHasPatch(entry); const titles = h("div", { class: "change-viewer-titles" }); const titleRow = h("div", { class: "change-viewer-title-row" }); titleRow.append( h("span", { class: `change-kind ${changeKindTone(entry.kind)}`, text: changeKindTitle(entry.kind) }), ); if (stat !== "") titleRow.append(h("span", { class: "change-viewer-stat monospace", text: stat })); titles.append(titleRow); titles.append(h("div", { class: "change-viewer-path monospace", text: entry.path })); titles.append( h("div", { class: "change-viewer-position muted", text: `${changePositionLabel(index, files.length)} · changed by ${(entry.steps ?? []).join(" → ")}`, }), ); const head = h( "div", { class: "change-viewer-head" }, titles, h("button", { class: "change-viewer-copy", type: "button", text: "Copy raw patch", disabled: !hasPatch, onclick: () => copyText(entry.patch ?? ""), }), h("button", { class: "change-viewer-close", type: "button", text: "Close diff", onclick: closeChangeViewer, }), ); const controls = h( "div", { class: "change-viewer-controls" }, h("button", { class: `change-form${form === "rendered" ? " active" : ""}`, type: "button", "data-form": "rendered", text: "Rendered", disabled: form === "rendered", onclick: () => { form = "rendered"; renderViewer(); }, }), h("button", { class: `change-form${form === "raw" ? " active" : ""}`, type: "button", "data-form": "raw", text: "Raw patch", disabled: !hasPatch, onclick: () => { form = "raw"; renderViewer(); }, }), h("div", { class: "change-viewer-spacer" }), h("button", { class: "change-page", type: "button", "data-page": "prev", text: "Previous file", disabled: index === 0, onclick: () => { index = Math.max(index - 1, 0); form = "rendered"; renderViewer(); }, }), h("button", { class: "change-page", type: "button", "data-page": "next", text: "Next file", disabled: index === files.length - 1, onclick: () => { index = Math.min(index + 1, files.length - 1); form = "rendered"; renderViewer(); }, }), ); const body = h("div", { class: "change-viewer-body" }); if (entry.binary || !hasPatch) { body.append( h("div", { class: "change-honest muted", text: entry.binary ? BINARY_DIFF_MESSAGE : patchUnavailableReason(entry), }), ); } else if (form === "raw") { body.append(h("pre", { class: "change-raw monospace", text: entry.patch ?? "" })); } else { body.append(renderRenderedDiff(entry)); } overlay.replaceChildren(head, controls, body); }; renderViewer(); document.body.append(overlay); changeViewerOverlay = overlay; changeViewerKeydown = (event) => { if (event.key === "Escape") closeChangeViewer(); }; document.addEventListener("keydown", changeViewerKeydown); } /** The rendered reading: the stat line, an optional truncation note, each hunk. */ function renderRenderedDiff(entry) { const wrap = h("div", { class: "change-diff" }); const parsed = parseUnifiedPatch(entry.patch); const statLine = h("div", { class: "change-diff-stat" }); if (parsed.added > 0) statLine.append(h("span", { class: "stat-add", text: `+${parsed.added}` })); if (parsed.removed > 0) statLine.append(h("span", { class: "stat-del", text: `-${parsed.removed}` })); if (parsed.added === 0 && parsed.removed === 0) { statLine.append(h("span", { class: "muted", text: NO_LINE_CHANGES_MESSAGE })); } wrap.append(statLine); if (entry.truncated) wrap.append(h("div", { class: "change-diff-note muted", text: TRUNCATED_PATCH_NOTE })); for (const hunk of parsed.hunks) wrap.append(renderHunk(hunk)); return wrap; } /** * One `@@` hunk: its header on a raised surface, then its lines in a * horizontally scrollable container, each with its old/new gutter numbers (blank * on the absent side and on a `\ No newline` marker) and the shared * `{symbol} {text}` coloured by kind. */ function renderHunk(hunk) { const width = gutterWidth(hunk); const wrap = h("div", { class: "change-hunk" }); wrap.append(h("div", { class: "change-hunk-head", text: hunk.header })); const lines = h("div", { class: "change-hunk-lines" }); for (const line of hunk.lines) { const gutter = line.noNewlineMarker ? " ".repeat(width * 2 + 1) : `${gutterText(line.oldLine, width)} ${gutterText(line.newLine, width)}`; lines.append( h( "div", { class: "change-line" }, h("span", { class: "change-gutter", text: gutter }), h("span", { class: `change-text ${diffLineClass(line.kind)}`, text: `${diffLineSymbol(line.kind)} ${line.text}` }), ), ); } wrap.append(lines); return wrap; } /** Copy arbitrary text (the raw patch) to the clipboard, best effort. */ async function copyText(text) { if (!text || !canCopyLink()) return; try { await navigator.clipboard.writeText(text); } catch { // Clipboard permission may be denied; the patch is still readable. } } /** The Timeline tab: one compact row per visit, in step order. */ function renderRunTimelineTab(d) { const wrap = h("div", { class: "run-tab-body" }); const timeline = runTimeline(d.steps ?? []); if (!timeline.entries.length) { wrap.append(h("div", { class: "run-empty muted", text: EMPTY_TIMELINE_MESSAGE })); return wrap; } const list = h("div", { class: "timeline" }); for (const entry of timeline.entries) list.append(renderTimelineRow(entry)); wrap.append(list); return wrap; } /** * One timeline row: a stage-outcome glyph, the `{stage} · visit {n}` line with * the outcome chip, a paperclip when the visit recorded artifacts, the duration, * and the one-line description. Clicking (or Enter/Space) opens the stage pane. */ function renderTimelineRow(entry) { const state_ = runStateOf(entry.outcomeLabel); const chipLabel = entry.outcomeLabel || state_.label; const tone = outcomeClass(entry.step.outcome, entry.step.status); const open = () => openStagePane(entry.stageKey, entry.visitIndex); const row = h("div", { class: "timeline-row", role: "button", tabindex: "0", "data-stage-key": entry.stageKey, "data-visit-index": String(entry.visitIndex), }); row.addEventListener("click", open); row.addEventListener("keydown", (event) => { if (event.key === "Enter" || event.key === " ") { event.preventDefault(); open(); } }); row.append(h("span", { class: `timeline-glyph ${tone}`, text: stateGlyph(state_) })); const head = h("div", { class: "timeline-head" }); head.append(h("span", { class: "timeline-title", text: `${entry.stageKey} · visit ${entry.visit}` })); head.append(h("span", { class: `outcome-chip ${tone}`, text: chipLabel })); if (entry.hasArtifacts) { head.append( h("span", { class: "timeline-paperclip", title: "Recorded artifacts", "aria-label": "has recorded artifacts", text: "\u{1F4CE}" }), ); } if (entry.duration) head.append(h("span", { class: "timeline-duration muted", text: entry.duration })); const body = h("div", { class: "timeline-main" }, head); if (entry.description) body.append(h("span", { class: "timeline-desc muted", text: entry.description })); row.append(body); return row; } /** A CSS class naming a stage-outcome colour (status palette, else flow). */ function outcomeClass(outcome, status) { const [kind, value] = outcomeColorToken(outcome, status).split(" "); return `outcome-${kind}-${value}`; } // --- Stage pane ------------------------------------------------------------ /** * The stage pane: a closable dialog for one visit, opened from a timeline row. * It leads with the verdict block (when the server recorded one), then the * always-visible headline rows, then the visit's collapsible sections in the * Android order (Artifacts, Session, Output, Input, This run, Stage definition). * Escape, the Back button and a backdrop click close it. */ function renderStagePane(d) { const stageKey = state.runStagePane.stageKey; const timeline = runTimeline(d.steps ?? []); const runSteps = timeline.visitsByStage.get(stageKey) ?? []; const visitIndex = clampVisitIndex(state.runStagePane.visitIndex, runSteps.length); const step = runSteps[visitIndex] ?? null; const graph = d.graph ?? { stages: [] }; const specs = stageSectionSpecs(stageKey, graph, runSteps, visitIndex, true); const fields = step ? runStepFields(step) : []; const headline = headlineFields(fields); const overlay = h("div", { class: "stage-pane", role: "dialog", "aria-modal": "true", "aria-label": nodeLabel(stageKey), }); overlay.addEventListener("click", (event) => { if (event.target === overlay) closeStagePane(); }); const bar = h( "div", { class: "stage-pane-bar" }, h("button", { class: "stage-pane-back", type: "button", "aria-label": "Back", text: "\u2190 Back", onclick: closeStagePane, }), h( "div", { class: "stage-pane-titles" }, h("span", { class: "stage-pane-title", text: nodeLabel(stageKey) }), h("span", { class: "stage-pane-run muted", text: runLabelFor(d) }), ), ); const body = h("div", { class: "stage-pane-body" }); if (step) { const verdict = renderVerdictBlock(step); if (verdict) body.append(verdict); } for (const field of headline) body.append(renderStageField(field)); if (headline.length === 0 && specs.length === 0) { body.append(h("div", { class: "run-empty muted", text: NO_STAGE_DETAILS_MESSAGE })); } for (const spec of specs) body.append(renderStageSection(spec, step)); overlay.append(h("div", { class: "stage-pane-sheet" }, bar, body)); return overlay; } /** One stage-pane section, using the pane's own expansion state. */ function renderStageSection(spec, step) { const expanded = state.runStageSections.has(spec.key); const wrap = h("div", { class: "collapsible stage-section" }); wrap.append( h( "button", { class: "section-toggle", type: "button", "aria-expanded": expanded ? "true" : "false", onclick: () => { state.runStageSections = new Set(state.runStageSections); if (state.runStageSections.has(spec.key)) state.runStageSections.delete(spec.key); else state.runStageSections.add(spec.key); renderContent(); }, }, h("span", { class: "chevron", text: expanded ? "\u25be" : "\u25b8" }), h("span", { class: "section-title", text: spec.title }), ), ); if (!expanded) return wrap; const body = h("div", { class: "section-body" }); if (spec.artifacts && step) body.append(renderVisitArtifacts(step)); else if (spec.session && step) body.append(renderSessionExport(step)); else for (const field of spec.fields) body.append(renderStageField(field)); wrap.append(body); return wrap; } /** * The verdict block: heading "Verdict", the option as an outcome-coloured chip, * the reason as body text with inline artifact links, and the referenced * artifacts as compact chips. Nothing renders when the server recorded no * option and no reason. */ function renderVerdictBlock(step) { const verdict = step.verdict; if (!verdict) return null; const option = String(verdict.option ?? ""); const reason = String(verdict.reason ?? ""); if (option.trim() === "" && reason.trim() === "") return null; const wrap = h("div", { class: "verdict" }); const head = h("div", { class: "verdict-head" }, h("span", { class: "verdict-title", text: "Verdict" })); if (option.trim() !== "") { head.append(h("span", { class: `outcome-chip ${outcomeClass(step.outcome, step.status)}`, text: option })); } wrap.append(head); const references = referencedVerdictArtifacts(verdict, presentedArtifacts(step)); if (reason.trim() !== "") { const body = h("p", { class: "verdict-reason" }); for (const segment of verdictReasonSegments(reason, references)) { if (!segment.artifact) body.append(document.createTextNode(segment.text)); else body.append(renderVerdictLink(segment.text, segment.artifact, step)); } wrap.append(body); } if (references.length) { const refs = h("div", { class: "verdict-refs" }); for (const artifact of references) refs.append(renderVerdictRef(artifact, step)); wrap.append(refs); } return wrap; } /** One inline artifact reference in a verdict reason (media opens the viewer). */ function renderVerdictLink(text, artifact, step) { const resolved = resolvedArtifactUrl(artifact, state.url); if (!resolved) return h("span", { class: "verdict-link disabled", text }); const link = h("a", { class: "verdict-link", href: resolved, target: "_blank", rel: "noreferrer", text }); link.addEventListener("click", (event) => { event.preventDefault(); openArtifactFromVerdict(artifact, step, resolved); }); return link; } /** One compact chip naming a referenced artifact. */ function renderVerdictRef(artifact, step) { const resolved = resolvedArtifactUrl(artifact, state.url); const chip = h("button", { class: "verdict-ref", type: "button", text: artifact.name || "(unnamed artifact)", }); chip.addEventListener("click", () => openArtifactFromVerdict(artifact, step, resolved)); return chip; } /** Open a referenced artifact: media in the viewer, everything else externally. */ function openArtifactFromVerdict(artifact, step, resolved) { if (!resolved) return; const group = { stageKey: step.stage, visit: displayVisit(step, 0), artifacts: presentedArtifacts(step) }; const viewable = pagedArtifacts([group]); const viewerIndexOf = viewerIndexByUrl([group]); const at = viewerIndexOf.get(artifact.url); const kind = artifactKind(artifact.content_type, artifact.name); const media = kind === ArtifactKind.Image || kind === ArtifactKind.Video; if (media && at != null) openArtifactViewer(viewable, at); else window.open(resolved, "_blank", "noopener,noreferrer"); } /** Open the stage pane for one visit of a stage and move focus into it. */ function openStagePane(stageKey, visitIndex, { updateRoute = true } = {}) { state.runStagePane = { stageKey, visitIndex }; state.runStageSections = new Set(); if (updateRoute && state.selectedRunId) { pushRoute({ kind: "runStage", id: state.selectedRunId, stageKey, visit: Number.isSafeInteger(visitIndex) && visitIndex >= 0 ? visitIndex : null, }); } renderContent(); document.querySelector(".stage-pane-back")?.focus(); } /** Close the stage pane, returning focus to the timeline row that opened it. */ function closeStagePane({ updateRoute = true } = {}) { const closing = state.runStagePane; if (!closing) return; state.runStagePane = null; state.runStageSections = new Set(); if (updateRoute && state.selectedRunId) { pushRoute({ kind: "run", id: state.selectedRunId }); } renderContent(); const row = [...document.querySelectorAll(".timeline-row")].find( (node) => node.dataset.stageKey === closing.stageKey && node.dataset.visitIndex === String(closing.visitIndex), ); // A pane opened from the Timeline returns to its row; one opened from the Graph // returns to the stage node that opened it (there is no timeline row then). const focusTarget = row ?? [...document.querySelectorAll(".graph-node")].find( (candidate) => candidate.dataset.key === closing.stageKey, ); focusTarget?.focus(); } // --- Run-level operator actions (R11–R14) ---------------------------------- /** The one-line error text of a refused action (the server's own message). */ function describeError(error) { return error?.message || String(error); } /** * The decision card (R11): a prominent "Waiting for your decision" banner with * the stage/run identity and a deliberate Decide action. Only rendered when the * loaded run is genuinely waiting on a person. */ function renderDecisionCard(decision) { const card = h("div", { class: "decision-card" }); card.append(h("span", { class: "decision-card-icon", "aria-hidden": "true", text: "\u270B" })); const text = h("div", { class: "decision-card-text" }); text.append(h("div", { class: "decision-card-title", text: DECISION_CARD_TITLE })); text.append(h("div", { class: "decision-card-meta muted", text: decisionCardMeta(decision) })); card.append(text); card.append( h("button", { class: "decision-open", type: "button", text: DECISION_ACTION, onclick: () => openDecisionSheet(decision), }), ); return card; } /** Cancel/Retry actions, shown exactly per the app's eligibility rules. */ function renderRunActions(d) { const buttons = []; if (canCancel(d)) { buttons.push( h("button", { class: "run-action cancel-run", type: "button", text: "Cancel run", onclick: () => openConfirm({ kind: "cancel", runId: d.id }), }), ); } if (canRetry(d)) { buttons.push( h("button", { class: "run-action retry-run", type: "button", text: "Retry", onclick: () => openConfirm({ kind: "retry", runId: d.id }), }), ); } if (!buttons.length) return null; return h("div", { class: "run-actions" }, ...buttons); } /** Open the decision sheet with a fresh draft; nothing is sent until Confirm. */ function openDecisionSheet(decision) { state.runDecision = decision; state.decisionOpen = true; state.decisionDraft = new DecisionDraft(); state.decisionError = ""; renderContent(); document.querySelector(".decision-sheet .decision-option")?.focus(); } /** Dismiss the decision sheet (never while a decision is in flight). */ function closeDecisionSheet() { if (state.decisionSending) return; const wasOpen = state.decisionOpen; state.decisionOpen = false; state.runDecision = null; state.decisionError = ""; state.decisionDraft = new DecisionDraft(); if (!wasOpen) return; renderContent(); document.querySelector(".decision-card .decision-open")?.focus(); } /** * The decision sheet (R11): the waiting stage, the author's recorded * instructions, one selectable row per option (with its resolved target when * declared), the optional feedback field and the deliberate confirm. Selecting a * row never sends; a refusal keeps the sheet open with the server's exact reason. */ function renderDecisionSheet(decision) { const overlay = h("div", { class: "decision-sheet", role: "dialog", "aria-modal": "true", "aria-label": decisionSheetTitle(decision.stageKey), }); overlay.addEventListener("click", (event) => { if (event.target === overlay) closeDecisionSheet(); }); const sheet = h("div", { class: "decision-sheet-panel" }); sheet.append(h("h2", { class: "decision-sheet-title", text: decisionSheetTitle(decision.stageKey) })); sheet.append(h("div", { class: "decision-sheet-meta muted", text: decisionSheetMeta(decision) })); if (String(decision.instructions ?? "").trim() !== "") { sheet.append(h("p", { class: "decision-instructions", text: decision.instructions })); } const options = h("div", { class: "decision-options", role: "radiogroup", "aria-label": "Options" }); for (const option of decision.options) { const selected = state.decisionDraft.selected === option.key; const row = h("button", { class: `decision-option${selected ? " selected" : ""}`, type: "button", role: "radio", "aria-checked": selected ? "true" : "false", "data-option": option.key, onclick: () => { state.decisionDraft = state.decisionDraft.select(option.key); renderContent(); }, }); row.append(h("span", { class: "decision-radio", "aria-hidden": "true" })); const body = h("span", { class: "decision-option-body" }); body.append(h("span", { class: "decision-option-key", text: option.key })); const target = optionTargetText(option.target); if (target !== "") body.append(h("span", { class: "decision-option-target muted", text: target })); row.append(body); options.append(row); } sheet.append(options); const field = h("label", { class: "decision-field" }); field.append(h("span", { class: "decision-field-label", text: FEEDBACK_LABEL })); field.append( h("input", { class: "decision-feedback", type: "text", value: state.decisionDraft.feedback, spellcheck: "false", oninput: (event) => { state.decisionDraft = state.decisionDraft.withFeedback(event.target.value); }, }), ); sheet.append(field); if (state.decisionError) sheet.append(h("div", { class: "decision-error bad", text: state.decisionError })); const actions = h("div", { class: "decision-sheet-actions" }); actions.append( h("button", { class: "ghost decision-cancel", type: "button", text: DECISION_CANCEL, disabled: state.decisionSending, onclick: closeDecisionSheet, }), ); actions.append( h("button", { class: "decision-confirm", type: "button", text: state.decisionSending ? DECISION_SENDING : DECISION_CONFIRM, disabled: !state.decisionDraft.canSubmit || state.decisionSending, onclick: () => confirmDecision(decision), }), ); sheet.append(actions); overlay.append(sheet); return overlay; } /** Send the chosen decision; on refusal show the server's reason and re-read. */ async function confirmDecision(decision) { if (state.decisionSending || !state.decisionDraft.canSubmit) return; const option = state.decisionDraft.selected; state.decisionSending = true; state.decisionError = ""; renderContent(); try { await repo.decideRun(decision.runId, { stage: decision.stageKey, option, feedback: state.decisionDraft.feedback, }); state.decisionSending = false; state.decisionOpen = false; state.runDecision = null; state.decisionDraft = new DecisionDraft(); await selectRun(decision.runId, { silent: true }); } catch (error) { state.decisionSending = false; state.decisionError = describeError(error); await selectRun(decision.runId, { silent: true }); } renderContent(); } /** Open one of the shared confirm dialogs (cancel / retry / restart). */ function openConfirm(kind) { state.confirmKind = kind; renderContent(); } function dismissConfirm() { state.confirmKind = null; renderContent(); } /** * The shared confirm dialog: the exact Android title/message for cancel and * retry (with Keep as the dismiss), plus the browser-only "Restart from start" * secondary confirm that plainly states the whole-pipeline replay. The dismiss * button is "Keep". */ function renderConfirmDialog(d) { const kind = state.confirmKind; if (!kind) return null; const runId = kind.runId ?? d.id; let title; let message; let confirmLabel; let secondary = null; if (kind.kind === "cancel") { title = cancelDialogTitle(runId); message = CANCEL_DIALOG_MESSAGE; confirmLabel = CANCEL_CONFIRM; } else if (kind.kind === "retry") { title = retryDialogTitle(runId); message = RETRY_DIALOG_MESSAGE; confirmLabel = RETRY_CONFIRM; secondary = { label: RESTART_CONFIRM, next: { kind: "restart", runId } }; } else { title = restartDialogTitle(runId); message = RESTART_DIALOG_MESSAGE; confirmLabel = RESTART_CONFIRM; } const overlay = h("div", { class: `confirm-dialog confirm-${kind.kind}`, role: "dialog", "aria-modal": "true", "aria-label": title, }); overlay.addEventListener("click", (event) => { if (event.target === overlay) dismissConfirm(); }); const panel = h("div", { class: "confirm-panel" }); panel.append(h("h2", { class: "confirm-title", text: title })); panel.append(h("p", { class: "confirm-message", text: message })); const actions = h("div", { class: "confirm-actions" }); if (secondary) { actions.append( h("button", { class: "ghost confirm-secondary", type: "button", text: secondary.label, onclick: () => openConfirm(secondary.next), }), ); } actions.append( h("button", { class: "ghost confirm-dismiss", type: "button", text: DISMISS_KEEP, onclick: dismissConfirm, }), ); actions.append( h("button", { class: "confirm-accept", type: "button", text: confirmLabel, onclick: () => acceptConfirm(kind), }), ); panel.append(actions); overlay.append(panel); return overlay; } /** * Run the confirmed action, then a silent get_run refresh — exactly as the * Android client does. A server refusal is reported through the one shared * Action-failed dialog. */ async function acceptConfirm(kind) { const runId = kind.runId ?? state.runDetail?.id; state.confirmKind = null; renderContent(); try { if (kind.kind === "cancel") { await repo.cancelRun(runId); } else { const mode = kind.kind === "restart" ? "restart" : "resume"; await repo.retryRun(runId, { mode, requestKey: retryRequestKey(runId) }); } } catch (error) { state.actionError = describeError(error); } await selectRun(runId, { silent: true }); renderContent(); } /** The one shared "Action failed" dialog (title, the server's message, OK). */ function renderActionFailedDialog() { const overlay = h("div", { class: "action-failed", role: "dialog", "aria-modal": "true", "aria-label": ACTION_FAILED_TITLE, }); overlay.addEventListener("click", (event) => { if (event.target === overlay) dismissActionError(); }); const panel = h("div", { class: "action-failed-panel" }); panel.append(h("h2", { class: "action-failed-title", text: ACTION_FAILED_TITLE })); panel.append(h("p", { class: "action-failed-message", text: state.actionError })); panel.append( h("button", { class: "action-failed-ok", type: "button", text: ACTION_FAILED_OK, onclick: dismissActionError }), ); overlay.append(panel); return overlay; } function dismissActionError() { state.actionError = ""; renderContent(); } /** The Summary title row: the run's label plus the inline rename control (R14). */ function renderRunTitleRow(d) { const row = h("div", { class: "run-title-row" }); row.append(h("h2", { class: "run-detail-title", text: runLabelFor(d) })); if (state.renameValue == null) { row.append( h("button", { class: "ghost rename-open", type: "button", text: RENAME_ACTION, onclick: () => { state.renameValue = String(d.title ?? ""); renderContent(); }, }), ); return row; } const field = h("div", { class: "rename-field" }); field.append( h("input", { class: "rename-input", type: "text", value: state.renameValue, "aria-label": RENAME_FIELD_LABEL, oninput: (event) => { state.renameValue = event.target.value; }, }), ); field.append( h("button", { class: "rename-save", type: "button", text: RENAME_SAVE, onclick: () => saveRunTitle(d.id), }), ); field.append( h("button", { class: "ghost rename-cancel", type: "button", text: RENAME_CANCEL, onclick: () => { state.renameValue = null; renderContent(); }, }), ); row.append(field); return row; } /** * Rename the run: send `set_run_title`, then update the run detail and the runs * list row. A refusal (for example a blank title) keeps the field open and shows * the server's exact reason through the shared Action-failed dialog. */ async function saveRunTitle(id) { if (state.renameBusy) return; state.renameBusy = true; try { const detail = await repo.setRunTitle(id, String(state.renameValue ?? "")); state.renameValue = null; applyRunTitle(id, detail); await selectRun(id, { silent: true }); } catch (error) { state.actionError = describeError(error); renderContent(); } finally { state.renameBusy = false; } } /** Apply a renamed run to the loaded detail and the runs-list row. */ function applyRunTitle(id, detail) { if (state.runDetail && state.runDetail.id === id && detail) state.runDetail = detail; const title = String(detail?.title ?? ""); state.runs = state.runs.map((run) => (run.id === id ? { ...run, title } : run)); } /** Whether the configured server URL can resolve a server-relative artifact. */ function artifactsResolvable() { return resolveArtifactUrl(state.url, "/artifacts/0/0/probe") != null; } /** * The run-level gallery: one header per (stage, visit) and one grid of tiles per * visit, in the gallery order (stages first-appearance, visits by sequence). A * run with no artifacts shows the header (which already says why) and nothing * else, so the section is never blank. */ function renderArtifactGallery(steps) { const wrap = h("div", { class: "artifact-gallery" }); const groups = artifactGroups(steps); if (!groups.length) return wrap; if (!artifactsResolvable()) { wrap.append(h("div", { class: "muted artifact-hint", text: ARTIFACT_SERVER_HINT })); } const viewable = pagedArtifacts(groups); const viewerIndexOf = viewerIndexByUrl(groups); for (const group of groups) { wrap.append( h("div", { class: "artifact-group-head", text: `${group.stageKey} · visit ${group.visit}` }), renderArtifactGrid(group.artifacts, viewable, viewerIndexOf), ); } return wrap; } /** * The per-visit artifacts section shown inside one step: the summary line, the * capture notes, the no-server-URL hint and a headerless grid of that visit's * tiles (matching the Android ArtifactsSection). Its viewer pages only through * that visit's media, exactly as the Android section does. */ function renderVisitArtifacts(step) { const wrap = h("div", { class: "artifacts" }); wrap.append(h("div", { class: "artifacts-summary", text: artifactsSummary(step) })); for (const note of artifactCaptureNotes(step)) { wrap.append(h("div", { class: "artifacts-note muted", text: note })); } const artifacts = presentedArtifacts(step); if (artifacts.length) { if (!artifactsResolvable()) { wrap.append(h("div", { class: "muted artifact-hint", text: ARTIFACT_SERVER_HINT })); } const group = { stageKey: step.stage, visit: displayVisit(step, 0), artifacts }; wrap.append( renderArtifactGrid(artifacts, pagedArtifacts([group]), viewerIndexByUrl([group])), ); } return wrap; } /** One visit's tiles in a CSS grid. */ function renderArtifactGrid(artifacts, viewable, viewerIndexOf) { const grid = h("div", { class: "artifact-grid" }); for (const artifact of artifacts) { grid.append(renderArtifactTile(artifact, viewable, viewerIndexOf)); } return grid; } /** * One gallery tile: an image thumbnail, a video poster with a play marker (never * a <video> element or autoplay), or a kind/name/size label. Every server string * is set as text, never as markup. */ function renderArtifactTile(artifact, viewable, viewerIndexOf) { const resolved = resolvedArtifactUrl(artifact, state.url); const kind = artifactKind(artifact.content_type, artifact.name); const media = kind === ArtifactKind.Image || kind === ArtifactKind.Video; const name = artifact.name || "(unnamed artifact)"; const tile = h("div", { class: "artifact-tile clickable" }); const openViewer = () => { const at = viewerIndexOf.get(artifact.url); if (at != null) openArtifactViewer(viewable, at); }; const openTab = () => { if (resolved) window.open(resolved, "_blank", "noopener,noreferrer"); }; if (kind === ArtifactKind.Image) { const img = h("img", { class: "artifact-thumb", alt: name, loading: "lazy" }); if (resolved) img.src = resolved; tile.append(img); tile.addEventListener("click", openViewer); } else if (kind === ArtifactKind.Video) { tile.append(h("div", { class: "artifact-poster" }, h("span", { class: "artifact-play", text: "▶" }))); tile.append(h("div", { class: "artifact-name", text: name })); tile.addEventListener("click", openViewer); } else { tile.append( h("div", { class: "artifact-kind", text: artifactKindLabel(kind) }), h("div", { class: "artifact-name", text: name }), h("div", { class: "artifact-size", text: humanBytes(artifact.size_bytes) }), ); tile.addEventListener("click", openTab); } tile.append(renderTileActions(resolved, media)); return tile; } /** The compact per-tile actions: copy-link (non-media tiles) and share. */ function renderTileActions(resolved, media) { const actions = h("div", { class: "artifact-actions" }); const stop = (fn) => (event) => { event.stopPropagation(); fn(); }; if (!media) { actions.append( h("button", { class: "artifact-action", type: "button", text: "Copy link", disabled: !resolved || !canCopyLink(), onclick: stop(() => copyArtifactLink(resolved)), }), ); } actions.append( h("button", { class: "artifact-action", type: "button", text: "Share", disabled: !resolved || !canShare(), onclick: stop(() => shareArtifact(resolved)), }), ); return actions; } function canCopyLink() { return typeof navigator !== "undefined" && Boolean(navigator.clipboard?.writeText); } function canShare() { return typeof navigator !== "undefined" && typeof navigator.share === "function"; } async function copyArtifactLink(resolved) { if (!resolved || !canCopyLink()) return; try { await navigator.clipboard.writeText(resolved); } catch { // Clipboard permission may be denied; the link is still openable. } } async function shareArtifact(resolved) { if (!resolved || !canShare()) return; try { await navigator.share({ url: resolved }); } catch { // The share chooser may be dismissed. } } /** * The step's session export: a link opening the read-only session.html in a new * tab, or the plain notice when the visit exported nothing (parity R9). */ function renderSessionExport(step) { const file = sessionExportArtifact(step); const wrap = h("div", { class: "session-export" }); if (!file) { wrap.append(h("span", { class: "muted", text: "No session was exported for this visit." })); return wrap; } const href = resolvedArtifactUrl(file, state.url); if (href) { wrap.append( h("a", { class: "session-link", href, target: "_blank", rel: "noreferrer", text: `Open ${file.name || "session.html"}`, }), ); } else { wrap.append( h("span", { class: "muted", text: "Set the server URL in Settings to open the session." }), ); } return wrap; } let viewerOverlay = null; let viewerKeydown = null; /** Close the full-screen viewer and remove its Escape listener. */ function closeArtifactViewer() { if (viewerKeydown) { document.removeEventListener("keydown", viewerKeydown); viewerKeydown = null; } viewerOverlay?.remove(); viewerOverlay = null; } /** * Open the full-screen viewer at `startIndex` into `viewable`, the same ordered * media list the grid drew. Previous/Next are disabled at the ends and absent for * a single artifact; Escape and a backdrop click close it. Nothing autoplays: a * non-image artifact shows a still poster placeholder instead. */ function openArtifactViewer(viewable, startIndex) { closeArtifactViewer(); if (!viewable?.length) return; let index = pagedIndex(startIndex, 0, viewable.length); const overlay = h("div", { class: "artifact-viewer", role: "dialog", "aria-modal": "true", "aria-label": "Artifact viewer", }); overlay.addEventListener("click", (event) => { if (event.target === overlay) closeArtifactViewer(); }); const renderViewer = () => { const artifact = viewable[index] ?? {}; const resolved = resolvedArtifactUrl(artifact, state.url); const kind = artifactKind(artifact.content_type, artifact.name); const name = artifact.name || "(unnamed artifact)"; const board = h("div", { class: "viewer-board" }); if (kind === ArtifactKind.Image && resolved) { board.append(h("img", { class: "viewer-image", src: resolved, alt: name })); } else { board.append( h( "div", { class: "viewer-placeholder" }, h("span", { class: "artifact-play", text: "▶" }), h("span", { class: "viewer-placeholder-name", text: name }), ), ); } const head = h( "div", { class: "viewer-head" }, h("div", { class: "viewer-title", text: name }), h("div", { class: "viewer-position muted", text: artifactViewerPositionLabel(index, viewable.length, artifact.content_type), }), ); const actions = h("div", { class: "viewer-actions" }); if (resolved) { actions.append( h("button", { class: "viewer-action", type: "button", text: "Open", onclick: () => window.open(resolved, "_blank", "noopener,noreferrer"), }), h("button", { class: "viewer-action", type: "button", text: "Copy link", disabled: !canCopyLink(), onclick: () => copyArtifactLink(resolved), }), h("button", { class: "viewer-action", type: "button", text: "Share", disabled: !canShare(), onclick: () => shareArtifact(resolved), }), ); } actions.append( h("button", { class: "viewer-action viewer-close", type: "button", text: "Close viewer", onclick: closeArtifactViewer, }), ); const nodes = [head, board]; if (viewable.length > 1) { nodes.push( h( "div", { class: "viewer-nav" }, h("button", { class: "viewer-page", type: "button", text: "Previous artifact", disabled: pagedIndex(index, -1, viewable.length) === index, onclick: () => { index = pagedIndex(index, -1, viewable.length); renderViewer(); }, }), h("button", { class: "viewer-page", type: "button", text: "Next artifact", disabled: pagedIndex(index, 1, viewable.length) === index, onclick: () => { index = pagedIndex(index, 1, viewable.length); renderViewer(); }, }), ), ); } nodes.push(actions); overlay.replaceChildren(...nodes); }; renderViewer(); document.body.append(overlay); viewerOverlay = overlay; viewerKeydown = (event) => { if (event.key === "Escape") closeArtifactViewer(); }; document.addEventListener("keydown", viewerKeydown); } /** A key/value row whose value is monospace (a key, an id) rather than prose. */ function kvMono(key, value) { return h( "div", { class: "kv-row" }, h("span", { class: "kv-key", text: key }), h("span", { class: "kv-val" }, h("code", { text: value })), ); } // --------------------------------------------------------------------------- // Chat (C1 · C3 · C4 · C7 · C14) // --------------------------------------------------------------------------- /** The persisted per-session scroll positions, or an empty map when unreadable. */ function readChatScrollStore() { try { const parsed = JSON.parse(localStorage.getItem(CHAT_SCROLL_STORAGE_KEY) ?? "{}"); return parsed && typeof parsed === "object" ? parsed : {}; } catch { return {}; } } /** Remember one conversation's scroll position (index of the first visible row). */ function saveChatScroll(sessionId, position) { if (!sessionId) return; state.chatScroll[sessionId] = { index: position.index, offset: position.offset }; try { localStorage.setItem(CHAT_SCROLL_STORAGE_KEY, JSON.stringify(state.chatScroll)); } catch { // storage may be full or disabled; the in-memory position still holds } } /** The persisted per-chat drafts, or an empty map when unreadable. */ function readChatDraftStore() { try { const parsed = JSON.parse(localStorage.getItem(CHAT_DRAFT_STORAGE_KEY) ?? "{}"); return parsed && typeof parsed === "object" ? parsed : {}; } catch { return {}; } } /** * Mirror one conversation's draft into localStorage. A blank draft clears its * entry so the store cannot grow without bound; the in-memory `thread.draft` * stays the source of truth, this is only the persistence beside it. */ function saveChatDraft(sessionId, text) { if (!sessionId) return; try { const store = readChatDraftStore(); if (String(text ?? "") === "") delete store[sessionId]; else store[sessionId] = String(text); localStorage.setItem(CHAT_DRAFT_STORAGE_KEY, JSON.stringify(store)); } catch { // storage may be full or disabled; the in-memory draft still holds } } /** The persisted draft for one conversation, or "" when there is none. */ function readChatDraft(sessionId) { const value = readChatDraftStore()[sessionId]; return typeof value === "string" ? value : ""; } /** The persisted local chat overrides; unreadable storage means no overrides. */ function readChatOverridesStore() { try { return decodeChatOverrides(localStorage.getItem(CHAT_OVERRIDES_STORAGE_KEY)); } catch { return emptyChatOverrides(); } } /** Persist the current local overrides; storage failure leaves memory authoritative. */ function saveChatOverrides() { try { localStorage.setItem(CHAT_OVERRIDES_STORAGE_KEY, encodeChatOverrides(state.chatOverrides)); } catch { // storage may be full or disabled; the in-memory overrides still hold } } /** The persisted seen state; unreadable storage means nothing seen. */ function readChatSeenStore() { try { return decodeChatSeen(localStorage.getItem(CHAT_SEEN_STORAGE_KEY)); } catch { return emptyChatSeen(); } } /** * Persist the seen state only when it actually changed. Every frame and refresh * would otherwise rewrite localStorage for no reason. */ function saveChatSeen(next) { if (next === state.chatSeen) return; state.chatSeen = next; try { localStorage.setItem(CHAT_SEEN_STORAGE_KEY, encodeChatSeen(state.chatSeen)); } catch { // storage may be full or disabled; the in-memory state still holds } } /** * The pixels the transcript still sits above its end (0 when at the bottom), via * the same pure decision the unit tests cover. `chatBottomDistancePx` measures * from the last row's bottom edge to the viewport's bottom edge; the live * analogue passes the last row as the last visible one. */ function transcriptDistance(el) { if (!el) return null; const rows = el.children; const count = rows.length; if (count === 0) return null; const last = rows[count - 1]; return chatBottomDistancePx({ lastVisibleIndex: count - 1, lastVisibleEndPx: last.offsetTop + last.offsetHeight, itemCount: count, viewportEndPx: el.scrollTop + el.clientHeight, }); } /** * Remember the live transcript's position (and follow intent) just before a * re-render replaces it, so `afterChatRender` can put the operator back exactly * where they were. A no-op when no transcript is mounted. */ function captureChatPosition() { const el = document.getElementById("chatTranscript"); if (!el || !el.dataset.session) return; state.chatPending = { sessionId: el.dataset.session, position: currentChatPosition(el), following: state.chatFollowing, }; } /** The first visible row's index and the pixels scrolled into it. */ function currentChatPosition(el) { const rows = [...el.children]; let index = 0; let offset = 0; for (let i = 0; i < rows.length; i += 1) { const row = rows[i]; if (row.offsetTop + row.offsetHeight > el.scrollTop + 1) { index = i; offset = Math.max(0, el.scrollTop - row.offsetTop); break; } index = i; } return { index, offset }; } /** The list of the server's operator sessions, narrowed by the search field. */ async function loadChatSessions(force = false) { if (state.connection.kind !== "connected") { state.chatError = "Connect to the server first."; state.chatLoading = false; renderContent(); return; } if (state.chatLoading) return; state.chatLoading = true; state.chatError = ""; renderContent(); try { const listed = await repo.chatSessions(); // Keep this page's own verification chats, which the server intentionally // never returns, at the head of the in-memory list (memory-only; see // chatEphemeralIds). Everything else is the server's list, in its order. const held = state.chatSessions.filter( (session) => state.chatEphemeralIds.has(session.id) && !listed.some((entry) => entry.id === session.id), ); state.chatSessions = [...held, ...listed]; state.chatLoaded = true; // Fold this device's seen state in: the active chat has been read, and every // session seen for the first time gets a baseline so pre-existing chats are // not all reported as new. saveChatSeen(seedChatSeen(state.chatSeen, state.chatSessions, state.chatActiveId)); } catch (error) { state.chatError = describeError(error); } state.chatLoading = false; renderContent(); } // --------------------------------------------------------------------------- // The create flow (C2, ChatCreatePane.kt) // --------------------------------------------------------------------------- /** * Open the create pane with a fresh operation id. The id is minted once per * intent, so a retry after a refusal reuses it and the server can dedupe the * create rather than starting a second session. */ function startNewChat() { state.chatCreate = newChatCreateState(newChatOperationId()); state.chatDirectoriesError = ""; renderContent(); loadChatDirectories(); } /** * Fetch `chat_directories` for the open picker. A failure keeps the reason for the * pane's error state; blank entries are dropped here as well as in the pure model * so a malformed reply can never produce an empty row. An already-loaded list is * reused unless [force] (the error state's Retry) asks again. */ async function loadChatDirectories(force = false) { if (!state.chatCreate || state.chatDirectoriesLoading) return; if (state.chatDirectoriesLoaded && !force) return; state.chatDirectoriesLoading = true; state.chatDirectoriesError = ""; renderContent(); try { const directories = await repo.chatDirectories(); state.chatDirectories = (directories ?? []).filter((entry) => String(entry ?? "").trim() !== ""); state.chatDirectoriesLoaded = true; } catch (error) { state.chatDirectoriesError = describeError(error); } state.chatDirectoriesLoading = false; renderContent(); } /** Select one directory row (the value is what chat_create will send). */ function selectChatDirectory(value) { if (!state.chatCreate) return; state.chatCreate = selectChatDirectoryModel(state.chatCreate, value); renderContent(); } /** Leave the create flow without creating anything. */ function cancelNewChat() { state.chatCreate = null; renderContent(); } /** * Create the chat in the chosen directory. Guarded against a double submit: the * guard reads the held state, so a second click while the request is in flight * sends nothing. On success the pane closes, the created session goes to the head * of the list, becomes the open conversation and loads its (empty) history; on * failure the server's own reason stays in the pane, which does not close. */ async function createNewChat() { const create = state.chatCreate; if (!create || create.creating) return; state.chatCreate = { ...create, creating: true, error: "" }; renderContent(); try { // Not ephemeral: this is the operator's own create path (the UI smoke uses the // same path for its one real session and closes it afterwards). const created = await repo.chatCreate("New chat", create.directory, create.operationId); state.chatCreate = null; state.chatSessions = chatCreateSucceeded(state.chatSessions, created); await openChatSession(created.id); await loadChatSessions(); } catch (error) { if (!state.chatCreate) return; state.chatCreate = chatCreateFailed(state.chatCreate, describeError(error)); renderContent(); } } /** Open a session: select it, subscribe its stream and load its newest history page. */ async function openChatSession(id) { if (state.chatActiveId === id && state.chatThreads.get(id)?.loaded) return; // Remember where the operator left the conversation being closed. const leaving = document.getElementById("chatTranscript"); if (leaving && state.chatActiveId) saveChatScroll(state.chatActiveId, currentChatPosition(leaving)); state.chatActiveId = id; state.chatMenu = null; state.chatPlaced = null; state.chatFollowing = true; state.chatReasoning = new Set(); state.chatToolPanels = new Set(); state.chatToolRows = new Set(); // Opening reads the conversation: advance the watermark to its current recency // and clear the explicit unseen mark (a row that is absent has no recency). const session = state.chatSessions.find((candidate) => candidate.id === id) ?? null; saveChatSeen(readChatSeen(state.chatSeen, id, session?.updated_at ?? 0)); const existing = state.chatThreads.get(id); state.chatThreads.set(id, { ...newChatThread(id), ...(existing ?? {}), // The composer's own per-chat state (C8/C9) survives a switch; the draft is // seeded from localStorage on the first open (the per-device analogue). The // live-stream fields (C5) come from `newChatThread`. draft: existing ? existing.draft ?? "" : readChatDraft(id), attachments: existing?.attachments ?? [], notices: existing?.notices ?? [], loaded: false, loading: true, error: "", }); renderContent(); // Attach the shared live stream once per session per connection; its failure is // non-fatal — history stays usable and the badge reads "not live". subscribeChatSession(id); // Load the session's background shells (C11) so the bar appears on open, not // only after the next pushed shell frame. loadChatShells(id); await loadChatHistory(id); } /** Replace one conversation's fields, keeping every other field intact. */ function setThread(sessionId, patch) { const current = state.chatThreads.get(sessionId); if (!current) return; state.chatThreads.set(sessionId, { ...current, ...patch }); } /** * Attach one session's shared live stream (C5): `chat_subscribe` with the session * id as the body. Idempotent per connection — a session already subscribed is not * asked for again. A refusal (an older server that does not know the command, or * any other error) leaves history usable and the live badge `not live`. */ async function subscribeChatSession(id) { if (!id || state.connection.kind !== "connected") return; if (state.chatSubscriptions.has(id)) return; try { await repo.subscribeChat(id); state.chatSubscriptions = new Set(state.chatSubscriptions).add(id); } catch { // The subscription is not live; nothing else changes. The badge says so. } renderContent(); } /** Drop the per-connection subscriptions (the server detaches them on close). */ function clearChatSubscriptions() { if (state.chatSubscriptions.size > 0) state.chatSubscriptions = new Set(); } /** * Settle every conversation that was running, and drop its observed shells. A * socket drop (or a close) removes the frames feeding the turn, so no thread * keeps claiming to run until a fresh frame proves otherwise; a shell's exit may * have been swallowed by the same gap, so the retained shells are forgotten and * re-learned from `chat_shells` on reconnect (mirrors ChatStore.streamResumed). */ function settleChatThreads() { for (const [id, thread] of state.chatThreads) { const hasShells = (thread?.shells ?? []).length > 0; if (thread?.running || thread?.queued || hasShells) { state.chatThreads.set(id, resumedThread(thread)); } } } /** * Fold one pushed `chat_event` frame into its conversation. Only a conversation * this client has open is folded (a frame for a session nobody opened is * ignored); the server only pushes frames for sessions this connection subscribed * to, so this is a no-op in practice until a chat is opened. */ function onChatEvent(frame) { const sessionId = String(frame?.session_id ?? "").trim(); if (!sessionId || !state.chatThreads.has(sessionId)) return; markBackgroundChatUnseen(sessionId); const thread = state.chatThreads.get(sessionId); state.chatThreads.set(sessionId, applyChatEvent(thread, frame, Date.now())); renderContent(); } /** * A frame for a conversation that is not on screen marks it explicitly unseen, * so its live activity is visible in the list even though a pushed stream carries * no wall-clock recency to compare. The active chat is read as it arrives and is * never marked. */ function markBackgroundChatUnseen(sessionId) { if (!sessionId || sessionId === state.chatActiveId) return; saveChatSeen(markChatUnseen(state.chatSeen, sessionId)); } /** * Fold one pushed `chat_permission` frame into its conversation (C10). Only a * conversation this client has open is folded — the server only pushes a * permission frame for sessions this connection is subscribed to, but the guard * keeps a frame for a session nobody opened from creating a thread. The card is * derived from the stored frame plus the local answer, so a resolved re-push * always clears the controls. */ function onChatPermission(frame) { const sessionId = String(frame?.session_id ?? "").trim(); if (!sessionId || !state.chatThreads.has(sessionId)) return; const thread = state.chatThreads.get(sessionId); const next = applyChatPermission(thread, frame); // A different request replaces the card, so the previous refusal's reason (and // the error line it owns) no longer describes what is on screen. const replaced = String(thread?.permission?.request_id ?? "") !== String(next.permission?.request_id ?? ""); if (replaced && thread?.permissionError) { next.error = thread.error === thread.permissionError ? "" : next.error; next.permissionError = ""; } state.chatThreads.set(sessionId, next); if (sessionId === state.chatActiveId) renderContent(); } /** * Answer the pending permission request (C10): settle the matching card * optimistically so the buttons are never left offering a decision already made, * then send `chat_reply`. A refused reply reopens the same request (the local * answer is cleared) and surfaces the server's reason through the thread's own * error line, so an unaccepted decision is never shown as accepted. A refusal * that arrives after a different request replaced the card is ignored. */ async function answerPermission(sessionId, requestId, decision) { const thread = state.chatThreads.get(sessionId); const permission = thread?.permission; if (!thread || String(permission?.request_id ?? "") !== requestId) return; setThread(sessionId, { permissionAnswer: decision }); renderContent(); try { await repo.chatReply(sessionId, requestId, decision); // A retried answer the server accepted clears the reason a previous refusal // left on the thread's error line — and only that reason, never an unrelated // error the conversation is carrying. const settled = state.chatThreads.get(sessionId); if (settled?.permissionError && settled.error === settled.permissionError) { setThread(sessionId, { error: "", permissionError: "" }); renderContent(); } } catch (error) { const current = state.chatThreads.get(sessionId); if (!current || String(current.permission?.request_id ?? "") !== requestId) return; const reason = describeError(error); setThread(sessionId, { permissionAnswer: "", error: reason, permissionError: reason }); renderContent(); } } /** * The reconnect repair (C5): re-attach the open chat's stream and replace its * conversation with the newest history page wholesale. Everything the gap could * have missed is repaired; a turn that was in flight is settled. Only the open * conversation is repaired — the others are not on screen. * Fetch a session's currently verified shells (C11) and retain only the exits * this client itself observed, so an exited task never reappears as running and a * shell the server no longer lists drops out. Called when the conversation opens * and on every stream reconnect (a gap may have swallowed an exit). A failure is * non-fatal: the transcript stays usable and the bar keeps its last known state. */ async function loadChatShells(id) { if (!id || state.connection.kind !== "connected") return; try { const running = await repo.chatShells(id); const thread = state.chatThreads.get(id); if (!thread) return; state.chatThreads.set(id, { ...thread, shells: shellsLoaded(thread.shells, running) }); renderContent(); } catch { // The shell list is a background convenience; leave the thread untouched. } } /** * Toggle a running task's detail pane (C11). Selecting a shell fetches its * bounded output page; selecting the selected one again closes it. Mirrors * ChatStore.selectShell: an id that is not a known shell is ignored. */ function selectChatShell(shellId) { const sessionId = state.chatActiveId; const thread = sessionId ? state.chatThreads.get(sessionId) : null; if (!thread) return; const closing = thread.selectedShellId === shellId; if (!closing && !(thread.shells ?? []).some((shell) => shell.id === shellId)) return; const next = closing ? null : shellId; state.chatThreads.set(sessionId, { ...thread, selectedShellId: next, shellOutput: null }); renderContent(); if (next) refreshChatShellOutput(next); } /** * Reread a selected task's bounded output page (C11) from the page's start. The * cursor is always 0 and the limit is the server's 64 KiB bound, so the client * never grows output unbounded and a Refresh never appends. A reply for a shell * that is no longer selected is ignored, exactly like ChatStore.shellOutput*. */ async function refreshChatShellOutput(shellId) { const sessionId = state.chatActiveId; if (!sessionId || !shellId) return; shellOutputLoading(sessionId, shellId); renderContent(); try { const page = await repo.chatShellOutput(sessionId, shellId, { cursor: 0, limit: SHELL_OUTPUT_LIMIT }); shellOutputLoaded(sessionId, shellId, page); } catch (error) { shellOutputFailed(sessionId, shellId, describeError(error)); } renderContent(); } /** Mark a selected task's output pane loading (ignored for a stale selection). */ function shellOutputLoading(sessionId, shellId) { const thread = state.chatThreads.get(sessionId); if (!thread || thread.selectedShellId !== shellId) return; state.chatThreads.set(sessionId, { ...thread, shellOutput: { loading: true, error: "", page: null } }); } /** * Apply a loaded output page, merging a shell the page reports back into the * retained list (keeping the command already learned when the page omits it). */ function shellOutputLoaded(sessionId, shellId, page) { const thread = state.chatThreads.get(sessionId); if (!thread || thread.selectedShellId !== shellId) return; const reported = page?.shell; const shells = reported && String(reported.id ?? "").trim() !== "" ? mergeShellFrame(thread.shells, reported) : thread.shells ?? []; state.chatThreads.set(sessionId, { ...thread, shells, shellOutput: { loading: false, error: "", page } }); } /** Report a failed output read against the still-selected task (Retry is offered). */ function shellOutputFailed(sessionId, shellId, message) { const thread = state.chatThreads.get(sessionId); if (!thread || thread.selectedShellId !== shellId) return; state.chatThreads.set(sessionId, { ...thread, shellOutput: { loading: false, error: message, page: null } }); } /** * The reconnect repair (C5/C11): re-attach the open chat's stream, replace its * conversation with the newest history page wholesale and re-learn its shells. * Everything the gap could have missed is repaired; a turn that was in flight is * settled and the retained shells are dropped before the fresh snapshot arrives. * Only the open conversation is repaired — the others are not on screen. */ async function resyncOpenChat() { const id = state.chatActiveId; if (!id || state.connection.kind !== "connected") return; await subscribeChatSession(id); const previous = state.chatThreads.get(id) ?? newChatThread(id); state.chatThreads.set(id, resumedThread(previous)); try { const page = await repo.chatHistory(id); state.chatThreads.set(id, historyResync(previous, page)); } catch { // The history refresh failed; the settled thread stands and the badge is honest. } await loadChatShells(id); renderContent(); } /** Load (or reload) a session's newest history page and merge it in. */ async function loadChatHistory(id) { const previous = state.chatThreads.get(id) ?? newChatThread(id); try { const page = await repo.chatHistory(id); // The merged page replaces only the history fields; spreading it over the // held thread keeps the composer's draft, attachments and flags intact (a // draft typed while the page was loading is not lost). setThread(id, mergeHistoryPage(previous, page, { older: false })); } catch (error) { setThread(id, { loading: false, loaded: true, error: describeError(error) }); } renderContent(); } /** * Fetch the next opaque older page. Only offered while the server reports * `has_more`; the cursor is the server's own `next_cursor`, passed back verbatim * and never interpreted. Nothing auto-loads on scroll. */ async function loadOlderChatHistory(id) { const thread = state.chatThreads.get(id); if (!thread?.hasMore || thread.loading) return; const scroller = document.getElementById("chatTranscript"); state.chatAnchor = scroller ? { sessionId: id, scrollHeight: scroller.scrollHeight, scrollTop: scroller.scrollTop } : null; state.chatThreads.set(id, { ...thread, loading: true }); renderContent(); try { const page = await repo.chatHistory(id, { cursor: thread.nextCursor }); const current = state.chatThreads.get(id) ?? thread; setThread(id, mergeHistoryPage(current, page, { older: true })); } catch (error) { setThread(id, { loading: false, error: describeError(error) }); } renderContent(); } /** Open the Close chat? confirm for [session] (the mutation only on confirm). */ function openChatClose(session) { state.chatMenu = null; state.chatClose = session; renderContent(); } function dismissChatClose() { state.chatClose = null; renderContent(); } /** * Run the confirmed close, then refresh the list from the server. The confirm is * the only path that mutates the session; the dialog itself never sends. */ async function acceptChatClose(session) { state.chatClose = null; state.chatBusy = true; renderContent(); try { const { session: updated } = await repo.closeChat(session.id); applyChatSessionUpdate(session.id, updated, true); // A closed chat's turn was stopped on the server: settle its conversation and // stop treating it as a live subscription. Nothing is deleted and it can be // reopened from the list. const thread = state.chatThreads.get(session.id); if (thread) state.chatThreads.set(session.id, settledThread(thread)); if (state.chatSubscriptions.has(session.id)) { state.chatSubscriptions = new Set(state.chatSubscriptions); state.chatSubscriptions.delete(session.id); } // Closing also finishes the session for this client: the conversation leaves // the pane, back to the list (mirrors Android's `finishSession` calling // `chatStore.close`). A rejection above leaves the conversation exactly as it // was; `settledThread` has already cleared the running/queued bits. if (state.chatActiveId === session.id) { state.chatActiveId = null; } } catch (error) { state.actionError = describeError(error); } state.chatBusy = false; await loadChatSessions(); } /** Clear a finished chat's closed state again, so it can be resumed. */ async function reopenChatSession(id) { if (state.chatBusy) return; state.chatBusy = true; state.chatMenu = null; renderContent(); try { const { session: updated } = await repo.reopenChat(id); applyChatSessionUpdate(id, updated, false); } catch (error) { state.actionError = describeError(error); } state.chatBusy = false; await loadChatSessions(); } /** Apply the echoed session (or the local closed flag) to the held row. */ function applyChatSessionUpdate(id, updated, closed) { state.chatSessions = state.chatSessions.map((session) => session.id === id ? { ...session, ...(updated ?? {}), closed } : session, ); } // --------------------------------------------------------------------------- // This device's chat changes (C13): local rename, hide + undo, row menu // --------------------------------------------------------------------------- /** The server row with this device's local title applied (for the open pane). */ function effectiveChatSession(session) { if (!session) return null; return applyChatOverrides([session], state.chatOverrides)[0] ?? session; } /** Open one row's Chat actions menu, closing any other. */ function openChatMenu(sessionId) { state.chatMenu = state.chatMenu === sessionId ? null : sessionId; renderContent(); // The re-render replaced the focused button; move focus into the panel so a // keyboard operator can walk the items without hunting for the next Tab stop. if (state.chatMenu) { const first = document.querySelector(`#chatRows .chat-row[data-session="${CSS.escape(sessionId)}"] .chat-menu-item`); first?.focus(); } } /** Open the Rename chat dialog for [session] (its current effective title). */ function openChatRename(session) { state.chatMenu = null; state.chatRename = session; renderContent(); // Same re-render note as the menu: put the cursor in the Name field. document.getElementById("chatRenameInput")?.focus(); } function dismissChatRename() { state.chatRename = null; renderContent(); } /** * Record a local rename, persist it and reflect it at once: the row shows the * local title on the next render (and every later refresh), and an open * conversation's own title follows. Nothing is sent to the server — the * brokered protocol has no chat rename. */ function applyLocalChatRename(sessionId, title) { const next = renameChatOverride(state.chatOverrides, sessionId, title); if (next === state.chatOverrides) return false; state.chatOverrides = next; saveChatOverrides(); const local = next.titles[String(sessionId)]; if (local != null) setThread(sessionId, { title: local }); return true; } /** * The dialog's Save: trim, record the override, close the dialog and re-render. * A blank title is ignored (Save is already disabled while trimmed-blank). */ function acceptChatRename(session, title) { const trimmed = String(title ?? "").trim(); if (trimmed === "") return; applyLocalChatRename(session.id, trimmed); state.chatRename = null; renderContent(); } /** * Hide a session on this device only. The server is not asked to delete * anything: the row disappears from this list, its conversation closes, and the * one snackbar says exactly that with an Undo. A new hide replaces the previous * report (one snackbar slot), never queues behind it. */ function hideChatLocally(sessionId) { const id = String(sessionId ?? ""); if (!id) return; const next = hideChatOverride(state.chatOverrides, id); if (next === state.chatOverrides) return; state.chatOverrides = next; saveChatOverrides(); state.chatMenu = null; state.chatRename = null; // Hiding closes the conversation, exactly as Android's remove does: the thread // is dropped, the active id cleared and the subscription forgotten. state.chatThreads.delete(id); if (state.chatActiveId === id) { state.chatActiveId = null; state.chatPlaced = null; } if (state.chatSubscriptions.has(id)) { state.chatSubscriptions = new Set(state.chatSubscriptions); state.chatSubscriptions.delete(id); } installChatSnackbar(id); renderContent(); } /** Replace the one in-flight hide report and (re)start its auto-dismiss timer. */ function installChatSnackbar(sessionId) { if (state.chatSnackbarTimer != null) clearTimeout(state.chatSnackbarTimer); state.chatSnackbarSeq += 1; const id = state.chatSnackbarSeq; state.chatSnackbar = { id, sessionId }; state.chatSnackbarTimer = setTimeout(() => { state.chatSnackbarTimer = null; if (state.chatSnackbar?.id !== id) return; state.chatSnackbar = null; renderContent(); }, 6000); } /** Undo the last hide: restore its row and clear the report (nothing server-side). */ function undoHideChat() { const sessionId = state.chatSnackbar?.sessionId; if (!sessionId) return; const next = restoreChatOverride(state.chatOverrides, sessionId); if (next !== state.chatOverrides) { state.chatOverrides = next; saveChatOverrides(); } clearChatSnackbar(); renderContent(); } /** Drop the hide report and its timer (Undo, expiry, or leaving the list). */ function clearChatSnackbar() { if (state.chatSnackbarTimer != null) { clearTimeout(state.chatSnackbarTimer); state.chatSnackbarTimer = null; } state.chatSnackbar = null; } // --------------------------------------------------------------------------- // The composer and its slash commands (C8 · C9) // --------------------------------------------------------------------------- // The per-conversation attachment and notice ids. An id is unique across the // page, so a chip or a command line is unambiguously removable after a re-render. let chatAttachmentSeq = 0; let chatNoticeSeq = 0; /** Revoke an attachment's image object URL, if it created one. */ function releaseAttachment(attachment) { if (attachment?.thumbUrl) { try { URL.revokeObjectURL(attachment.thumbUrl); } catch { // already gone } } } /** Revoke every attachment's object URL (used once the message is sent/gone). */ function releaseAttachments(attachments) { for (const attachment of attachments ?? []) releaseAttachment(attachment); } /** * Fold one server push into its session's thread: any frame for the session * clears the queued notice (the turn it waited behind moved on), and a settled * step clears the running bit the Stop control reads. The live transcript owns * the rest of the frame fold; this only keeps the composer honest while C5 is * still to land. */ function onChatFrame(message) { const frame = message?.chat_event; if (!frame || !frame.session_id) return; const sessionId = frame.session_id; const thread = state.chatThreads.get(sessionId); if (!thread) return; const queued = queuedAfterFrame(thread.queued, frame); const running = runningAfterFrame(thread.running, frame); if (queued === thread.queued && running === thread.running) return; setThread(sessionId, { queued, running }); if (sessionId === state.chatActiveId) renderContent(); } /** Add one local command line to a conversation's transcript. */ function addChatNotice(sessionId, text, { failed = false, offer = null } = {}) { const thread = state.chatThreads.get(sessionId); if (!thread) return; chatNoticeSeq += 1; const notice = makeChatNotice(`notice-${chatNoticeSeq}`, text, { failed, offer }); setThread(sessionId, { notices: appendChatNotice(thread.notices, notice) }); } /** Remove one local command line (the operator cancelled or dismissed it). */ function dismissChatNotice(sessionId, noticeId) { const thread = state.chatThreads.get(sessionId); if (!thread) return; setThread(sessionId, { notices: dismissChatNoticeModel(thread.notices, noticeId) }); renderContent(); } /** * Take an unknown-command offer's draft, removing the notice first so a stale * tap can neither send the same draft twice nor send anything at all. */ function takeChatNoticeOffer(sessionId, noticeId) { const thread = state.chatThreads.get(sessionId); if (!thread) return null; const taken = takeChatNoticeOfferModel(thread.notices, noticeId); if (taken.offer == null) return null; setThread(sessionId, { notices: taken.notices }); return taken.offer; } /** * The composer's draft field, updated in place on every keystroke: the draft is * mirrored into localStorage, the textarea grows to fit (1–6 rows), and the * palette and the send/stop control are refreshed without rebuilding the DOM (so * the operator keeps focus and caret). */ function onComposerInput(event, sessionId, session, controls) { const value = event.target.value; setThread(sessionId, { draft: value }); saveChatDraft(sessionId, value); growComposerTextarea(event.target); refreshComposerControls(sessionId, session, controls); } /** * The composer's key handling. While the offer list is showing, Up/Down move the * highlight and Enter runs the highlighted command (mirrors ChatComposer's * preview handler). Enter otherwise submits — which is inert while a turn is * running unless the palette or a slash draft is present (see composerSubmit); * Shift+Enter is left to insert a newline. */ function onComposerKeydown(event, sessionId, session, controls) { const thread = state.chatThreads.get(sessionId); if (!thread) return; const suggestions = chatCommandSuggestions(thread.draft); if (suggestions.length > 0 && (event.key === "ArrowDown" || event.key === "ArrowUp")) { event.preventDefault(); const step = event.key === "ArrowDown" ? 1 : -1; controls.selected = (controls.selected + step + suggestions.length) % suggestions.length; refreshComposerControls(sessionId, session, controls); return; } if (event.key === "Enter" && !event.shiftKey) { event.preventDefault(); submitChatComposer(sessionId, session, controls); } } /** * Grow the composer's textarea between one and six rows to fit its content. The * element is `box-sizing: border-box` with vertical padding, so the cap and the * measured height both include the padding and the border: a six-row field is * six full text lines, not five-and-a-bit, and the first row is not clipped. */ function growComposerTextarea(el) { if (!el) return; const style = getComputedStyle(el); const line = parseFloat(style.lineHeight) || 20; const border = el.offsetHeight - el.clientHeight; const padding = (parseFloat(style.paddingTop) || 0) + (parseFloat(style.paddingBottom) || 0); const maxRows = 6; const max = line * maxRows + padding + border; el.style.height = "auto"; const wanted = el.scrollHeight + border; el.style.height = `${Math.min(wanted, max)}px`; el.style.overflowY = wanted > max ? "auto" : "hidden"; } /** * Refresh the composer's derived parts (the offer list, the send/stop control) * after a keystroke, without rebuilding the textarea. The highlighted row moves * only through the palette itself, so it is preserved here. */ function refreshComposerControls(sessionId, session, controls) { const thread = state.chatThreads.get(sessionId); if (!thread || !controls) return; const suggestions = chatCommandSuggestions(thread.draft); if (controls.selected >= suggestions.length) controls.selected = 0; fillCommandPalette(controls.palette, suggestions, controls.selected, (index) => { const command = suggestions[index]; if (command) runChatCommand(sessionId, session, `/${command.name}`); }); fillComposerPrimary(controls.primary, thread, { onSend: () => submitChatComposer(sessionId, session, controls), onStop: () => stopChatTurn(sessionId), }); } /** Run the composer's submit (Enter): a command runs, else the draft sends. */ function submitChatComposer(sessionId, session, controls) { const thread = state.chatThreads.get(sessionId); if (!thread) return; const action = composerSubmit(thread, controls?.selected ?? 0); if (action.kind === "command") { runChatCommand(sessionId, session, action.text); } else if (action.kind === "send") { sendChatPrompt(sessionId, session); } } /** * Run one slash command against a conversation (C9). The draft is always consumed * here — a slash draft is never handed to the prompt path — so only an explicit * "Send as message" from an unknown-command offer reaches the agent. Every * outcome is a local transcript line. */ function runChatCommand(sessionId, session, text) { const thread = state.chatThreads.get(sessionId); if (!thread) return; setThread(sessionId, { draft: "" }); saveChatDraft(sessionId, ""); const view = { ...thread, draft: "", directory: session?.directory ?? "", running: thread.running === true }; const effect = chatCommandEffect(parseChatInput(text), view); if (effect == null) return; applyChatCommandEffect(sessionId, session, effect); renderContent(); } /** * Perform one command effect. `/new` creates a session in the current directory * and opens it (the create request is C2's; until C2 lands the browser sends * `chat_create` directly); `/close` reuses the C3 confirm; `/rename` writes to * C13's durable device-local store; `/stop` interrupts; `/help` shows the * command list. */ function applyChatCommandEffect(sessionId, session, effect) { switch (effect.kind) { case "start-session": startChatSession(effect.directory); break; case "finish-session": if (session) openChatClose(session); break; case "rename-session": renameChatSessionLocally(sessionId, effect.title); break; case "stop-turn": stopChatTurn(sessionId); break; case "show-help": addChatNotice(sessionId, chatCommandHelp()); break; case "report": addChatNotice(sessionId, effect.text, { failed: true, offer: effect.offer ?? null }); break; default: break; } } /** `/new`: create a session titled "New chat" in [directory] and open it. */ async function startChatSession(directory) { const from = state.chatActiveId; try { // An automated check (the UI smoke) can mark its throwaway chat ephemeral, so // creating one for verification never adds a stray "New chat" to the // operator's list. Set only by test tooling; a normal page leaves it unset. const ephemeral = globalThis.__pipelinesEphemeralChat === true; const created = await repo.chatCreate("New chat", directory, undefined, { ephemeral }); if (ephemeral) state.chatEphemeralIds = new Set(state.chatEphemeralIds).add(created.id); // The list is the server's; insert the created session so the row is present // before the conversation opens, then refresh from the server. state.chatSessions = [created, ...state.chatSessions.filter((s) => s.id !== created.id)]; state.chatThreads.set(created.id, { draft: "", attachments: [], notices: [], queued: false, running: false, messages: [], nextCursor: "", hasMore: false, loaded: false, loading: true, error: "", }); const title = String(created.title ?? "").trim() || "New chat"; addChatNotice(created.id, `Started a new session “${title}” in ${directory}.`); await openChatSession(created.id); await loadChatSessions(); } catch (error) { if (from) addChatNotice(from, `Couldn't start a new session in ${directory}: ${describeError(error)}`, { failed: true }); state.actionError = describeError(error); renderContent(); } } /** * `/rename`: rename the session on this device only, through the same durable * store the row's Rename chat dialog uses (C13). The local title wins over the * server's on every later refresh; nothing is sent to the server. */ function renameChatSessionLocally(sessionId, title) { const trimmed = String(title ?? "").trim(); if (trimmed === "") return; applyLocalChatRename(sessionId, trimmed); addChatNotice(sessionId, `Renamed this session to “${trimmed}” on this device only; the server's title is unchanged.`); } /** The composer's Stop control: interrupt the session's running turn. */ async function stopChatTurn(sessionId) { try { await repo.chatInterrupt(sessionId); addChatNotice(sessionId, "Stopping the running turn…"); } catch (error) { state.actionError = describeError(error); } renderContent(); } /** * Send the composer's draft with its attachments (mirrors * `AppViewModel.sendChatPrompt`): the draft is trimmed, the compose state is * cleared at once, and a rejected prompt restores the draft and the attachments * with the server's own message. */ async function sendChatPrompt(sessionId, session) { const thread = state.chatThreads.get(sessionId); if (!thread || !composerCanSend(thread)) return; const text = String(thread.draft).trim(); if (text === "") return; const attachments = thread.attachments ?? []; releaseAttachments(attachments); setThread(sessionId, { draft: "", attachments: [] }); saveChatDraft(sessionId, ""); renderContent(); await postChatPrompt(sessionId, text, attachments); } /** * One prompt, from the composer or an unknown-command offer. Flags the chat * running, posts it, and takes the attachments back out flagged with the * server's reason if it is rejected. The live transcript item (C5) owns the * optimistic bubble; this only drives the composer and its request. */ async function postChatPrompt(sessionId, text, attachments) { const body = String(text).trim(); if (body === "") return; setThread(sessionId, { running: true }); renderContent(); try { const queued = await repo.chatPrompt(sessionId, body, attachmentFiles(attachments)); const thread = state.chatThreads.get(sessionId); if (!thread) return; // Prompting a closed session reopens it on the server; clear the local mark // too so the list agrees without a re-fetch. applyChatSessionUpdate(sessionId, null, false); setThread(sessionId, { queued, running: true }); renderContent(); } catch (error) { const message = describeError(error); const restored = (attachments ?? []).map((attachment) => { releaseAttachment(attachment); return { ...attachment, thumbUrl: null, error: message }; }); setThread(sessionId, { running: false, queued: false, error: message, draft: body, attachments: restored, }); saveChatDraft(sessionId, body); state.actionError = message; renderContent(); } } /** Send an unknown-command offer's draft through the ordinary prompt path. */ function sendChatCommandOffer(sessionId, noticeId) { const offer = takeChatNoticeOffer(sessionId, noticeId); if (offer == null) return; renderContent(); postChatPrompt(sessionId, offer, []); } /** * Resolve the files the operator picked into composer attachments. Only the * metadata is read here (nothing is transmitted until the message is sent): the * browser has no `content://` reference, so the file's own name is carried as the * best-effort reference string. A file over the limit is returned with its error * set rather than dropped. */ function onChatFilesPicked(sessionId, session, fileList) { const thread = state.chatThreads.get(sessionId); if (!thread) return; const picked = []; for (const file of fileList ?? []) { chatAttachmentSeq += 1; const name = String(file?.name ?? ""); const mime = String(file?.type ?? ""); const size = Number(file?.size) || 0; picked.push({ id: `att-${chatAttachmentSeq}`, name, uri: name, mime, size, error: attachmentError(name, size, true), thumbUrl: mime.startsWith("image/") ? createThumbUrl(file) : null, file, }); } if (picked.length === 0) return; setThread(sessionId, { attachments: [...(thread.attachments ?? []), ...picked] }); renderContent(); } /** An object URL for a local image preview, or null when the browser refuses one. */ function createThumbUrl(file) { try { return URL.createObjectURL(file); } catch { return null; } } /** Remove one attachment from the next message and release its preview URL. */ function removeChatAttachment(sessionId, attachmentId) { const thread = state.chatThreads.get(sessionId); if (!thread) return; const attachment = (thread.attachments ?? []).find((entry) => entry.id === attachmentId); releaseAttachment(attachment); setThread(sessionId, { attachments: (thread.attachments ?? []).filter((entry) => entry.id !== attachmentId), }); renderContent(); } function renderChatList() { // The open menu must not be clipped by the list's rounded-corner overflow; the // class is present only while a menu is open, so the normal list stays clipped. const list = h("div", { class: `list chat-list${state.chatMenu ? " menu-open" : ""}` }); const toolbar = h("div", { class: "list-toolbar chat-toolbar" }); toolbar.append( h("input", { id: "chatSearch", class: "chat-search", type: "text", placeholder: CHAT_SEARCH_LABEL, "aria-label": CHAT_SEARCH_LABEL, value: state.chatQuery, spellcheck: "false", autocomplete: "off", oninput: (event) => { state.chatQuery = event.target.value; fillChatRows(rows); }, }), // C2: the create path stays one tap away while the list is narrowed, the same // trailing action the app keeps beside its search control. h("button", { class: "ghost chat-new", type: "button", text: CHAT_NEW_ACTION, onclick: startNewChat, }), ); list.append(toolbar); const rows = h("div", { id: "chatRows", class: "chat-rows" }); fillChatRows(rows); list.append(rows); return list; } /** The list body: the loading/error/empty states or the grouped session rows. */ function fillChatRows(rows) { rows.replaceChildren(); if (state.chatLoading && state.chatSessions.length === 0 && !state.chatLoaded) { rows.append(chatEmpty(CHAT_LOADING)); return; } if (state.chatError && state.chatSessions.length === 0) { const empty = chatEmpty(state.chatError); empty.append( h("button", { class: "ghost", type: "button", text: "Retry", onclick: () => loadChatSessions(true) }), ); rows.append(empty); return; } const visible = applyChatOverrides(state.chatSessions, state.chatOverrides); const filtered = filterSessions(visible, state.chatQuery); if (filtered.length === 0 && state.chatQuery.trim() !== "") { const empty = chatEmpty(chatNoMatchMessage(state.chatQuery)); empty.append( h("button", { class: "ghost", type: "button", text: CHAT_NO_MATCH_ACTION, onclick: () => { state.chatQuery = ""; renderContent(); }, }), ); rows.append(empty); return; } if (filtered.length === 0) { const empty = chatEmpty(CHAT_EMPTY); empty.append( h("button", { class: "ghost chat-new", type: "button", text: CHAT_NEW_ACTION, onclick: startNewChat, }), ); rows.append(empty); return; } const active = filtered.filter((session) => !session.closed); const closed = filtered.filter((session) => session.closed); const groups = groupSessionsByDirectory(active); if (groups.length > 1) { for (const group of groups) { rows.append(h("div", { class: "chat-group-header", text: directoryLabel(group.directory) })); for (const session of group.sessions) rows.append(renderChatRow(session)); } } else { for (const session of active) rows.append(renderChatRow(session)); } if (closed.length > 0) { rows.append(h("div", { class: "chat-group-header", text: CLOSED_SECTION_LABEL })); for (const session of closed) rows.append(renderChatRow(session)); } if (state.chatError) { rows.append(h("div", { class: "chat-error muted", text: state.chatError })); } } function chatEmpty(message) { return h("div", { class: "empty" }, h("span", { class: "muted", text: message })); } /** * One session row: title, kind chip, a Closed chip only when closed, the * activity badge word, the work-label meta line and the close/reopen action. * Every server string is set with textContent. */ function renderChatRow(session) { const open = state.chatActiveId === session.id; const thread = state.chatThreads.get(session.id) ?? null; const unseen = !session.closed && isChatSessionUnseen(session, { activeId: state.chatActiveId, seen: state.chatSeen, opened: state.chatThreads.has(session.id), }); const activity = sessionActivity(thread?.running === true, unseen); const badge = sessionActivityBadge(activity, open); const row = h("div", { class: `row chat-row${open ? " selected" : ""}`, role: "button", tabindex: "0", "data-session": session.id, onclick: () => openChatSession(session.id), onkeydown: (event) => { // Only the row itself opens on Enter/Space; the Chat actions menu handles // its own keyboard activation (and must not double-fire). if (event.target !== event.currentTarget) return; if (event.key === "Enter" || event.key === " ") { event.preventDefault(); openChatSession(session.id); } }, }); const head = h("div", { class: "row-head" }); head.append(h("span", { class: "row-title chat-row-title", text: sessionTitle(session) })); const chip = sessionChipLabel(session); if (chip) head.append(h("span", { class: "chip chat-kind-chip", text: chip })); if (session.closed) head.append(h("span", { class: "chip chat-closed-chip", text: CLOSED_CHIP_LABEL })); if (badge) { head.append( h("span", { class: `chat-activity chat-activity-${activity}` }, h("span", { class: "chat-activity-dot", "aria-hidden": "true" }), h("span", { class: "chat-activity-word", text: badge }), ), ); } row.append(head); row.append( h("span", { class: "row-meta chat-row-meta", text: sessionMeta(session, sessionWorkLabel(session.busy === true, thread)), }), ); row.append(renderChatActionsMenu(session)); return row; } /** * The create pane (C2): the app's NewChatPane. A back control leaves without * creating, then the directory error / loading / picker states in the app's own * order, the model note and the footer naming the value that will be sent. Every * server string is set with textContent. */ function renderChatCreate() { const create = state.chatCreate; const pane = h("div", { class: "detail chat-detail chat-create" }); const bar = h("div", { class: "chat-bar chat-create-bar" }); bar.append( h( "button", { class: "ghost chat-create-back", type: "button", "aria-label": CHAT_CREATE_BACK_LABEL, title: CHAT_CREATE_BACK_LABEL, onclick: cancelNewChat, }, h("span", { class: "chat-create-back-glyph", "aria-hidden": "true", text: "←" }), ), h("h2", { class: "chat-bar-title chat-create-title", text: CHAT_CREATE_TITLE }), ); pane.append(bar); if (state.chatDirectoriesError && !state.chatDirectoriesLoaded) { const empty = chatEmpty(state.chatDirectoriesError); empty.classList.add("chat-create-directories-error"); empty.append( h("button", { class: "ghost chat-create-retry", type: "button", text: "Retry", onclick: () => loadChatDirectories(true), }), ); pane.append(empty); } else if (!state.chatDirectoriesLoaded) { pane.append(h("div", { class: "chat-create-loading muted", text: CHAT_CREATE_LOADING })); } else { pane.append(h("div", { class: "chat-create-prompt muted", text: CHAT_CREATE_PROMPT })); const choices = directoryChoices(state.chatDirectories); const selected = choices.find((choice) => choice.createDirectory === create.directory) ?? defaultDirectoryChoice(choices); const list = h("div", { class: "chat-create-choices", role: "listbox", "aria-label": CHAT_CREATE_PROMPT, }); for (const choice of choices) { const active = choice.createDirectory === selected?.createDirectory; const row = h("button", { class: `row chat-create-choice${active ? " selected" : ""}`, type: "button", role: "option", "aria-selected": active ? "true" : "false", "data-directory": choice.createDirectory, onclick: () => selectChatDirectory(choice.createDirectory), }); row.append(h("span", { class: "row-title chat-create-choice-label", text: choice.label })); if (choice.secondary) { row.append(h("span", { class: "row-meta chat-create-choice-path", text: choice.secondary })); } list.append(row); } pane.append(list); // A refresh that failed after a successful first load keeps the choices and // says why the list may be stale (the app's own bodySmall error line). if (state.chatDirectoriesError) { pane.append(h("div", { class: "chat-create-directories-error", text: state.chatDirectoriesError })); } if (create.error) { pane.append(h("div", { class: "chat-create-error", text: create.error })); } pane.append(h("p", { class: "chat-create-model-note muted", text: CHAT_CREATE_MODEL_NOTE })); const directory = selected?.createDirectory ?? create.directory; const footer = h("div", { class: "chat-create-footer" }); footer.append(h("span", { class: "chat-create-start", text: chatStartInLabel(directory) })); footer.append( h("button", { class: "ghost chat-create-cancel", type: "button", text: CHAT_CREATE_CANCEL, disabled: create.creating, onclick: cancelNewChat, }), ); const confirm = h("button", { class: "chat-create-confirm", type: "button", "aria-label": CHAT_CREATE_CONFIRM, disabled: create.creating, onclick: createNewChat, }); if (create.creating) { confirm.append(h("span", { class: "spinner chat-create-spinner", "aria-hidden": "true" })); } else { confirm.append(document.createTextNode(CHAT_CREATE_CONFIRM)); } footer.append(confirm); pane.append(footer); } appendChatDialogs(pane); return pane; } /** * One row's Chat actions menu, with Android's items in its order: Rename…, then * Close chat… (open) or Reopen (closed), then Hide on this device. Closing is the * shared, server-side finish; hiding only affects this device and says so. */ function renderChatActionsMenu(session) { const wrap = h("div", { class: "chat-row-actions chat-menu-wrap" }); const expanded = state.chatMenu === session.id; wrap.append( h("button", { class: "ghost chat-menu-button", type: "button", text: "⋯", "aria-label": CHAT_ACTIONS_LABEL, "aria-haspopup": "menu", "aria-expanded": expanded ? "true" : "false", title: CHAT_ACTIONS_LABEL, onclick: (event) => { event.stopPropagation(); openChatMenu(session.id); }, }), ); if (expanded) { const menu = h("div", { class: "chat-menu-panel", role: "menu", "aria-label": CHAT_ACTIONS_LABEL }); menu.addEventListener("click", (event) => event.stopPropagation()); menu.append( h("button", { class: "ghost chat-menu-item chat-menu-rename", type: "button", role: "menuitem", text: CHAT_RENAME_ACTION, onclick: () => openChatRename(session), }), ); if (session.closed) { menu.append( h("button", { class: "ghost chat-menu-item chat-menu-reopen", type: "button", role: "menuitem", text: REOPEN_ACTION, disabled: state.chatBusy, onclick: () => reopenChatSession(session.id), }), ); } else { menu.append( h("button", { class: "ghost chat-menu-item chat-menu-close", type: "button", role: "menuitem", text: CLOSE_CHAT_ACTION, disabled: state.chatBusy, onclick: () => openChatClose(session), }), ); } menu.append( h("button", { class: "ghost chat-menu-item chat-menu-hide", type: "button", role: "menuitem", text: CHAT_HIDE_ACTION, onclick: () => hideChatLocally(session.id), }), ); wrap.append(menu); } return wrap; } /** The active conversation: identity, context, transcript and its controls. */ function renderChatConversation() { const pane = h("div", { class: "detail chat-detail" }); if (!state.chatActiveId) { pane.append(chatEmpty(SELECT_CHAT_HINT)); appendChatDialogs(pane); return pane; } const session = state.chatSessions.find((candidate) => candidate.id === state.chatActiveId) ?? null; const effective = effectiveChatSession(session); const thread = state.chatThreads.get(state.chatActiveId) ?? null; const title = effective ? sessionTitle(effective) : state.chatActiveId.slice(0, 18); // The pending approval card (C10), derived from the stored frame plus the local // answer. While it is actionable the top bar offers a jump control and the // running indicator stands down (a turn blocked on a decision is not generating). const approval = approvalCard(thread?.permission, thread?.permissionAnswer); const awaiting = approval?.actionable === true; const bar = h("div", { class: "chat-bar" }); const titles = h("div", { class: "chat-bar-titles" }); titles.append(h("h2", { class: "chat-bar-title", text: title })); const meta = chatHeaderMeta({ model: session?.model, tag: session?.tag, directory: session?.directory, }); if (meta !== "") titles.append(h("div", { class: "chat-bar-meta muted", text: meta })); bar.append(titles); if (thread?.hasMore) { bar.append( h("button", { class: "ghost chat-load-older", type: "button", text: LOAD_OLDER_ACTION, disabled: thread.loading, onclick: () => loadOlderChatHistory(state.chatActiveId), }), ); } // The approval jump control appears only while a request is actionable, and // brings its card (the transcript's last item) into view — the one scroll path, // so a pending request is reached the same way new content is. if (awaiting) bar.append(approvalJumpButton()); pane.append(bar); // The context line: the kind chip, the activity word and directory · model. const context = h("div", { class: "chat-context" }); const chip = session ? sessionChipLabel(session) : null; if (chip) context.append(h("span", { class: "chip chat-kind-chip", text: chip })); context.append( h("span", { class: "chat-context-activity", text: sessionStatusLabel(thread?.running === true, session?.closed === true), }), ); // The live-stream badge (C5): live while this session is subscribed, the same // words as the run badge (`live` / `reconnecting` / `not live`). context.append( renderLiveBadge({ ...chatStreamState(state.connection.kind, state.chatSubscriptions.has(state.chatActiveId)), title: "Live chat stream", }), ); const contextMeta = [session?.directory, session?.model] .map((value) => String(value ?? "").trim()) .filter((value) => value !== "") .join(" · "); if (contextMeta !== "") context.append(h("span", { class: "chat-context-meta muted", text: contextMeta })); pane.append(context); // The background-tasks bar (C11) sits above the transcript, outside the // scroller so the C14 scroll positions are untouched. It is present only while // a shell is still running and disappears with the last exit. const backgroundTasks = renderBackgroundTasks(thread); if (backgroundTasks) pane.append(backgroundTasks); const notices = thread?.notices ?? []; if (thread?.loading && !thread?.loaded) { pane.append(h("div", { class: "chat-transcript-empty muted", text: CONVERSATION_LOADING })); } else if (thread?.error && !thread?.loaded) { const empty = chatEmpty(thread.error); empty.append( h("button", { class: "ghost", type: "button", text: "Retry", onclick: () => loadChatHistory(state.chatActiveId), }), ); pane.append(empty); } else { const rows = transcriptRows(thread?.messages ?? []); // The running indicator stands down while an approval is pending (C10): a turn // blocked on a decision is not generating, so neither the spinner nor its clock // shows. The composer's Stop control stays governed by thread.running. const running = thread?.running === true && !awaiting; if (rows.length === 0 && notices.length === 0 && !running && !approval) { pane.append(h("div", { class: "chat-transcript-empty muted", text: CONVERSATION_EMPTY })); } else { pane.append( renderChatTranscript(state.chatActiveId, rows, { notices, running, now: Date.now(), approval }), ); } if (thread?.error && thread?.loaded) { pane.append(h("div", { class: "chat-transcript-error", text: thread.error })); } } // The composer sits at the foot of the conversation, always available while a // chat is open (the transcript may still be loading). pane.append(renderChatComposer(thread, session, state.chatActiveId)); appendChatDialogs(pane); return pane; } /** * The chat overlays, appended to the conversation pane whether or not a * conversation is open: the row's own `Close chat…` action is offered on every * open row, so its confirm must appear even when no chat is selected. */ function appendChatDialogs(pane) { if (state.chatClose) pane.append(renderChatCloseDialog(state.chatClose)); if (state.chatRename) pane.append(renderChatRenameDialog(state.chatRename)); if (state.chatSnackbar) pane.append(renderChatSnackbar()); if (state.actionError) pane.append(renderActionFailedDialog()); } /** * The one hide report (C13): the exact Android message and an `Undo` action. It * is a fixed overlay (so a re-render or the transcript's height never moves it) * and it is replaced, never queued, by a newer hide. */ function renderChatSnackbar() { const bar = h("div", { class: "chat-snackbar", role: "status" }); bar.append(h("span", { class: "chat-snackbar-message", text: CHAT_REMOVED_MESSAGE })); bar.append( h("button", { class: "ghost chat-snackbar-undo", type: "button", text: CHAT_UNDO_ACTION, onclick: () => undoHideChat(), }), ); return bar; } /** * The Rename chat dialog (C13): a locally-kept name, with the helper that says so * plainly. Save is disabled while the trimmed value is blank; typing toggles that * state directly, so the transcript's scroll is never disturbed by a re-render. * Nothing is sent to the server — there is no chat rename on the wire. */ function renderChatRenameDialog(session) { const effective = effectiveChatSession(session) ?? session; const overlay = h("div", { class: "confirm-dialog confirm-chat-rename", role: "dialog", "aria-modal": "true", "aria-label": CHAT_RENAME_TITLE, }); overlay.addEventListener("click", (event) => { if (event.target === overlay) dismissChatRename(); }); const panel = h("div", { class: "confirm-panel" }); panel.append(h("h2", { class: "confirm-title", text: CHAT_RENAME_TITLE })); const field = h("div", { class: "chat-rename-field" }); field.append(h("label", { class: "chat-rename-label", for: "chatRenameInput", text: CHAT_RENAME_FIELD_LABEL })); const input = h("input", { id: "chatRenameInput", class: "rename-input chat-rename-input", type: "text", value: sessionTitle(effective), spellcheck: "false", autocomplete: "off", }); field.append(input); panel.append(field); panel.append(h("p", { class: "chat-rename-helper", text: CHAT_RENAME_HELPER })); const actions = h("div", { class: "confirm-actions" }); actions.append( h("button", { class: "ghost confirm-dismiss chat-rename-cancel", type: "button", text: CHAT_RENAME_DISMISS, onclick: dismissChatRename, }), ); const save = h("button", { class: "confirm-accept chat-rename-save", type: "button", text: CHAT_RENAME_SAVE, disabled: input.value.trim() === "", onclick: () => acceptChatRename(session, input.value), }); // Toggle Save in place on input: no renderContent, so the transcript's scroll // position (C14) is untouched while the operator types. input.addEventListener("input", () => { save.disabled = input.value.trim() === ""; }); actions.append(save); panel.append(actions); overlay.append(panel); return overlay; } /** * The background-tasks bar (C11): the running shells this conversation still * owns. It returns null (renders nothing) unless at least one shell is running, * so it disappears the moment the last task exits. Heading `Background tasks` + * `{n} running`; the list shows at most BACKGROUND_TASK_VISIBLE_ROWS rows and * scrolls beyond; a selected row reveals its bounded, read-only output pane. * Every server string is set with textContent (never innerHTML). */ function renderBackgroundTasks(thread) { const running = runningBackgroundShells(thread?.shells ?? []); if (running.length === 0) return null; const wrap = h("section", { class: "chat-bg-tasks", id: "chatBackgroundTasks" }); const head = h("div", { class: "chat-bg-tasks-head" }); head.append(h("span", { class: "chat-bg-tasks-title", text: BACKGROUND_TASKS_TITLE })); head.append( h("span", { class: "chat-bg-tasks-count muted", text: backgroundTasksRunningLabel(running.length) }), ); wrap.append(head); const list = h("div", { class: "chat-bg-tasks-list" }); const selectedId = thread?.selectedShellId ?? null; running.forEach((shell) => list.append(renderBackgroundTaskRow(shell, shell.id === selectedId))); wrap.append(list); const selected = running.find((shell) => shell.id === selectedId) ?? null; if (selected) wrap.append(renderBackgroundTaskDetail(thread, selected)); return wrap; } /** One running shell task; tapping it toggles its detail pane. */ function renderBackgroundTaskRow(shell, selected) { const row = h("button", { class: `chat-bg-task${selected ? " selected" : ""}`, type: "button", "data-shell": shell.id, "aria-pressed": selected ? "true" : "false", onclick: () => selectChatShell(shell.id), }); // A CSS play glyph, decorative only (the row's own text names the task). row.append(h("span", { class: "chat-bg-task-glyph", "aria-hidden": "true" })); row.append(h("span", { class: "chat-bg-task-status", text: SHELL_ROW_LABEL })); row.append( h("span", { class: "chat-bg-task-command", text: shellCommandSummary(shell.command), title: String(shell.command ?? ""), }), ); if (selected) row.append(h("span", { class: "chat-bg-task-details muted", text: SHELL_DETAILS_LABEL })); return row; } /** * The selected task's read-only detail: its command, its identity in monospace * and `Status: running`, then the output area — the exact label order and wording * of ChatTranscript.BackgroundProcessDetail. Reload is always a bounded reread * from the page's start (`Refresh`; `Retry` after a failure). */ function renderBackgroundTaskDetail(thread, shell) { const labels = SHELL_OUTPUT_LABELS; const pane = h("div", { class: "chat-bg-task-detail" }); pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.COMMAND })); const command = String(shell.command ?? "").trim(); pane.append( h("div", { class: "chat-bg-task-command-full", text: command === "" ? labels.UNAVAILABLE : shell.command, }), ); pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.TASK_IDENTITY })); pane.append(h("div", { class: "chat-bg-task-id monospace", text: String(shell.id ?? "") })); pane.append(h("div", { class: "chat-bg-task-status-line", text: labels.STATUS_RUNNING })); const output = thread?.shellOutput ?? null; switch (shellOutputState(output)) { case SHELL_OUTPUT_LOADING: pane.append(h("span", { class: "spinner chat-bg-task-spinner", "aria-hidden": "true" })); break; case SHELL_OUTPUT_ERROR: { const row = h("div", { class: "chat-bg-task-error-row" }); row.append(h("span", { class: "chat-bg-task-error", text: output.error })); row.append( h("button", { class: "ghost chat-bg-task-retry", type: "button", text: labels.RETRY, onclick: () => refreshChatShellOutput(shell.id), }), ); pane.append(row); break; } case SHELL_OUTPUT_UNAVAILABLE: pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.OUTPUT_UNAVAILABLE })); break; case SHELL_OUTPUT_EMPTY: pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.NO_OUTPUT })); break; case SHELL_OUTPUT_READY: { const page = output.page; pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.OUTPUT })); // Untrusted shell text: set as textContent, never parsed as markup. pane.append(h("pre", { class: "chat-bg-task-output", text: String(page.output ?? "") })); if (page.truncated) { pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.OUTPUT_BOUNDED })); } pane.append( h("button", { class: "ghost chat-bg-task-refresh", type: "button", text: labels.REFRESH, onclick: () => refreshChatShellOutput(shell.id), }), ); break; } default: break; } return pane; } /** * The transcript: one column of turns. An operator message is its own * right-aligned bubble (with the sending client's label when the server echoed * one); consecutive assistant messages are one left-aligned agent bubble, drawn * in order as the reasoning block, then the tool-call chip, then the answer * markdown. No timestamps, model or agent are shown inside the transcript. */ function renderChatTranscript( sessionId, rows, { notices = [], running = false, now = Date.now(), approval = null } = {}, ) { const wrap = h("div", { class: "chat-transcript-wrap" }); const transcript = h("div", { class: "chat-transcript", id: "chatTranscript", "data-session": sessionId, }); const thread = state.chatThreads.get(sessionId) ?? null; let lastAgent = -1; rows.forEach((row, index) => { if (row.kind === "agent") lastAgent = index; }); rows.forEach((row, index) => { if (row.kind === "user") transcript.append(renderChatUserMessage(row.message)); else { const streaming = running && index === lastAgent; const elapsed = (part) => threadToolElapsedMillis(thread, part, now); transcript.append(renderChatAgentTurn(row.turn, streaming, elapsed)); } }); // The running indicator sits under the transcript, after the last agent turn: // a spinner, the phase headline, the turn's elapsed, then one line per running // tool (a call over 60 s is tinted and marked `· long`). if (running && thread) transcript.append(renderChatRunningIndicator(thread, now)); // The conversation's local command lines sit after the turns, full width and // deliberately unlike a message bubble (see ChatCommandNoticeItem). for (const notice of notices) transcript.append(renderChatCommandNotice(sessionId, notice)); // The approval card is the transcript's last item (C10) — after the notices and // after the running indicator when it is shown — so the top bar's jump control // and a fresh card both land at the end. if (approval) transcript.append(renderChatApproval(sessionId, approval)); wrap.append(transcript); wrap.append( h("button", { class: "ghost chat-jump", id: "chatJump", type: "button", text: "Jump to latest", hidden: true, onclick: () => { state.chatFollowing = true; const el = document.getElementById("chatTranscript"); if (el) el.scrollTop = el.scrollHeight; updateChatJump(el); }, }), ); return wrap; } /** The top bar's approval jump control (C10), naming the pending request. */ function approvalJumpButton() { return h("button", { class: "ghost chat-approval-jump", type: "button", text: WAITING_FOR_APPROVAL_LABEL, onclick: () => { // The card is the transcript's last item, so the transcript's own end is the // card; the one scroll path shared with jump-to-latest. const el = document.getElementById("chatTranscript"); if (!el) return; state.chatFollowing = true; el.scrollTop = el.scrollHeight; updateChatJump(el); }, }); } /** * One approval request as a card (C10), the browser's port of * `ui/chat/ChatApprovalCard.kt`: a shield and the headline, the status line, the * request's resources newline-joined in monospace (blank entries dropped, at most * six lines), the amber `RISK REVIEW` panel only while the app shows it, and the * once/always/reject controls only while the request is actionable. Every server * string is set with textContent and every node is built by hand. */ function renderChatApproval(sessionId, card) { const node = h("div", { class: `chat-approval${card.actionable ? " chat-approval-pending" : ""}`, id: "chatApproval", "data-request-id": card.requestId, }); const head = h("div", { class: "chat-approval-head" }); head.append(shieldIcon("chat-approval-shield")); const titles = h("div", { class: "chat-approval-titles" }); titles.append(h("div", { class: "chat-approval-headline", text: card.headline })); titles.append(h("div", { class: "chat-approval-status muted", text: card.statusLine })); head.append(titles); node.append(head); if (card.resourceText !== "") { // The padded frame around a padding-free clamp block: clamping the padded // element itself lets the seventh line paint into its bottom padding. const box = h("div", { class: "chat-approval-resources" }); box.append(h("pre", { class: "chat-approval-resources-text", text: card.resourceText })); node.append(box); } if (card.showRisk && card.risk.trim() !== "") { const risk = h("div", { class: "chat-approval-risk" }); const riskHead = h("div", { class: "chat-approval-risk-head" }); riskHead.append(shieldIcon("chat-approval-risk-shield")); riskHead.append(h("span", { class: "chat-approval-risk-label", text: RISK_REVIEW_LABEL })); risk.append(riskHead); risk.append(h("div", { class: "chat-approval-risk-text", text: card.risk })); node.append(risk); } if (card.actionable) { const controls = h("div", { class: "chat-approval-controls" }); controls.append(approvalControl(APPROVAL_CONTROL_ONCE, DECISION_ONCE, sessionId, card.requestId, "primary")); controls.append(approvalControl(APPROVAL_CONTROL_ALWAYS, DECISION_ALWAYS, sessionId, card.requestId)); controls.append(approvalControl(APPROVAL_CONTROL_REJECT, DECISION_REJECT, sessionId, card.requestId)); node.append(controls); } return node; } /** * The app's amber outlined Shield (`Icons.Outlined.Shield`): an inline SVG stroked * with `currentColor` so the palette's warn hue actually tints it, unlike the * colour emoji it replaces. Decorative — the headline carries the meaning. */ function shieldIcon(className) { const NS = "http://www.w3.org/2000/svg"; const svg = document.createElementNS(NS, "svg"); svg.setAttribute("class", className); svg.setAttribute("viewBox", "0 0 24 24"); svg.setAttribute("aria-hidden", "true"); svg.setAttribute("focusable", "false"); const path = document.createElementNS(NS, "path"); path.setAttribute("d", "M12 3 5 6v5.5c0 4.2 2.8 8.1 7 9.5 4.2-1.4 7-5.3 7-9.5V6l-7-3z"); path.setAttribute("fill", "none"); path.setAttribute("stroke", "currentColor"); path.setAttribute("stroke-width", "1.8"); path.setAttribute("stroke-linejoin", "round"); svg.append(path); return svg; } function approvalControl(label, decision, sessionId, requestId, extraClass = "") { return h("button", { class: `chat-approval-control${extraClass ? ` ${extraClass}` : ""}`, type: "button", text: label, onclick: () => answerPermission(sessionId, requestId, decision), }); } /** * The in-flight turn's indicator: a spinner, the phase headline (`Thinking…` / * `Running a tool…` / `Waiting…`), `· {elapsed}`, then one line per running tool * with its own elapsed. A call that has passed [TOOL_LONG_RUNNING_MILLIS] is * tinted and marked `· long` — the same threshold the tool chip uses. */ function renderChatRunningIndicator(thread, now) { const wrap = h("div", { class: "chat-running", id: "chatRunning" }); const head = h("div", { class: "chat-running-head" }); head.append(h("span", { class: "spinner chat-running-spinner", "aria-hidden": "true" })); head.append( h("span", { class: "chat-running-label", text: turnPhaseLabel(threadPhase(thread, now) ?? TURN_PHASE_WAITING), }), ); head.append( h("span", { class: "chat-running-elapsed", text: `\u00b7 ${formatDuration(Math.trunc(threadElapsedMillis(thread, now) / 1000))}`, }), ); wrap.append(head); for (const part of threadRunningTools(thread.messages)) { wrap.append(renderChatRunningTool(thread, part, now)); } return wrap; } function renderChatRunningTool(thread, part, now) { const line = h("div", { class: "chat-running-tool", "data-part-id": String(part?.id ?? "") }); const name = toolLabel(part); const detail = toolDetail(part); line.append(h("span", { class: "chat-running-tool-text", text: detail == null ? name : `${name} ${detail}` })); line.append( h("span", { class: "chat-running-tool-elapsed muted", text: formatToolDuration(threadToolElapsedMillis(thread, part, now)), }), ); if (toolLongRunning(threadToolElapsedMillis(thread, part, now))) { line.classList.add("chat-running-tool-long"); line.append(h("span", { class: "chat-tool-long", text: "\u00b7 long" })); } return line; } /** One operator turn, right-aligned, carrying its sender label when present. */ function renderChatUserMessage(message) { const turn = h("div", { class: "chat-turn chat-turn-user" }); const bubble = h("div", { class: "chat-bubble user-bubble" }); const client = String(message?.client ?? "").trim(); if (client !== "") bubble.append(h("div", { class: "chat-client", text: message.client })); const text = (message?.parts ?? []) .filter((part) => part?.type === "text" || !part?.type) .map((part) => String(part?.text ?? "")) .join("\n") .trim(); if (text !== "") bubble.append(h("div", { class: "chat-user-text", text })); turn.append(bubble); return turn; } /** One folded agent reply, left-aligned: reasoning, tool-call chip, answer. */ function renderChatAgentTurn(turn, streaming = false, elapsedMillis = () => 0) { const wrap = h("div", { class: "chat-turn chat-turn-agent" }); const bubble = h("div", { class: "chat-bubble agent-bubble" }); const steps = turn.reasoningSteps; if (steps.length > 0) bubble.append(renderChatReasoning(turn, streaming)); if (turn.tools.length > 0) { const tools = renderChatToolCalls(turn, { streaming, elapsedMillis }); if (tools) bubble.append(tools); } if (turn.answer.trim() !== "") bubble.append(renderMarkdown(turn.answer)); wrap.append(bubble); return wrap; } /** * The turn's one collapsible reasoning block. The open/closed state lives on the * conversation keyed by the turn, so it survives a re-render; toggling it never * rebuilds the transcript (and so never moves the operator's scroll). The label is * the app's own (see `reasoningLabel`) with the turn's server-reported duration * appended when it has one; a settled history turn reads `Reasoning` (or * `Reasoning · N steps`), a live one `Thinking…`/`Thinking · N steps`. Live * elapsed time is C5's; this renders the parts' own timing. */ function renderChatReasoning(turn, streaming = false) { const expanded = state.chatReasoning.has(turn.key); const block = h("div", { class: "chat-reasoning" }); const toggle = h("button", { class: "chat-reasoning-toggle", type: "button", "aria-expanded": String(expanded), }); toggle.append( h("span", { class: "chat-reasoning-icon", role: "img", "aria-label": expanded ? "Hide reasoning" : "Show reasoning", text: expanded ? "\u25be" : "\u25b8", }), ); const label = reasoningLabel(turn.reasoningSteps.length, streaming); const elapsedMillis = turnElapsedMillis(turn.parts); const duration = elapsedMillis == null ? null : formatDuration(Math.trunc(elapsedMillis / 1000)); toggle.append( h("span", { class: "chat-reasoning-label", text: duration == null ? label : `${label} · ${duration}`, }), ); const body = h("div", { class: "chat-reasoning-body", text: turn.reasoning }); body.hidden = !expanded; toggle.addEventListener("click", () => { const next = body.hidden; body.hidden = !next; toggle.setAttribute("aria-expanded", String(next)); const icon = toggle.querySelector(".chat-reasoning-icon"); icon.textContent = next ? "\u25be" : "\u25b8"; icon.setAttribute("aria-label", next ? "Hide reasoning" : "Show reasoning"); if (next) state.chatReasoning.add(turn.key); else state.chatReasoning.delete(turn.key); }); block.append(toggle, body); return block; } /** * One turn's tool calls behind a single summary chip (C6), the browser's port of * `ui/chat/ChatToolCalls.kt`: `N tools called`, a spinner while any call is in * flight, a `· long` mark (error tint) once a running call has passed * [TOOL_LONG_RUNNING_MILLIS], error styling once a call failed, and a chevron * naming the panel it opens. The panel is a fixed overlay anchored below the chip * (flipped above when there is no room), with a header count, a close control, an * internally scrolling list, and per-row expand state; because it never joins the * transcript's flow, opening or closing it cannot re-flow the conversation nor * move its scroll position (C14). * * [streaming] is whether the turn is still live, and [elapsedMillis] the live age * of a running call (the conversation supplies it from its own clock, so the * `long` mark is derived from real time, never guessed). A settled history turn * passes neither, so a stored `running` status cannot spin or wear the mark. */ function renderChatToolCalls(turn, { streaming = false, elapsedMillis = () => 0 } = {}) { const parts = turn.tools; if (parts.length === 0) return null; const count = toolCallCount(turn.parts); const running = streaming && toolsRunning(turn.parts); const failed = parts.some((part) => toolFailed(part.state)); const long = running && parts.some((part) => toolRunning(part) && toolLongRunning(elapsedMillis(part))); const turnKey = turn.key; const wrap = h("div", { class: "chat-tools" }); const open = state.chatToolPanels.has(turnKey); const chip = h("button", { class: `chip chat-tool-chip${failed ? " chat-tool-chip-failed" : ""}`, type: "button", "aria-label": toolCallsAnnouncement(count), "aria-expanded": String(open), }); if (running) { chip.append(h("span", { class: "spinner chat-tool-spinner", "aria-hidden": "true" })); } else { chip.append( h("span", { class: `chat-tool-icon${failed ? " chat-tool-icon-failed" : ""}`, "aria-hidden": "true", text: failed ? "\u26a0" : "\u29c9", }), ); } chip.append(h("span", { class: "chat-tool-label", text: toolCallsLabel(count) })); if (long) chip.append(h("span", { class: "chat-tool-long", text: "\u00b7 long" })); const chevron = h("span", { class: "chat-tool-chevron", role: "img", "aria-label": open ? "Hide tool calls" : "Show tool calls", text: open ? "\u25b4" : "\u25be", }); chip.append(chevron); wrap.append(chip); const panel = h("div", { class: "chat-tool-panel", role: "dialog", "aria-label": toolCallsLabel(count) }); panel.hidden = !open; const head = h("div", { class: "chat-tool-panel-head" }); head.append(h("span", { class: "chat-tool-panel-count", text: toolCallsLabel(count) })); const close = h("button", { class: "ghost chat-tool-close", type: "button", "aria-label": "Close tool calls", title: "Close tool calls", text: "\u00d7", }); head.append(close); panel.append(head); const list = h("div", { class: "chat-tool-list" }); for (const part of parts) { const id = String(part?.id ?? ""); const holder = h("div", { class: "chat-tool-row-holder" }); const build = () => renderToolCallRow(part, { expanded: state.chatToolRows.has(id), onToggle: () => { if (state.chatToolRows.has(id)) state.chatToolRows.delete(id); else state.chatToolRows.add(id); holder.replaceChild(build(), holder.firstChild); }, }); holder.append(build()); list.append(holder); } panel.append(list); wrap.append(panel); const setOpen = (next) => { if (next) state.chatToolPanels.add(turnKey); else state.chatToolPanels.delete(turnKey); panel.hidden = !next; chip.setAttribute("aria-expanded", String(next)); chevron.setAttribute("aria-label", next ? "Hide tool calls" : "Show tool calls"); chevron.textContent = next ? "\u25b4" : "\u25be"; if (next) positionChatToolPanel(panel, chip); }; chip.addEventListener("click", (event) => { event.stopPropagation(); setOpen(panel.hidden); }); close.addEventListener("click", () => setOpen(false)); if (open) { // The panel is built before its turn is attached to the document, so its // rect is not measurable yet; place it on the next frame, when it is. const place = () => positionChatToolPanel(panel, chip); if (typeof requestAnimationFrame === "function") requestAnimationFrame(place); else setTimeout(place, 0); } return wrap; } /** * Places the tool panel below its chip, or above it when there is no room, keeping * it inside the viewport margins — the browser's port of * `ToolPanelPositionProvider`. Resolved in px from the live rects, so it is * independent of any layout guess. */ function positionChatToolPanel(panel, chip) { const gap = 4; const margin = 8; const chipRect = chip.getBoundingClientRect(); const rect = panel.getBoundingClientRect(); let top = chipRect.bottom + gap; if (top + rect.height > window.innerHeight - margin) top = chipRect.top - rect.height - gap; top = Math.max(margin, Math.min(top, window.innerHeight - rect.height - margin)); const left = Math.max(margin, Math.min(chipRect.left, window.innerWidth - rect.width - margin)); panel.style.top = `${Math.round(top)}px`; panel.style.left = `${Math.round(left)}px`; } /** * One call inside the panel: a header naming the call, its `+N -M` stat for an * edit and its duration, and — expanded in place — the pretty-printed INPUT, the * synthesised edit diff, then the ERROR block for a failed call or the OUTPUT for * a settled one. Rows expand and collapse independently. Exported so the smoke can * render a representative row through this same builder. */ export function renderToolCallRow(part, { expanded = false, onToggle = null } = {}) { const row = toolCallRow(part); const node = h("div", { class: `chat-tool-row${row.error != null ? " chat-tool-row-failed" : ""}` }); const head = h("button", { class: "chat-tool-row-head", type: "button", "aria-expanded": String(expanded), }); head.append( h("span", { class: `chat-tool-icon${row.error != null ? " chat-tool-icon-failed" : ""}`, role: "img", "aria-label": row.error != null ? "Failed tool call" : "", "aria-hidden": row.error != null ? null : "true", text: row.error != null ? "\u26a0" : row.diff != null ? "\u270e" : "\u29c9", }), ); const titles = h("span", { class: "chat-tool-row-titles" }); titles.append(h("span", { class: "chat-tool-name", text: row.name })); if (row.detail != null) titles.append(h("span", { class: "chat-tool-detail", text: row.detail })); head.append(titles); if (row.diff != null) { head.append(h("span", { class: "chat-tool-stat", text: changeStat(row.diff.added, row.diff.removed) })); } if (row.duration != null) head.append(h("span", { class: "chat-tool-duration", text: row.duration })); head.append( h("span", { class: "chat-tool-row-chevron", role: "img", "aria-label": expanded ? `Collapse ${row.name}` : `Expand ${row.name}`, text: expanded ? "\u25b4" : "\u25be", }), ); node.append(head); if (expanded) { const body = h("div", { class: "chat-tool-body" }); const input = toolSection("INPUT", row.input); if (input) body.append(input); if (row.diff != null) body.append(renderToolDiff(row.diff)); if (row.error != null) { const error = toolSection("ERROR", row.error); if (error) body.append(error); } else { const output = toolSection("OUTPUT", row.output); if (output) body.append(output); } node.append(body); } if (typeof onToggle === "function") { head.addEventListener("click", () => onToggle()); } return node; } /** One monospace section card (INPUT/OUTPUT/ERROR); blank content renders none. */ function toolSection(label, text) { if (text == null || String(text).trim() === "") return null; const section = h("div", { class: "chat-tool-section" }); section.append(h("div", { class: "chat-tool-section-label", text: label })); section.append(h("pre", { class: "chat-tool-section-body", text })); return section; } /** * The unified diff body of an edit call: line-by-line monospace with `+`/`-` * gutter symbols and the app's success/failure hues, the shared line language of * the run Changes viewer. A diff longer than the rendered cap is summarised with * an omitted note. Exported so the smoke can render a representative sample. */ export function renderToolDiff(diff) { const card = h("div", { class: "chat-tool-diff" }); if (diff.omitted > 0) { card.append( h("div", { class: "chat-tool-diff-note", text: `\u2026 ${diff.omitted} more changed ${diff.omitted === 1 ? "line" : "lines"} not shown`, }), ); } for (const line of diff.lines) { card.append( h("div", { class: `chat-tool-diff-line ${diffLineClass(line.kind)}`, text: `${diffLineSymbol(line.kind)} ${line.text}`, }), ); } return card; } /** * Render assistant markdown by building DOM nodes, never by assigning innerHTML. * Exported so the live UI smoke can exercise the page's own renderer for the * fenced-code path the live transcript does not carry; the page itself calls it * directly. */ export function renderMarkdown(text) { const wrap = h("div", { class: "markdown" }); for (const block of parseMarkdown(text)) wrap.append(renderMarkdownBlock(block)); return wrap; } function renderMarkdownBlock(block) { if (block.kind === "heading") { const level = Math.min(Math.max(block.level, 1), 4) + 2; // h3..h6, never h1/h2 return h(`h${level}`, { class: "md-heading" }, ...renderInlineNodes(parseInline(block.text))); } if (block.kind === "paragraph") { return h("p", { class: "md-paragraph" }, ...renderInlineNodes(parseInline(block.text))); } if (block.kind === "code") { const code = h("div", { class: "md-code-block" }); code.append(h("div", { class: "md-code-label", text: codeBlockLabel(block.language) })); code.append(h("pre", { class: "md-pre" }, h("code", { text: block.code }))); return code; } if (block.kind === "rule") return h("hr", { class: "md-rule" }); if (block.kind === "quote") { const quote = h("blockquote", { class: "md-quote" }); for (const line of block.lines) { if (line.trim() !== "") quote.append(h("p", {}, ...renderInlineNodes(parseInline(line)))); } return quote; } if (block.kind === "list") { const list = h(block.ordered ? "ol" : "ul", { class: "md-list" }); for (const item of block.items) { list.append(h("li", {}, ...renderInlineNodes(parseInline(item)))); } return list; } if (block.kind === "table") { const table = h("table", { class: "md-table" }); const head = h("thead"); const headRow = h("tr"); for (const cell of block.header) headRow.append(h("th", {}, ...renderInlineNodes(parseInline(cell)))); head.append(headRow); table.append(head); const body = h("tbody"); for (const row of block.rows) { const tr = h("tr"); for (const cell of row) tr.append(h("td", {}, ...renderInlineNodes(parseInline(cell)))); body.append(tr); } table.append(body); return table; } // Anything outside the subset stays plain text and is never dropped. return h("p", { class: "md-paragraph", text: block.text ?? "" }); } function renderInlineNodes(spans) { return (spans ?? []).map((span) => { if (span.kind === "code") return h("code", { class: "md-code", text: span.text }); if (span.kind === "strong") return h("strong", {}, ...renderInlineNodes(span.spans)); if (span.kind === "emphasis") return h("em", {}, ...renderInlineNodes(span.spans)); if (span.kind === "link") { // Only http(s) targets become links: the transcript is untrusted model // output, so a javascript:/data: target is shown as its label, never made // clickable. Nothing is dropped either way. if (/^https?:\/\//i.test(span.url)) { return h( "a", { class: "md-link", href: span.url, rel: "noreferrer noopener", target: "_blank" }, ...renderInlineNodes(span.spans), ); } return h("span", { class: "md-link-plain" }, ...renderInlineNodes(span.spans)); } return document.createTextNode(String(span.text ?? "")); }); } /** One local command line in the transcript (see ChatCommandNoticeItem). */ function renderChatCommandNotice(sessionId, notice) { const failed = notice?.failed === true; const row = h("div", { class: `chat-command-notice${failed ? " chat-command-notice-failed" : ""}`, role: "note", "data-notice-id": notice?.id ?? "", }); const head = h("div", { class: "chat-command-notice-head" }); head.append( h("span", { class: "chat-command-notice-glyph", "aria-hidden": "true", // The app draws `Icons.Default.Terminal` for both states and only changes // the tint, so both notices share the one terminal glyph. text: CHAT_COMMAND_GLYPH, }), ); head.append( h("span", { class: "chat-command-notice-label", text: chatNoticeLabel(failed) }), ); row.append(head); row.append(h("div", { class: "chat-command-notice-text", text: notice?.text ?? "" })); if (notice?.offer != null) { const actions = h("div", { class: "chat-command-notice-actions" }); actions.append( h("button", { class: "ghost chat-command-send-as-message", type: "button", text: "Send as message", onclick: () => sendChatCommandOffer(sessionId, notice.id), }), ); actions.append( h("button", { class: "ghost chat-command-cancel", type: "button", text: "Cancel", onclick: () => dismissChatNotice(sessionId, notice.id), }), ); row.append(actions); } else { // Android only offers the Send/Cancel pair on an offer-bearing notice, so a // `/help` or `/new` line cannot be dismissed there. The browser item requires // each notice to be individually dismissible; the wording and the offer pair // still match the app verbatim, and this extra control is stated in PARITY. const actions = h("div", { class: "chat-command-notice-actions" }); actions.append( h("button", { class: "ghost chat-command-dismiss", type: "button", text: "Dismiss", "aria-label": CHAT_COMMAND_DISMISS_LABEL, onclick: () => dismissChatNotice(sessionId, notice.id), }), ); row.append(actions); } return row; } /** * The composer at the foot of an open conversation: the queued notice, the * attachment chips, the slash-command offer list, the attach control, the growing * multiline field and the single send/stop control. All state is derived from the * thread and its session; every server/model string is set with textContent. */ function renderChatComposer(thread, session, sessionId) { const composer = h("div", { class: "chat-composer", id: "chatComposer" }); if (!thread) return composer; const controls = { selected: 0, palette: null, primary: null }; if (thread.queued) { composer.append(h("div", { class: "chat-queued", id: "chatQueued", text: CHAT_QUEUED_NOTICE })); } const strip = renderChatAttachmentStrip(sessionId, thread); if (strip) composer.append(strip); const palette = h("div", { class: "chat-command-palette", id: "chatPalette", role: "listbox", "aria-label": "Command suggestions", hidden: true, }); controls.palette = palette; composer.append(palette); const row = h("div", { class: "chat-composer-row" }); const fileInput = h("input", { id: "chatFileInput", class: "chat-file-input", type: "file", multiple: true, tabindex: "-1", "aria-hidden": "true", onchange: (event) => { onChatFilesPicked(sessionId, session, event.target.files); event.target.value = ""; }, }); row.append( h( "button", { class: "ghost chat-attach", id: "chatAttach", type: "button", "aria-label": CHAT_ATTACH_LABEL, title: CHAT_ATTACH_LABEL, onclick: () => fileInput.click(), }, "\u{1F4CE}", ), ); row.append(fileInput); const input = h("textarea", { id: "chatInput", class: "chat-composer-input", rows: "1", placeholder: CHAT_COMPOSER_PLACEHOLDER, "aria-label": CHAT_COMPOSER_PLACEHOLDER, spellcheck: "false", }); input.value = thread.draft ?? ""; input.addEventListener("input", (event) => onComposerInput(event, sessionId, session, controls)); input.addEventListener("keydown", (event) => onComposerKeydown(event, sessionId, session, controls)); row.append(input); const primary = h("span", { class: "chat-composer-primary" }); controls.primary = primary; row.append(primary); composer.append(row); const suggestions = chatCommandSuggestions(thread.draft); fillCommandPalette(palette, suggestions, controls.selected, (index) => { const command = suggestions[index]; if (command) runChatCommand(sessionId, session, `/${command.name}`); }); fillComposerPrimary(primary, thread, { onSend: () => submitChatComposer(sessionId, session, controls), onStop: () => stopChatTurn(sessionId), }); if (typeof requestAnimationFrame === "function") { requestAnimationFrame(() => growComposerTextarea(input)); } return composer; } /** The offer list above the composer: `/name` and the summary per row. */ function fillCommandPalette(palette, suggestions, selected, onPick) { if (!palette) return; palette.replaceChildren(); if (!suggestions || suggestions.length === 0) { palette.hidden = true; return; } palette.hidden = false; suggestions.forEach((command, index) => { palette.append( h( "div", { class: `chat-command-row${index === selected ? " selected" : ""}`, role: "option", "aria-selected": index === selected ? "true" : "false", tabindex: "-1", onclick: () => onPick(index), }, h("span", { class: "chat-command-name", text: `/${command.name}` }), h("span", { class: "chat-command-summary", text: command.summary }), ), ); }); } /** * The composer's single primary control: Stop while a turn is in flight (error * tint), else Send, disabled unless the draft is sendable (or a slash draft). * Stop routes to [onStop] (`chat_interrupt`), never to the submit path — the * control must interrupt the running turn, as Android's `onStop` does. */ function fillComposerPrimary(primary, thread, { onSend, onStop } = {}) { if (!primary) return; primary.replaceChildren(); if (composerAction(thread) === COMPOSER_STOP) { primary.append( h( "button", { class: "chat-stop", id: "chatStop", type: "button", "aria-label": CHAT_STOP_LABEL, title: CHAT_STOP_LABEL, onclick: onStop, }, "■", ), ); return; } primary.append( h( "button", { class: "chat-send", id: "chatSend", type: "button", "aria-label": CHAT_SEND_LABEL, title: CHAT_SEND_LABEL, disabled: !composerSendEnabled(thread), onclick: onSend, }, "➤", ), ); } /** The removable chips for the files attached to the next message. */ function renderChatAttachmentStrip(sessionId, thread) { const attachments = thread?.attachments ?? []; if (attachments.length === 0) return null; const strip = h("div", { class: "chat-attachment-strip", id: "chatAttachments" }); for (const attachment of attachments) { strip.append(renderChatAttachmentChip(sessionId, attachment)); } return strip; } /** One attachment chip: its preview, its name, its size or error, and remove. */ function renderChatAttachmentChip(sessionId, attachment) { const failed = attachment?.error != null; const display = attachmentDisplayName(attachment?.name, attachment?.uri); const chip = h("div", { class: `chat-attachment-chip${failed ? " chat-attachment-chip-failed" : ""}`, }); chip.append(renderAttachmentThumb(attachment, display)); const body = h("div", { class: "chat-attachment-body" }); body.append(h("span", { class: "chat-attachment-name", text: display })); if (failed) { body.append(h("span", { class: "chat-attachment-meta chat-attachment-error", text: attachment.error })); } else if (Number(attachment?.size) > 0) { body.append(h("span", { class: "chat-attachment-meta", text: humanBytes(attachment.size) })); } chip.append(body); chip.append( h( "button", { class: "ghost chat-attachment-remove", type: "button", "aria-label": `Remove ${display}`, title: `Remove ${display}`, onclick: () => removeChatAttachment(sessionId, attachment.id), }, "✕", ), ); return chip; } /** The chip's square preview: the decoded thumbnail for an image, else a glyph. */ function renderAttachmentThumb(attachment, display) { if (attachment?.thumbUrl) { return h("img", { class: "chat-attachment-thumb", src: attachment.thumbUrl, alt: display, "aria-hidden": "true", }); } const image = String(attachment?.mime ?? "").startsWith("image/"); return h("span", { class: "chat-attachment-glyph", "aria-hidden": "true", text: image ? "🖼" : "📄", }); } /** The Close chat? confirm: the exact Android body naming the session title. */ function renderChatCloseDialog(session) { const overlay = h("div", { class: "confirm-dialog confirm-chat-close", role: "dialog", "aria-modal": "true", "aria-label": CLOSE_CHAT_TITLE, }); overlay.addEventListener("click", (event) => { if (event.target === overlay) dismissChatClose(); }); const panel = h("div", { class: "confirm-panel" }); panel.append(h("h2", { class: "confirm-title", text: CLOSE_CHAT_TITLE })); panel.append( h("p", { class: "confirm-message", text: closeChatConfirmation(sessionTitle(session)) }), ); const actions = h("div", { class: "confirm-actions" }); actions.append( h("button", { class: "ghost confirm-dismiss", type: "button", text: CLOSE_CHAT_DISMISS, onclick: dismissChatClose, }), ); actions.append( h("button", { class: "confirm-accept confirm-close-chat", type: "button", text: CLOSE_CHAT_CONFIRM, onclick: () => acceptChatClose(session), }), ); panel.append(actions); overlay.append(panel); return overlay; } /** * Wire the freshly rendered transcript: restore the operator's saved position * (or open at the newest message when they have none), preserve the visual * position across a prepended older page, follow new content while following, * and offer "Jump to latest" only when not following and something is below the * fold. Only the operator's own wheel/drag changes that intent; nothing here ever * auto-loads older history on scroll. */ function afterChatRender() { const el = document.getElementById("chatTranscript"); if (!el) { state.chatPending = null; return; } const sessionId = el.dataset.session; const itemCount = el.children.length; const thread = state.chatThreads.get(sessionId) ?? null; // The position captured from the previous render (if it was this session), and // the paging anchor (if an older page is being fetched). Both are consumed once. const pending = state.chatPending?.sessionId === sessionId ? state.chatPending : null; state.chatPending = null; const anchor = state.chatAnchor?.sessionId === sessionId ? state.chatAnchor : null; // A re-render is not the operator's gesture: the intent flag is re-armed only // by a wheel/drag on the transcript below. state.chatUserIntent = false; if (anchor && thread?.loading !== true) { // The render that actually carries the prepended older page: keep the same // message at the same place by the height the page added. The loading frame // itself is skipped, so the anchor survives until the content arrives. const delta = el.scrollHeight - anchor.scrollHeight; el.scrollTop = anchor.scrollTop + Math.max(0, delta); state.chatAnchor = null; state.chatFollowing = chatFollowsAt(transcriptDistance(el), CHAT_FOLLOW_THRESHOLD_PX, itemCount); } else if (state.chatPlaced === sessionId) { // A re-render of a conversation already placed (a dialog, a refresh, the // loading frame of a paging fetch): put the operator back exactly where they // were, so nothing they did not do moves their view. const restore = pending ? pending.position : state.chatScroll[sessionId] ?? null; const follow = pending ? pending.following : state.chatFollowing; if (follow || restore == null) { el.scrollTop = el.scrollHeight; state.chatFollowing = true; } else { const first = chatFirstScroll(restore, itemCount); const row = el.children[first.index]; el.scrollTop = row ? row.offsetTop + first.offset : el.scrollHeight; state.chatFollowing = chatFollowsAt(transcriptDistance(el), CHAT_FOLLOW_THRESHOLD_PX, itemCount); } } else { const saved = state.chatScroll[sessionId] ?? null; if (chatOpensAtNewest(saved)) { // No position of the operator's own: land on the newest content instantly — // the end of the transcript, so a last turn taller than the viewport opens // at its newest part rather than its first — and follow. el.scrollTop = el.scrollHeight; state.chatFollowing = true; } else { const first = chatFirstScroll(saved, itemCount); const row = el.children[first.index]; el.scrollTop = row ? row.offsetTop + first.offset : el.scrollHeight; state.chatFollowing = chatFollowsAt(transcriptDistance(el), CHAT_FOLLOW_THRESHOLD_PX, itemCount); } state.chatPlaced = sessionId; } // Only a scroll that happens during the operator's own gesture (a wheel, or a // pointer/touch press that is still down) is theirs; a programmatic placement, // follow or anchor restore never changes the intent. A plain click that never // scrolls therefore leaves the intent alone. let gesture = false; const beginGesture = () => { gesture = true; }; const endGesture = () => { gesture = false; }; el.addEventListener("wheel", () => { state.chatUserIntent = true; state.chatFollowing = false; updateChatJump(el); }); el.addEventListener("pointerdown", beginGesture); el.addEventListener("pointerup", endGesture); el.addEventListener("pointercancel", endGesture); el.addEventListener("touchstart", beginGesture, { passive: true }); el.addEventListener("touchend", endGesture); el.addEventListener("touchcancel", endGesture); el.addEventListener("scroll", () => { if (state.chatUserIntent || gesture) { state.chatUserIntent = true; state.chatFollowing = chatFollowsAt( transcriptDistance(el), CHAT_FOLLOW_THRESHOLD_PX, el.children.length, ); } updateChatJump(el); clearTimeout(state.chatScrollTimer); state.chatScrollTimer = setTimeout(() => { if (state.chatActiveId) saveChatScroll(state.chatActiveId, currentChatPosition(el)); }, 200); }); updateChatJump(el); } /** Offer "Jump to latest" only when not following and something is below the fold. */ function updateChatJump(el) { const jump = document.getElementById("chatJump"); if (!jump) return; const count = el ? el.children.length : 0; jump.hidden = !chatShowJumpToLatest( state.chatFollowing, transcriptDistance(el), CHAT_FOLLOW_THRESHOLD_PX, count, ); } // --------------------------------------------------------------------------- // Omni-search (S1/S2) // --------------------------------------------------------------------------- /** Open the search field and ask for focus; the current view is left alone. */ function openSearch() { if (state.searchOpen) return; state.searchOpen = true; state.searchError = ""; state.searchFocusPending = true; renderHeader(); renderSearch(); } /** * Close and clear the search: the pending debounce is dropped, an in-flight reply * is invalidated by recording a fresh edit, and the query, results, error and * loading flag are reset. The view, the selection and the loaded data are * deliberately untouched, so closing restores exactly the state that was on * screen before the search opened. */ function closeSearch() { cancelSearchDebounce(); // Recording an empty edit advances the sequencer, so a reply for a request // still in flight can no longer be accepted. state.searchSequencer.edit(""); state.searchOpen = false; state.searchQuery = ""; state.searchResults = []; state.searchLoading = false; state.searchError = ""; state.searchLoaded = false; state.searchFocusPending = false; renderHeader(); renderSearch(); } function cancelSearchDebounce() { if (searchTimer) { clearTimeout(searchTimer); searchTimer = null; } searchEdit = null; } /** * A keystroke. A blank/whitespace query clears the results locally and sends * nothing; otherwise the previous results stay visible, the request is marked in * flight and the send is debounced `SEARCH_DEBOUNCE_MS` from the last keystroke. * Recording the edit is itself enough to drop any older reply still in flight. */ function onSearchInput(value) { state.searchQuery = value; state.searchError = ""; cancelSearchDebounce(); if (!searchQuerySendable(value)) { state.searchSequencer.edit(""); state.searchResults = []; state.searchLoading = false; state.searchLoaded = false; refreshSearch(); return; } state.searchLoading = true; searchEdit = state.searchSequencer.edit(value); refreshSearch(); searchTimer = setTimeout(() => { searchTimer = null; const sent = state.searchSequencer.begin(searchEdit); if (sent) runSearch(sent); }, SEARCH_DEBOUNCE_MS); } /** Send the current query at once (Enter, or a kind change), skipping the debounce. */ function sendSearchNow() { const query = state.searchQuery; cancelSearchDebounce(); if (!searchQuerySendable(query)) { state.searchSequencer.edit(""); state.searchResults = []; state.searchLoading = false; state.searchError = ""; state.searchLoaded = false; refreshSearch(); return; } const sent = state.searchSequencer.begin(state.searchSequencer.edit(query)); if (sent) runSearch(sent); } /** * A kind-filter change: the in-hand filter is re-applied immediately so the list * always matches the control, and — when the query is non-blank — a fresh server * request is sent with the new kind. A sort change never sends a request. */ function setSearchKind(kind) { state.searchKind = kind; refreshSearch(); if (searchQuerySendable(state.searchQuery)) sendSearchNow(); } function setSearchSort(sort) { state.searchSort = sort; refreshSearch(); } /** * Run one query and apply the reply only if it is still the newest edit. A reply * without a `search_results` payload (an older server's pong) or a rejection * naming an unknown command reports the app's "cannot search" sentence; any other * failure carries the server's own text. A stale reply is dropped entirely. */ async function runSearch(sent) { try { const reply = await repo.search(sent.query, state.searchKind); if (!state.searchSequencer.accepts(sent.token)) return; if (reply == null) { state.searchLoading = false; state.searchLoaded = true; state.searchError = searchFailureText(null); refreshSearch(); return; } state.searchResults = Array.isArray(reply.results) ? reply.results : []; state.searchLoading = false; state.searchError = ""; state.searchLoaded = true; refreshSearch(); } catch (error) { if (!state.searchSequencer.accepts(sent.token)) return; state.searchLoading = false; state.searchLoaded = true; state.searchError = searchFailureText(error); refreshSearch(); } } /** * Re-render the search panel's controls and results in place. Only the results * area, the summary and the select values are touched, so a keystroke never * rebuilds (and so never blurs) the query field. */ function refreshSearch() { const kindSelect = document.getElementById("searchKind"); if (kindSelect) kindSelect.value = state.searchKind; const sortSelect = document.getElementById("searchSort"); if (sortSelect) sortSelect.value = state.searchSort; const summary = document.getElementById("searchSummary"); if (summary) summary.textContent = searchControlsSummary(state.searchKind, state.searchSort); const area = document.getElementById("searchResults"); if (area) fillSearchResults(area); } /** * The full-width search panel: the controls row (kind select, sort select, the * one-line summary and the Clear filter reset) and a bounded scrolling result * area. Rendered only while the search is open; the panel is one flat list, with * no per-kind grouping headers, matching the app. */ function renderSearch() { if (!state.searchOpen) { searchHost.replaceChildren(); return; } const kindSelect = h( "select", { id: "searchKind", class: "search-select", "aria-label": "Filter results", onchange: (event) => setSearchKind(event.target.value), }, ...SEARCH_KINDS.map((option) => h("option", { value: option.value, text: option.label })), ); kindSelect.value = state.searchKind; const sortSelect = h( "select", { id: "searchSort", class: "search-select", "aria-label": "Sort results in hand", onchange: (event) => setSearchSort(event.target.value), }, ...SEARCH_SORTS.map((option) => h("option", { value: option.value, text: option.label })), ); sortSelect.value = state.searchSort; const controls = h( "div", { class: "search-controls" }, h("label", { class: "search-field" }, h("span", { class: "search-field-label", text: "Kind" }), kindSelect), h("label", { class: "search-field" }, h("span", { class: "search-field-label", text: "Sort" }), sortSelect), h("span", { id: "searchSummary", class: "search-summary muted", text: searchControlsSummary(state.searchKind, state.searchSort), }), h("button", { id: "searchClearFilter", class: "ghost search-clear", type: "button", text: "Clear filter", onclick: () => setSearchKind(DEFAULT_SEARCH_KIND), }), ); const area = h("div", { id: "searchResults", class: "search-results", "aria-live": "polite" }); fillSearchResults(area); searchHost.replaceChildren(h("div", { id: "searchPanel", class: "search-panel" }, controls, area)); } /** * Fill the results area from the current state. A first load with nothing yet * shows the spinner and `Searching…`; a refresh that retained results shows a thin * progress bar above them; an error takes precedence over the results; otherwise * the filtered and sorted rows, or the empty-state line. */ function fillSearchResults(area) { const shown = sortSearchResults( filterSearchResults(state.searchResults, state.searchKind), state.searchSort, ); const nodes = []; if (searchPanelProgress(state)) { nodes.push(h("div", { class: "search-progress", role: "progressbar", "aria-label": "Searching" })); } const body = searchPanelBody(state, shown, state.searchKind); if (body.kind === "error") { nodes.push(h("div", { class: "search-error", text: body.message })); } else if (body.kind === "results") { for (const hit of shown) nodes.push(renderSearchResultRow(hit)); } else if (body.kind === "searching") { nodes.push( h( "div", { class: "search-searching muted" }, h("span", { class: "spinner", "aria-hidden": "true" }), h("span", { text: "Searching…" }), ), ); } else if (body.kind === "empty") { nodes.push(h("div", { class: "search-empty muted", text: body.message })); } area.replaceChildren(...nodes); } /** * One result row: a compact kind label (the accessibility counterpart of the * app's type glyph), the title and — for a text match — the server snippet with * the first case-insensitive query occurrence emphasised. A known payload is * clickable and routes to its destination; an unknown/absent payload is rendered * read-only and is never clickable. Every server string is set as text. */ function renderSearchResultRow(hit) { const row = searchRow(hit, state.searchQuery); const target = searchTarget(hit); const element = h("div", { class: `search-row${target ? " clickable" : " readonly"}`, "data-kind": String(hit?.kind ?? ""), }); if (target) { const route = () => routeSearchResult(hit); element.setAttribute("role", "button"); element.setAttribute("tabindex", "0"); if (target.kind === "pipeline") { element.setAttribute("data-target", `pipeline:${target.pipelineId}:v${target.version}`); } else if (target.matchedField) { element.setAttribute("data-target", `run:${target.runId}:${target.sequence}:${target.matchedField}`); } else { element.setAttribute("data-target", `run:${target.runId}${target.sequence ? `:${target.sequence}` : ""}`); } element.addEventListener("click", route); element.addEventListener("keydown", (event) => { if (event.key === "Enter" || event.key === " ") { event.preventDefault(); route(); } }); } element.append(h("span", { class: "search-kind muted", text: searchResultKindLabel(hit) })); const main = h("div", { class: "search-row-main" }); main.append(h("div", { class: "search-row-title", text: row.title })); if (row.snippet != null) { const line = h("div", { class: "search-row-snippet muted" }); for (const span of row.snippet) { if (span.matched) { line.append(h("strong", { class: "search-match" }, h("u", {}, span.text))); } else { line.append(document.createTextNode(span.text)); } } main.append(line); } else if (row.secondary) { main.append(h("div", { class: "search-row-secondary muted", text: row.secondary })); } element.append(main); return element; } /** * Route one selected result through the page's existing navigation, exactly as * the app does. The search is closed and cleared first, so every selection leaves * the panel; a known payload then opens the pipeline detail (at the result * version, 0 = latest), the run detail, the run-detail tab holding a text match, * or the recorded visit's stage pane (the artifact route is that same pane). A * visit that cannot be located falls back to the plain run detail. An unknown * result has no target and never navigates. */ async function routeSearchResult(hit) { const target = searchTarget(hit); if (!target) return; closeSearch(); state.error = ""; if (target.kind === "pipeline") { state.view = "pipelines"; state.selectedRunId = null; await selectPipeline({ id: target.pipelineId, version: target.version }); return; } state.view = "runs"; await selectRun(target.runId); if (!state.runDetail) return; const resolved = resolveRunTarget(target, target.runId, state.runDetail.steps ?? []); if (resolved.tab) { state.runTab = resolved.tab; renderContent(); } else if (resolved.stageKey != null) { openStagePane(resolved.stageKey, resolved.visitIndex); } } // --------------------------------------------------------------------------- // Actions // --------------------------------------------------------------------------- function setError(err) { state.error = err instanceof Error ? err.message : String(err); state.loading = false; renderContent(); } /** * Validate the URL field, remember it and open the socket. Shared by Connect, * the manual Reconnect control and the foreground recovery so all three take the * same validate → persist → repo.connect path. `repo.connect` resets the * attempt/backoff inside client.js, cancelling a pending retry delay. * * An invalid draft is reported as the Settings field's own error (Android's * `urlError`) and cleared on the next edit; it is never left as a page-level * banner. `surfaceError` is false for the background (foreground-recovery) * caller so a stale, invalid URL field cannot spray an error into the UI on every * visibilitychange/online event. */ function openConfiguredEndpoint({ surfaceError = true } = {}) { const validated = validateServerUrl(state.url); if (!validated.valid) { if (surfaceError) { state.urlError = validated.message; // On another view the field is not rendered, so the page-level error is the // only way to say why nothing happened; on Settings it belongs under the // field. if (state.view === "settings") { refreshServerUrlError(); } else { state.error = validated.message; renderContent(); } } return; } state.error = ""; state.urlError = ""; writeServerUrl(localStorage, state.url); repo.connect(validated); } function onConnectClicked() { if (state.connection.kind === "connected") { repo.disconnect(); stopRunPoll(); return; } openConfiguredEndpoint(); // The `state` listener kicks off the initial load once connected. } /** * The manual reconnect control (T3): re-open the same validated endpoint now. * `repo.connect` (client.connect) resets the attempt/backoff, so a pending * retry delay is cancelled and the socket is reopened immediately. */ function onReconnectClicked() { openConfiguredEndpoint(); } /** * Return-to-foreground recovery (T4), the page's counterpart of * ForegroundReconnector: called when the tab becomes visible again or the * browser comes back online. Idle is the client's own deliberate-disconnect * state and is left alone; Connecting and Disconnected are driven back to the * socket at once, cancelling the pending backoff inside client.connect. A * Connected socket is trusted because the browser's own online/visibility event * is the liveness signal available to the page (it has no in-page positive ping * probe like ForegroundReconnector.confirm()); that deviation is recorded in * web/PARITY.md. Idempotent: repeated events just re-open the same endpoint. */ function onForegroundActive() { if (foregroundAction(state.connection, true) !== ForegroundAction.Reconnect) return; openConfiguredEndpoint({ surfaceError: false }); } async function onConnected() { let reply; try { reply = await repo.ping(); } catch (err) { setError(err); return; } // Remember the server's build/protocol so the banner can name a stale server // and warn about a protocol mismatch (T5); the ping is the only source. state.serverProtocol = reply?.protocol ?? null; state.serverBuild = reply?.build ?? null; // The pong carries the server's own time (internal/protocol/message.go `Time`), // shown in the Settings connection card. state.serverTime = reply?.time ?? null; // Update the banner at once; the content render that shows the build/time in // the Settings card is the one `loadCurrentView` already performs (Settings is // local, so that path is a single render and nothing is fetched twice). renderBanner(); // A URL opened before the socket was up is the pending destination: the first // successful connection loads its list and then its detail/stage. Later // reconnects keep the ordinary current-view refresh and never replay a link. if (!state.routeFirstConnect) { state.routeFirstConnect = true; const route = state.pendingRoute ?? state.route ?? DEFAULT_ROUTE; state.pendingRoute = null; await applyRoute(route); return; } await loadCurrentView(); // Seed from the authoritative list first, then watch: the subscribe snapshot // and its ack are treated as seeds, so a reconnect gap never notifies. await startRunAlertWatch(); // A reconnect after a network drop must also re-hydrate an open detail: the // route (and its URL) can survive a drop, but a detail that was never loaded — // or was cleared while disconnected — has to be fetched again, otherwise the // URL and the rendered view disagree. Only the URL-bearing detail routes do // this; the list destinations were just refreshed above. const route = state.route; if ( route && (route.kind === "run" || route.kind === "runStage" || route.kind === "pipeline" || route.kind === "pipelineStage") ) { await applyRoute(route); } } // --------------------------------------------------------------------------- // URL routes (L6) // --------------------------------------------------------------------------- /** The view a route renders in: details belong to their list's destination. */ function viewForRoute(route) { switch (route?.kind) { case "pipeline": case "pipelineStage": return "pipelines"; case "run": case "runStage": return "runs"; case "template": return "templates"; case "runs": case "chat": case "settings": case "templates": return route.kind; default: return "pipelines"; } } /** Record a user move in history. Only a real URL change pushes an entry. */ function pushRoute(route) { const url = serializeRoute(route); const current = `${location.pathname}${location.search}`; if (url !== current) { try { history.pushState(null, "", url); } catch { // A non-HTTP location (file://) may refuse history; local state still moves. } } state.route = route; // Only an untouched boot deep link is replayed after connecting. A move the // operator made while still disconnected (a tab, a selection, Back/Forward) is // now the destination the URL shows, so the stale boot link must not win. state.pendingRoute = null; } /** Correct the current entry in place (a missing entity, a consumed action). */ function replaceRoute(route) { const url = serializeRoute(route); const current = `${location.pathname}${location.search}`; if (url !== current) { try { history.replaceState(null, "", url); } catch { // See pushRoute. } } state.route = route; state.pendingRoute = null; } /** * Apply a route to the local view and, when connected, load exactly what it * needs: the destination list first on a boot deep link, then the requested * detail/stage. Same-id data already in hand is not refetched, so Back from a * stage route only closes the pane. Total: every failure ends in an honest list * fallback rather than a throw. */ async function applyRoute(route) { const r = route && typeof route === "object" ? route : { ...DEFAULT_ROUTE }; state.routeApplying = true; const connected = () => state.connection.kind === "connected"; try { state.route = r; // Applying a route is itself a navigation decision (popstate, a push, or the // boot link): the pending boot link is never allowed to override it later. state.pendingRoute = null; state.error = ""; state.loading = false; state.view = viewForRoute(r); // A run detail's poll belongs to the Runs view only. Moving to any other // destination stops it, including a destination that keeps the selection id. if (state.view !== "runs") stopRunPoll(); if (r.kind === "pipelines") { // A default destination reached from an unknown or malformed path (a boot // deep link or a Back entry) corrects the address bar so the URL and the // rendered list agree; on the canonical /pipelines this is a no-op. if (`${location.pathname}${location.search}` !== "/pipelines") { replaceRoute({ kind: "pipelines" }); } state.selectedPipelineId = null; resetPipelineDetailState(); renderContent(); // Mirror the old tab handler: an unfetched destination while disconnected // still says `Connect to the server first.` rather than showing a silent // empty list. Once connected this is the list load the route needs. if (!state.pipelines.length) await loadCurrentView(); return; } if (r.kind === "runs") { state.selectedRunId = null; state.runDetail = null; state.runStagePane = null; state.runStageSections = new Set(); state.decisionOpen = false; state.runDecision = null; stopRunPoll(); renderContent(); if (!state.runs.length) await loadCurrentView(); return; } if (r.kind === "pipeline" || r.kind === "pipelineStage") { const version = Number.isSafeInteger(r.version) ? r.version : 0; const same = state.selectedPipelineId === r.id && state.pipelineDetail != null && state.pipelineRequestedVersion === version; state.view = "pipelines"; if (same) { if (r.kind === "pipelineStage") { if (!pipelineHasStage(state.pipelineDetail, r.stageKey)) { state.pipelineGraphSelection = null; state.pipelineTab = "graph"; replaceRoute({ kind: "pipeline", id: r.id, version }); renderContent(); return; } state.pipelineTab = "graph"; state.pipelineGraphSelection = r.stageKey; } else { // The detail route itself does not name a section; keep the tab and // only close the stage pane. state.pipelineGraphSelection = null; } renderContent(); return; } state.selectedPipelineId = r.id; state.pipelineRequestedVersion = version; state.pipelineDetail = null; state.pipelineTab = r.kind === "pipelineStage" ? "graph" : "summary"; state.pipelineGraphSelection = r.kind === "pipelineStage" ? r.stageKey : null; renderContent(); if (!connected()) return; if (!state.pipelinesLoaded) await loadCurrentView(); await selectPipeline({ id: r.id, version }, { updateRoute: false }); if (r.kind === "pipelineStage" && state.view === "pipelines" && state.pipelineDetail) { if (!pipelineHasStage(state.pipelineDetail, r.stageKey)) { // A path naming a stage the loaded graph does not declare is accepted by // the (data-blind) parser but cannot open a pane: mirror the missing-entity // fallbacks and replace the URL with the pipeline itself. state.pipelineGraphSelection = null; state.pipelineTab = "graph"; replaceRoute({ kind: "pipeline", id: r.id, version }); renderContent(); return; } state.pipelineTab = "graph"; state.pipelineGraphSelection = r.stageKey; renderContent(); } return; } if (r.kind === "run" || r.kind === "runStage") { state.view = "runs"; const same = state.selectedRunId === r.id && state.runDetail != null; if (!same) { state.selectedRunId = r.id; resetRunDetailState(); renderContent(); if (!connected()) return; if (!state.runsLoaded) await loadCurrentView(); await selectRun(r.id, { updateRoute: false }); } if (!connected() || !state.runDetail || state.runDetail.id !== r.id) return; if (r.kind === "runStage") { // No ?visit means the stage's most recent visit, exactly as the graph's // own node click opens it; the URL stays without a visit. A valid but // out-of-range index is clamped to the stage's last visit and the entry // corrected, so the address bar and the pane agree (renderStagePane // already clamps, which is why the two must not diverge). const visits = runTimeline(state.runDetail.steps ?? []).visitsByStage.get(r.stageKey) ?? []; // A key that is neither visited nor a node of the loaded run graph cannot // open a pane. Mirror the pipeline-stage fallback: show the run itself and // correct the URL rather than leaving an empty pane under a stage path. if (!visits.length && !layoutGraph(state.runDetail.graph).nodes.some((node) => node.key === r.stageKey)) { state.runStagePane = null; state.runStageSections = new Set(); replaceRoute({ kind: "run", id: r.id }); renderContent(); return; } const wanted = r.visit == null ? Math.max(0, visits.length - 1) : r.visit; const visit = clampVisitIndex(wanted, visits.length); state.runStagePane = { stageKey: r.stageKey, visitIndex: visit }; state.runStageSections = new Set(); renderContent(); if (r.visit != null && visit !== r.visit) { replaceRoute({ kind: "runStage", id: r.id, stageKey: r.stageKey, visit }); } } else { if (state.runStagePane) { state.runStagePane = null; state.runStageSections = new Set(); renderContent(); } consumeRunAction(r); } return; } if (r.kind === "templates") { // Entering the gallery leaves any template detail (and a create dialog // opened for it) behind, exactly as the Settings card did before routing. resetTemplateSelection(); renderContent(); if (!state.templates.length) await loadCurrentView(); return; } if (r.kind === "template") { // A route that names a different template reseeds the detail: a create // dialog and its typed name belong to the template they were opened on. // A same-route re-apply keeps them, so a push or replace is not a reset. if (state.selectedTemplateKey !== r.key) resetTemplateCreateState(); state.selectedTemplateKey = r.key; renderContent(); if (!state.templates.length) await loadCurrentView(); return; } if (r.kind === "chat") { renderContent(); if (!state.chatLoaded) await loadCurrentView(); return; } // Settings is local; the fallback covers any route kind a caller invents. state.view = "settings"; state.error = ""; renderContent(); } finally { state.routeApplying = false; // A Back/Forward that arrived while a load was in flight still wins: apply // the location the browser actually shows now, once this pass is done. if (state.popPending) { state.popPending = false; applyRoute(parseRoute(location.pathname, location.search)); } } } /** * A run URL's one-shot `?action=decide` (the notification analogue): after the * run loads, open the existing decision sheet only when the run is genuinely * waiting, then replace the entry with the action-free /runs/:id so a refresh * does not reopen it. Never invents a decision. */ function consumeRunAction(route) { if (!route?.action) return; const action = route.action; replaceRoute({ kind: "run", id: route.id }); if (action !== "decide") return; const decision = pendingDecision(state.runDetail); if (decision) openDecisionSheet(decision); } async function loadCurrentView(force = false) { // Settings is local: it has no server-backed list to (re)load, so switching to // or refreshing it must never raise the "connect first" error. if (state.view === "settings") { renderContent(); return; } if (state.connection.kind !== "connected") { state.error = "Connect to the server first."; renderContent(); return; } if (state.view === "templates") { await loadTemplates(force); return; } if (state.view === "chat") { await loadChatSessions(force); return; } state.loading = true; state.error = ""; renderContent(); try { if (state.view === "pipelines") { state.pipelines = await repo.listPipelines(); state.pipelinesLoaded = true; // The last-run line joins list_runs onto the pipelines, so the history is // fetched alongside them; runsLoaded distinguishes a genuinely empty // history from one that has not arrived yet. const { runs, usage } = await repo.listRuns(); state.runs = runs; runAlerts.seed(runs); if (usage) state.usage = usage; state.runsLoaded = true; } else { const { runs, usage } = await repo.listRuns(); state.runs = runs; runAlerts.seed(runs); state.usage = usage; state.runsLoaded = true; // The nav badge reads `Pipelines (${state.pipelines.length})`, so the Runs // destination (and a run deep link) loads the pipeline list too when it has // not been seen: an empty `state.pipelines` would show a false `Pipelines (0)` // until the Pipelines tab was visited. if (!state.pipelinesLoaded) { state.pipelines = await repo.listPipelines(); state.pipelinesLoaded = true; } } state.loading = false; renderContent(); // The run list the attention surface derives from has just (re)loaded, so // bring the bell's badge up to date. refreshAttentionBell(); // Keep the current selection fresh after a refresh. if (force && state.view === "runs" && state.selectedRunId) { await selectRun(state.selectedRunId, { silent: true }); } } catch (err) { setError(err); } } /** * Loads the template catalogue, then validates each template's source once and * caches the parsed graph (null when it did not parse) so a card's stage count * and the detail's stage list read the same result and can never disagree. */ async function loadTemplates(force = false) { state.templateLoading = true; state.error = ""; renderContent(); try { state.templates = await repo.listTemplates(); for (const entry of state.templates) { if (force || !state.templateGraphs.has(entry.key)) { state.templateGraphs.set(entry.key, await validateTemplate(entry)); } } state.templateLoading = false; renderContent(); } catch (err) { state.templateLoading = false; setError(err); } } /** The parsed graph for a template, or null when the server cannot parse its source. */ async function validateTemplate(entry) { try { return await repo.validate(entry.source); } catch { return null; } } function selectTemplate(key) { if (key) pushRoute({ kind: "template", key }); else pushRoute({ kind: "templates" }); state.selectedTemplateKey = key || null; resetTemplateCreateState(); renderContent(); } /** * The run/pipeline detail reset a different selection needs: no stale pane, * dialog or tab from the entity the operator navigated away from. Shared by the * in-page selection and the URL route so both open the same fresh detail. */ function resetRunDetailState() { state.runGraph?.unmount(); state.runGraph = null; state.runDetail = null; state.runTab = "summary"; state.runSections = new Set(); state.runStagePane = null; state.runStageSections = new Set(); state.runDecision = null; state.decisionOpen = false; state.decisionDraft = new DecisionDraft(); state.decisionSending = false; state.decisionError = ""; state.confirmKind = null; state.renameValue = null; state.actionError = ""; } /** * A server refusal (its own `type:"error"` reply) means the entity genuinely does * not exist. A transport failure — a timeout, a socket drop, a client-side * NotConnectedError — is not a missing entity, so its deep link is kept (and will * be hydrated again on reconnect) rather than discarded. */ function isServerRefusal(err) { return err instanceof ProtocolError; } /** * A run the server does not have falls back honestly: the selection is cleared, * the runs list is shown (and loaded if this was a hard deep link), the server's * own refusal stays in the page banner, and the URL is replaced with /runs. It * never throws and never leaves an empty run pane carrying a stale identity. */ async function missingRunFallback(err) { stopRunPoll(); resetRunDetailState(); state.selectedRunId = null; state.view = "runs"; if (state.connection.kind === "connected" && !state.runsLoaded) { await loadCurrentView(); } state.error = describeError(err); replaceRoute({ kind: "runs" }); renderContent(); } /** * The pipeline-side reset a different selection (or a refusal) needs. The * selection ids are the caller's, so only the detail it describes is cleared. */ function resetPipelineDetailState() { state.pipelineDetail = null; state.pipelineTab = "summary"; state.pipelineGraphSelection = null; state.versionsExpanded = false; } /** * Whether the loaded graph can select a stage key. The route parser cannot know * the keys without data, so the wiring checks and falls back honestly. The * mounted graph selects every laid-out node — named stages and the two terminals * (`#success`/`#failure`) — and the URL it writes for any of them must re-open * the same pane, so the check uses the same layout rather than stages alone. */ function pipelineHasStage(detail, key) { return layoutGraph(detail?.graph).nodes.some((node) => node.key === key); } /** The pipeline counterpart of missingRunFallback: list, banner, /pipelines. */ async function missingPipelineFallback(err) { resetPipelineDetailState(); state.selectedPipelineId = null; state.view = "pipelines"; if (state.connection.kind === "connected" && !state.pipelinesLoaded) { await loadCurrentView(); } state.error = describeError(err); replaceRoute({ kind: "pipelines" }); renderContent(); } /** The pipeline selection this reply was requested for is still the shown one. */ function pipelineStillSelected(id, version) { return ( state.view === "pipelines" && state.selectedPipelineId === id && state.pipelineRequestedVersion === version ); } async function selectPipeline(summary, { updateRoute = true } = {}) { const id = summary.id; const version = Number.isSafeInteger(summary.version) && summary.version > 0 ? summary.version : 0; if (updateRoute) pushRoute({ kind: "pipeline", id, version }); state.view = "pipelines"; state.selectedPipelineId = id; state.pipelineRequestedVersion = version; resetPipelineDetailState(); // A selection describes only itself: a previous refusal banner must not sit // above the entity the operator has just opened. state.error = ""; renderContent(); try { const detail = await repo.getPipeline(id, version); // The operator may have moved on while this reply was in flight (a tab, a // different pipeline, Back/Forward). A late reply must not repaint an entity // beside a URL that no longer names it. if (!pipelineStillSelected(id, version)) return; state.pipelineDetail = detail; renderContent(); } catch (err) { if (!pipelineStillSelected(id, version)) return; if (isServerRefusal(err)) { await missingPipelineFallback(err); return; } // A transient failure keeps the deep link; the reconnect re-hydrates it. state.error = describeError(err); renderContent(); } } /** The run this reply was requested for is still the shown one. */ function runStillSelected(id) { return state.view === "runs" && state.selectedRunId === id; } async function selectRun(id, { silent = false, updateRoute = true } = {}) { if (!silent && updateRoute) pushRoute({ kind: "run", id }); state.selectedRunId = id; if (!silent) { resetRunDetailState(); // See selectPipeline: a refusal about the previous entity is not about this // one, and a silent poll must never wipe an error the operator should see. state.error = ""; renderContent(); } try { const detail = await repo.getRun(id); // Ignore a reply for a selection the operator already navigated away from // (the same guard covers a silent poll whose run was deselected). The poll // itself is stopped here: a reply discarded for a view that no longer shows // Runs must not leave a 1 Hz get_run loop running against an unshown run. if (!runStillSelected(id)) { stopRunPoll(); return; } state.runDetail = detail; renderContent(); updateRunPoll(); } catch (err) { if (!runStillSelected(id)) { stopRunPoll(); return; } if (silent) { stopRunPoll(); return; } if (isServerRefusal(err)) { await missingRunFallback(err); return; } // A transient failure keeps the deep link; the reconnect re-hydrates it. state.error = describeError(err); renderContent(); } } function updateRunPoll() { stopRunPoll(); if (state.view === "runs" && state.selectedRunId && isExecuting(state.runDetail)) { runPoll = setInterval(() => selectRun(state.selectedRunId, { silent: true }), 1000); } } function stopRunPoll() { if (runPoll) { clearInterval(runPoll); runPoll = null; } } /** * (Re)start the shared runs-list clock: it ticks once a second only while a * shown run is executing, updating each running row's meta line in place (never * a full re-render, so an open filter/sort menu is not torn down). The elapsed * value is derived from the run's server start timestamp, so it survives a * reconnect. */ function refreshListClock() { stopListClock(); listNow = Date.now(); if (state.view === "runs" && state.runs.some((run) => run.executing)) { listClock = setInterval(() => { listNow = Date.now(); for (const node of document.querySelectorAll(".run-row-meta[data-run-id]")) { const id = Number(node.getAttribute("data-run-id")); const run = state.runs.find((candidate) => candidate.id === id); if (run && run.executing) node.textContent = metaText(run, listNow); } }, 1000); } } function stopListClock() { if (listClock) { clearInterval(listClock); listClock = null; } } /** * (Re)start the run detail's own clock: it ticks once a second only while the * shown run is executing, updating just the Duration row in place (never a full * re-render, so an open stage pane and its scroll are not torn down). The value * is derived from the server's start timestamp, so it survives a reconnect. */ function refreshDetailClock() { stopDetailClock(); detailNow = Date.now(); if (state.view === "runs" && isExecuting(state.runDetail)) { detailClock = setInterval(() => { detailNow = Date.now(); const node = document.querySelector(".run-duration[data-run-id]"); if (node && state.runDetail) node.textContent = runDurationText(state.runDetail, detailNow) ?? ""; }, 1000); } } function stopDetailClock() { if (detailClock) { clearInterval(detailClock); detailClock = null; } } /** * (Re)start the chat indicator's clock: it ticks once a second only while the * open conversation has a turn in flight, updating the phase, the elapsed and the * per-tool `· long` marks in place (never a full re-render). */ function refreshChatClock() { stopChatClock(); chatNow = Date.now(); const thread = state.chatActiveId ? state.chatThreads.get(state.chatActiveId) : null; const awaiting = approvalCard(thread?.permission, thread?.permissionAnswer)?.actionable === true; if (state.view === "chat" && thread?.running && !awaiting) { chatClock = setInterval(() => { chatNow = Date.now(); updateChatIndicator(chatNow); }, 1000); } } function stopChatClock() { if (chatClock) { clearInterval(chatClock); chatClock = null; } } /** Refresh the running indicator in place from the thread's own state at [now]. */ function updateChatIndicator(now) { const thread = state.chatActiveId ? state.chatThreads.get(state.chatActiveId) : null; const el = document.getElementById("chatRunning"); if (!thread?.running || !el) return; const label = el.querySelector(".chat-running-label"); if (label) label.textContent = turnPhaseLabel(threadPhase(thread, now) ?? TURN_PHASE_WAITING); const elapsed = el.querySelector(".chat-running-elapsed"); if (elapsed) elapsed.textContent = `\u00b7 ${formatDuration(Math.trunc(threadElapsedMillis(thread, now) / 1000))}`; for (const part of threadRunningTools(thread.messages)) { const line = el.querySelector(`.chat-running-tool[data-part-id="${String(part?.id ?? "")}"]`); if (!line) continue; const age = threadToolElapsedMillis(thread, part, now); const toolElapsed = line.querySelector(".chat-running-tool-elapsed"); if (toolElapsed) toolElapsed.textContent = formatToolDuration(age); const mark = line.querySelector(".chat-tool-long"); if (toolLongRunning(age) && !mark) { line.classList.add("chat-running-tool-long"); line.append(h("span", { class: "chat-tool-long", text: "\u00b7 long" })); } } } // --------------------------------------------------------------------------- // Boot // --------------------------------------------------------------------------- client.addEventListener("state", (event) => { const next = event.detail; const wasConnected = state.connection.kind === "connected"; const previousKind = state.connection.kind; state.connection = next; if (next.kind === "connected" && !wasConnected) { onConnected(); } if (next.kind !== "connected" && previousKind === "connected") { stopRunPoll(); stopListClock(); stopDetailClock(); stopChatClock(); // The socket dropped: the server detaches every chat subscription with it // (there is no chat_unsubscribe), and the frames feeding any running turn are // gone, so no thread keeps claiming to run until a fresh frame proves it. clearChatSubscriptions(); settleChatThreads(); // Drop the run-status baseline but keep this page session's notified keys: // the reconnect reseeds from the fresh list before it resubscribes, so a // transition hidden by the gap can never notify late. runAlerts.reset(); } // A reconnect (not a first connect): re-attach the open chat's stream and // refresh its history wholesale, so a gap that swallowed the end of a turn is // repaired rather than shown stale. if (next.kind === "connected" && (previousKind === "connecting" || previousKind === "disconnected")) { resyncOpenChat(); } render(); }); // The client surfaces every unsolicited envelope as a DOM-free `frame` event // (client.js). A `chat_event` frame is folded twice, on purpose: the live // transcript (C5) folds the frame itself, and the composer's own bookkeeping // clears the queued notice and releases the Stop control. A frame for any other // type is ignored. client.addEventListener("frame", (event) => { const message = event.detail; if (!message) return; if (message.type === Protocol.RUN_EVENT) { // L5 only: observe the pushed transition for notifications. R10's runs-list // fold is deliberately not implemented here. const runFrame = message[Protocol.RUN_EVENT]; if (runFrame) onRunAlertFrame(runFrame); return; } if (message.type === Protocol.CHAT_PERMISSION) { const permission = message[ChatKeys.PERMISSION]; if (permission) onChatPermission(permission); return; } if (message.type !== Protocol.CHAT_EVENT) return; const frame = message[ChatKeys.EVENT]; if (frame) onChatEvent(frame); onChatFrame(message); }); // The stage pane, the decision sheet, the confirm/Action-failed dialogs, the // omni-search field and the attention sheet are modal: Escape closes the topmost // one (the artifact viewer or the diff viewer, when either is above, owns Escape // first via its own listener). The attention sheet, when open, is the topmost // overlay and owns Escape first. Registered once; every branch is a no-op when // nothing is open. document.addEventListener("keydown", (event) => { if (event.key !== "Escape") return; if (state.attentionSheetOpen) { event.preventDefault(); closeAttentionSheet(); return; } if (document.querySelector(".artifact-viewer") || document.querySelector(".change-viewer")) return; if (state.templateCreateOpen) { event.preventDefault(); closeTemplateCreateDialog(); return; } if (state.actionError) { event.preventDefault(); dismissActionError(); return; } if (state.chatRename) { event.preventDefault(); dismissChatRename(); return; } if (state.chatClose) { event.preventDefault(); dismissChatClose(); return; } if (state.confirmKind) { event.preventDefault(); dismissConfirm(); return; } if (state.decisionOpen) { event.preventDefault(); closeDecisionSheet(); return; } if (state.runStagePane) { event.preventDefault(); closeStagePane(); return; } if (state.chatMenu) { event.preventDefault(); state.chatMenu = null; renderContent(); return; } if (state.searchOpen) { event.preventDefault(); closeSearch(); } }); // A click anywhere outside an open Chat actions menu closes it, so a menu never // lingers behind another row's selection. The wrap element (button + panel) // keeps its own clicks from closing it. document.addEventListener("click", (event) => { if (!state.chatMenu) return; const target = event.target; if (target instanceof Element && target.closest(".chat-menu-wrap")) return; state.chatMenu = null; renderContent(); }); // Return-to-foreground recovery (T4): the page becomes visible again, or the // browser reports it is back online, and the client drives its socket back // without waiting out the backoff. DOM-only, and idempotent. document.addEventListener("visibilitychange", () => { if (document.visibilityState === "visible") onForegroundActive(); }); window.addEventListener("online", onForegroundActive); // Prefill from a previous session only; the user still confirms with Connect. // The attention surface's dismissed identities are loaded once here, before the // first render, so the bell's badge is correct from the very first paint. state.attentionDismissed = loadAttentionDismissed(); state.notifyAsked = loadNotifyAsked(); // One route parse at boot. A deep link is kept pending — the first successful // connection loads its list and then its detail/stage — while the page paints the // right destination's shell immediately. const bootRoute = parseRoute(location.pathname, location.search); // An unknown or malformed boot path parses to the Pipelines list; correct the // address bar so the URL and the rendered view agree (the pending deep link, if // any, is untouched: a real deep link is not the default route). const bootUrl = `${location.pathname}${location.search}`; if (bootRoute.kind === "pipelines" && bootUrl !== "/pipelines") { try { history.replaceState(null, "", "/pipelines"); } catch { // A non-HTTP location (file://) may refuse history; the view still renders. } } state.route = bootRoute; state.pendingRoute = bootRoute; state.view = viewForRoute(bootRoute); // Back/Forward move between the views the user actually visited: parse the new // location and apply it without a document reload. A pop during an in-flight // application is recorded and re-applied when that pass finishes. window.addEventListener("popstate", () => { if (state.routeApplying) { state.popPending = true; return; } applyRoute(parseRoute(location.pathname, location.search)); }); render();