/** * Terminal app, hosted in its own worker thread. Window model: * - "terminal:hub": the window opened from the launcher; shows the list of * live g2mirror sessions grouped under a heading per configured host * (unconnected hosts show their state and a Connect row; selecting a * connected host's heading launches a shell there), and hosts the Manage * Connections section * where g2mirror:// connections are added, removed, and toggled. * - "terminal:view:N": opened by selecting a session in the hub; each has * its own websocket connection (the protocol allows one attached session * per connection) and its own xterm emulator. * * Connections are g2mirror://@[:port] strings (g2mirrors:// for * TLS), stored as JSON in the settings store (see connections.ts). Each * enabled connection gets a control websocket that backs the session list and * carries unsolicited bell/title notifications; control connections live as * long as the worker so bells keep flowing even if the hub window is closed. * The host's server_name (from the init reply) is cached per connection and * used as its display name, falling back to the connection string's * host[:port] before the first successful handshake. * * Bells for a session with an open, non-foregrounded view window set that * window's sidebar attention flag (cleared by the host on foregrounding). * Frames are painted here and submitted directly to the Java compositor from * this worker's thread. * * Auto-reconnect (window menu > Settings, default on): while any terminal window * is open, a dropped control connection reconnects with exponential backoff; * the first session list after reconnect delivers bells that rang while * disconnected (attention + wake) via their advanced lastBellAt. A dropped * view connection reconnects immediately while visible, but a hidden view just * marks itself stale and reconnects on its next foreground/screen-on — its * re-attach snapshot resyncs contents and scrollback only once it's needed. */ import "@nativescript/core/globals"; import { hasTerminalBackgroundWork } from "./background"; import { finishWorkerShutdown } from "../../ui/shell/worker-lifecycle"; import { GrayImage, type UiFont } from "../../graphics/image"; import { flattenPlanesWithDraws, planesFingerprint, type Plane } from "../../graphics/plane"; import { prepareFrameDraws } from "../../graphics/glyph-wire"; import { getDefaultSmallFont, getTerminalFontConfig } from "../../graphics/ui-fonts"; import { HUB_TITLE_X, layoutHubHeader } from "./hub-header"; import { TERMINAL_ICON_GLYPHS, type IconActivity } from "../../graphics/icons"; import { drawSessionRow, TERMINAL_SESSIONS_STATE_KEY, type TerminalSessionsSnapshot, } from "./session-list"; import * as frameTimings from "../../native/frame-timings"; import { getActiveDisplay } from "../../native/active-display"; import { GESTURE_DOUBLE_CLICK, type InputEvent } from "../../ui/gestures"; import { G2MirrorClient, type G2MirrorClientOptions, type G2MirrorSession, type G2MirrorState } from "../../native/g2mirror-client"; import { onSettingsStoreChanged } from "../../native/settings-store"; import { clamp } from "../../util/numeric-util"; import { enumSettingMenuItem, terminalAutoReconnectSetting, terminalDisplayLayoutSetting, terminalLaunchPresetsSetting, terminalNewConnectionSetting, terminalWakeOnBellSetting, textSettingMenuItem, toggleSettingMenuItem, } from "../../ui/dashboard-settings"; import { terminalFontPickerMenuItem } from "../../ui/font-picker"; import { connectionDisplayName, loadConnections, parseConnectionString, saveConnections, TERMINAL_CONNECTIONS_KEY, updateConnection, type TerminalConnection } from "./connections"; import { TerminalEmulator } from "./terminal-emulator"; import { drawSubmenuIndicator, submenuItem, type MenuItem } from "../../ui/menu"; import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { centeredTextY, lineStep, listRowHeight, textInkHeight } from "../../ui/metrics"; import { WindowMenu, WindowMenuLayer } from "../../ui/window-menu"; import { appViewportSize } from "../../ui/shell/geometry"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; import type { ToolResult, ToolSpec } from "../../assistant/tool-registry"; declare const global: any; // Cell geometry comes from the terminal font setting (window menu > Settings > // Font; the default is Terminus-12's 6x12). Each window derives its grid from // the viewport in its open-window message (the hub is min-height, session // views full-height). Grid dimensions are baked into each session's websocket // handshake, so windows and control connections capture the cell size at // creation — a font change applies to ones (re)opened afterwards. function chromeFont(): UiFont { return getDefaultSmallFont(); } // Grid of a session view window (full-height); also declared on the control // connections so sessions launched from presets come up at view size. const VIEW_VIEWPORT = appViewportSize("max"); function viewGrid(): { cols: number; rows: number } { const { cellWidth, cellHeight } = getTerminalFontConfig(); return { cols: Math.floor(VIEW_VIEWPORT.width / cellWidth), rows: Math.floor(VIEW_VIEWPORT.height / cellHeight), }; } const DEVICE_NAME = "Faceclaw G2"; const RENDER_COALESCE_MS = 33; const HISTORY_PAGE = 200; // Auto-reconnect backoff: doubles per failed attempt, resets on success. const RECONNECT_MIN_DELAY_MS = 1_000; const RECONNECT_MAX_DELAY_MS = 60_000; // Storage key of terminalNewConnectionSetting (the Add-connection draft the // phone text editor types into); its changes just repaint the add screen. const NEW_CONNECTION_DRAFT_KEY = "terminal.newConnectionDraft"; // Storage key of terminalLaunchPresetsSetting, edited from the window menu. const LAUNCH_PRESETS_KEY = "terminal.launchPresets"; type BaseWindow = { windowId: string; surfaceId: string; /** Shell-side window title, echoed back in the open-window message. */ title: string; /** Content viewport from the shell's open-window message; grid = viewport / cell. */ viewportWidth: number; viewportHeight: number; gridCols: number; gridRows: number; foreground: boolean; /** * Whether this window is the shell's input target (vs. the sidebar having * focus). Pushed by the shell on every input/render/foreground message; * every focus transition triggers one of those, so it never goes stale. */ focused: boolean; renderScheduled: boolean; lastSubmittedFingerprint: string; /** Long-press window menu; created on first open. */ menu: WindowMenu | null; }; /** * What the hub window is showing: the session list, the Manage Connections * section, or the Add-connection screen (type the g2mirror:// string on the * phone, click to save). */ type HubMode = "sessions" | "connections" | "add"; type HubWindow = BaseWindow & { kind: "hub"; mode: HubMode; /** The section's item list; created on first paint or input (hubMenu). */ list: Menu | null; /** * Session recency keys in display order, captured when the window last * became visible so the list doesn't reshuffle under the user while it's * open. Cleared on foreground/screen-on; orderedSessions() rebuilds it * lazily, sorting by recency and appending sessions that appear while * visible. */ sessionOrder: string[]; /** Parse-failure message shown on the Add-connection screen. */ addError: string; }; type ViewWindow = BaseWindow & { kind: "view"; /** Grid font and integer cell pitch, captured at window creation. */ font: UiFont; cellWidth: number; cellHeight: number; connectionId: string; socket: string; label: string; /** Sidebar-icon character (">3"); "" if every glyph was taken at open time. */ glyph: string; client: G2MirrorClient; emulator: TerminalEmulator; receivedData: boolean; attachRequested: boolean; status: string; unsubscribers: Array<() => void>; // Scrollback model. Absolute line indices span the archive and the emulator: // indices < historyNext are archived lines; >= historyNext are emulator buffer // line (index - historyNext). `archive` holds fetched lines [archiveStart, // historyNext). `scrollTop` is the absolute index of the top visible line, or // null to follow the live bottom. historyNext: number; historyOldest: number; archive: string[]; archiveStart: number; scrollTop: number | null; historyFetchInFlight: boolean; /** * The websocket dropped and hasn't been reconnected yet. While the view is * hidden this just sits set (content resync deferred); the next * foreground/screen-on reconnects if auto-reconnect is enabled. */ needsReconnect: boolean; reconnectTimer: ReturnType | null; reconnectDelayMs: number; }; type TerminalWindow = HubWindow | ViewWindow; type PendingView = { connectionId: string; socket: string; label: string; glyph: string; /** Client options captured when the view was requested from a live control. */ options: G2MirrorClientOptions; }; const windows = new Map(); const pendingViews = new Map(); // The view an assistant tool acts on when the terminal isn't foregrounded: // the last view to be foregrounded or receive input. let activeViewId: string | null = null; let nextViewSerial = 1; /** * Assistant tools this app contributes, declared on the hub window (which the * launcher opens and which persists for the app's life). All `open`-tier so * "rerun the build" works while the terminal is backgrounded. send_input and * read_screen act on the active view session (see resolveActiveView). */ const TERMINAL_TOOLS: ToolSpec[] = [ { name: "list_sessions", description: "List the live g2mirror terminal sessions the glasses can see, across every connected host.", inputSchema: { type: "object", properties: {}, additionalProperties: false }, availability: "open", }, { name: "send_input", description: "Type a line into the active terminal session and submit it (as if typed and Enter pressed). Use to run a command in the terminal.", inputSchema: { type: "object", properties: { text: { type: "string", description: "The line to type and run." } }, required: ["text"], additionalProperties: false, }, availability: "open", }, { name: "read_screen", description: "Return the current visible contents of the active terminal session's screen.", inputSchema: { type: "object", properties: {}, additionalProperties: false }, availability: "open", }, { name: "list_launch_presets", description: "List the named launch presets that can start a new terminal session on a host machine (for launch_session).", inputSchema: { type: "object", properties: {}, additionalProperties: false }, availability: "open", }, { name: "launch_session", description: "Start a new terminal session on a connected host machine from a named launch preset (see list_launch_presets) and open a window viewing it.", inputSchema: { type: "object", properties: { preset: { type: "string", description: "Name of the launch preset to start." }, host: { type: "string", description: "Which host to launch on (server name), when more than one is connected.", }, }, required: ["preset"], additionalProperties: false, }, availability: "open", timeoutMs: 15_000, }, ]; let screenOn = true; /** * One record per configured connection: the stored config plus the live * control client (session listing for the hub, unsolicited bell/title * notifications). `client` is null while the connection is disabled or the * config doesn't parse. */ type ControlConnection = { config: TerminalConnection; client: G2MirrorClient | null; state: G2MirrorState | null; unsubscribers: Array<() => void>; reconnectTimer: ReturnType | null; reconnectDelayMs: number; sessionsSeeded: boolean; }; // Keyed by connection id; iteration order mirrors the stored list (rebuilt by // syncControlsFromSettings). Populated once the app is first opened. const controls = new Map(); let controlsInitialized = false; // When each session last "updated", unix epoch ms: bells, title changes, and // terminal output from open views. Keys are recencyKey(connectionId, socket). // Sessions first seen in the initial list after (re)connect are seeded from // their last bell, since we weren't watching; ones appearing later were just // created, so they get "now". const sessionRecency = new Map(); // When each session's app last produced output, as LOCAL receive time of the // server's `activity` push (phone clock — the wire timestamp is host-clock // and can't be compared against Date.now() across machines). Keys are // recencyKey(connectionId, socket). A session is "active" (hub rows show an // animated indicator) while an activity push arrived within the last // ACTIVITY_ACTIVE_MS; the wrapper reports at most one per 2s while output // continues, so 5s of slack keeps the indicator lit through the gaps. const sessionActivity = new Map(); const ACTIVITY_ACTIVE_MS = 5_000; // Alternation period shared by hub rows and sidebar cursors. const HUB_ANIMATION_STEP_MS = 800; function recencyKey(connectionId: string, socket: string): string { return `${connectionId}\n${socket}`; } function post(message: WorkerAppReply): void { global.postMessage(message); } // The host queues messages until this arrives: posts to a worker whose bundle // is still evaluating can be silently dropped (see WorkerAppHost). Top-level // evaluation is synchronous, so the handler below is installed before any // queued message can be delivered. post({ type: "worker-ready" }); global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { case "check-idle": reportIdle(); break; case "shutdown": for (const control of controls.values()) stopControl(control); controls.clear(); finishWorkerShutdown(); break; case "open-window": openWindow(message.windowId, message.surfaceId, message.title, message.viewport); break; case "resize-window": { const window = windows.get(message.windowId); if (!window || (window.viewportWidth === message.viewport.width && window.viewportHeight === message.viewport.height)) break; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; window.menu?.resize(message.viewport); window.lastSubmittedFingerprint = ""; if (window.kind === "view") { window.gridCols = Math.floor(window.viewportWidth / window.cellWidth); window.gridRows = Math.floor(window.viewportHeight / window.cellHeight); if (window.reconnectTimer) clearTimeout(window.reconnectTimer); window.reconnectTimer = null; window.client.stop(); window.client.setViewport(window.gridCols, window.gridRows); window.emulator.dispose(); window.emulator = new TerminalEmulator(window.gridCols, window.gridRows); window.receivedData = false; window.archive = []; window.scrollTop = null; reconnectView(window); } scheduleRender(window); break; } case "close-window": closeWindow(message.windowId); break; case "input": { const window = windows.get(message.windowId); if (!window) { frameTimings.finishFrame(message.frameId, "discarded: unknown terminal window"); break; } window.focused = message.focused; // Marks the main-thread -> worker hop, which is otherwise an // unexplained gap inside the shell's handle-input span. frameTimings.logFrame(message.frameId, `input received in ${message.windowId} worker`); handleInput(window, message.event as InputEvent, message.frameId); break; } case "text-input": { const window = windows.get(message.windowId); // Attached view windows type into their terminal. The hub accepts text // only on the Add-connection screen, where it fills the draft (voice // input as an alternative to the phone keyboard). submitInput appends // Enter ("\r") after a wrapper-side pause so paste-detecting apps // (e.g. Claude Code) submit instead of inserting a newline. if (window && window.kind === "view") { if (message.submit === false) window.client.sendInput(message.text); else window.client.submitInput(message.text); } else if (window && window.kind === "hub" && window.mode === "add") { terminalNewConnectionSetting.set(message.text); scheduleRender(window); } break; } case "render": { const window = windows.get(message.windowId); if (!window) break; window.focused = message.focused; renderAndSubmit(window, 0); break; } case "foreground": { const window = windows.get(message.windowId); if (!window) break; window.foreground = message.foreground; window.focused = message.focused; if (window.foreground && window.kind === "view") { activeViewId = window.windowId; maybeReconnectView(window); } if (window.foreground && window.kind === "hub") window.sessionOrder = []; if (window.foreground) renderAndSubmit(window, 0); updateHubAnimation(); break; } case "screen": screenOn = message.on; if (screenOn) { for (const window of windows.values()) { if (!window.foreground) continue; // Waking counts as becoming visible: let the session list re-sort. if (window.kind === "hub") window.sessionOrder = []; if (window.kind === "view") maybeReconnectView(window); renderAndSubmit(window, 0); } } updateHubAnimation(); break; case "tool-call": { const callId = message.callId; Promise.resolve(handleTerminalTool(message.name, message.args)) .then((result) => post({ type: "tool-result", callId, result })) .catch((error) => post({ type: "tool-result", callId, result: { ok: false, error: String((error as Error)?.message ?? error) }, }), ); break; } case "input-focus": case "navigation-sensors": break; } }; // React to setting changes (connections edited here or in another isolate, // the window menu's settings, the Add-connection draft typed on the phone). onSettingsStoreChanged((key) => { if (key.startsWith("glanceboard.")) { reportIdle(); return; } if (!key.startsWith("terminal.")) return; switch (key) { case TERMINAL_CONNECTIONS_KEY: // Only once the app has actually been opened. if (controlsInitialized) syncControlsFromSettings(); renderHubWindows(); reportIdle(); return; case NEW_CONNECTION_DRAFT_KEY: // Live keystrokes from the phone editor; repaint the add screen. renderHubWindows(); return; case "terminal.autoReconnect": if (!terminalAutoReconnectSetting.get()) { cancelPendingReconnects(); } else if (windows.size > 0 || hasTerminalBackgroundWork()) { for (const control of controls.values()) { if ((control.state?.phase ?? "idle") === "failed") scheduleControlReconnect(control); } } return; case LAUNCH_PRESETS_KEY: // Live keystrokes from the phone editor (Settings > Launch presets in // the window menu): repaint its edit page, and the hub, whose host // headings launch presets. for (const window of windows.values()) { if (window.menu?.isOpen()) scheduleRender(window); } renderHubWindows(); return; default: // wakeOnBell: no connection impact. return; } }); function reportIdle(): void { if (windows.size === 0 && !hasTerminalBackgroundWork()) post({ type: "worker-idle" }); } /** Cancel scheduled retries (auto-reconnect turned off); stale views stay marked. */ function cancelPendingReconnects(): void { for (const control of controls.values()) { cancelControlReconnect(control); } for (const window of windows.values()) { if (window.kind === "view" && window.reconnectTimer) { clearTimeout(window.reconnectTimer); window.reconnectTimer = null; } } } function openWindow(windowId: string, surfaceId: string, title: string, viewport: { width: number; height: number }): void { const pendingView = pendingViews.get(windowId); if (pendingView) { pendingViews.delete(windowId); windows.set(windowId, createViewWindow(windowId, surfaceId, title, viewport, pendingView)); updateHubAnimation(); renderHubWindows(); return; } const hubCell = getTerminalFontConfig(); windows.set(windowId, { kind: "hub", windowId, surfaceId, title, viewportWidth: viewport.width, viewportHeight: viewport.height, gridCols: Math.floor(viewport.width / hubCell.cellWidth), gridRows: Math.floor(viewport.height / hubCell.cellHeight), foreground: false, focused: false, renderScheduled: false, lastSubmittedFingerprint: "", menu: null, mode: "sessions", list: null, sessionOrder: [], addError: "", }); // The hub carries the app's assistant tools; declare them once it exists. post({ type: "set-tools", windowId, tools: TERMINAL_TOOLS }); if (!controlsInitialized) { syncControlsFromSettings(); } updateHubAnimation(); } function closeWindow(windowId: string): void { const window = windows.get(windowId); if (!window) return; if (window.kind === "view") { for (const unsubscribe of window.unsubscribers.splice(0)) { unsubscribe(); } if (window.reconnectTimer) { clearTimeout(window.reconnectTimer); window.reconnectTimer = null; } window.client.stop(); } if (window.kind === "hub" && window.mode === "add") { // Window closed mid-add: shut the phone editor down. endAddConnection(window); } // Likewise for a setting being edited from the window menu. window.menu?.close(); windows.delete(windowId); windowIconActivity.delete(windowId); updateHubAnimation(); // A configured widget owns the control connections after the last window closes. if (windows.size === 0 && !hasTerminalBackgroundWork()) { for (const control of controls.values()) { cancelControlReconnect(control); } } if (activeViewId === windowId) activeViewId = null; if (window.kind === "view") { renderHubWindows(); } } /** Client options for a connection string; null if the string doesn't parse. */ function clientOptionsFor(connection: TerminalConnection): G2MirrorClientOptions | null { const parsed = parseConnectionString(connection.url); if (!parsed) return null; return { ...parsed, deviceName: DEVICE_NAME, ...viewGrid(), }; } /** * Reconcile the live control clients with the stored connection list: start * enabled connections, stop disabled or removed ones, restart ones whose * connection string changed. Called on first open and whenever the stored * list changes (including our own edits). Rebuilds the map in stored order so * UI iteration matches the list the user manages. */ function syncControlsFromSettings(): void { controlsInitialized = true; const stored = loadConnections(); const storedIds = new Set(stored.map((connection) => connection.id)); for (const [id, control] of Array.from(controls)) { if (!storedIds.has(id)) { stopControl(control); controls.delete(id); } } const previous = new Map(controls); controls.clear(); for (const connection of stored) { let control = previous.get(connection.id); if (!control) { control = { config: connection, client: null, state: null, unsubscribers: [], reconnectTimer: null, reconnectDelayMs: RECONNECT_MIN_DELAY_MS, sessionsSeeded: false, }; } const urlChanged = control.config.url !== connection.url; control.config = connection; controls.set(connection.id, control); if (connection.enabled && (urlChanged || !control.client)) { startControl(control); } else if (!connection.enabled && control.client) { stopControl(control); } } renderHubWindows(); } function startControl(control: ControlConnection): void { stopControl(control); const options = clientOptionsFor(control.config); if (!options) { control.state = null; return; } const client = new G2MirrorClient(options); const connectionId = control.config.id; control.client = client; control.state = client.state(); control.sessionsSeeded = false; control.unsubscribers.push( client.onStateChange((state) => { // Only the current client speaks for the control (stopControl clears // listeners, but a stop() emits synchronously before that). if (control.client !== client) return; noteSessionListRecency(control, state); control.state = state; if (state.phase === "connected") { control.reconnectDelayMs = RECONNECT_MIN_DELAY_MS; maybeCacheServerName(control, state.serverName); } if (state.phase === "failed") scheduleControlReconnect(control); renderHubWindows(); }), client.onBell((socket, lastBellAtMs) => { routeBell(connectionId, socket, lastBellAtMs); }), client.onTitle((socket) => { noteSessionUpdated(connectionId, socket); }), client.onActivity((socket) => { noteSessionActivity(connectionId, socket); }), ); client.start(); } function stopControl(control: ControlConnection): void { cancelControlReconnect(control); for (const unsubscribe of control.unsubscribers.splice(0)) { unsubscribe(); } control.client?.stop(); control.client = null; control.state = null; } /** * A successful handshake reported the host's server_name; cache it on the * stored connection so the hub can name the host even while disconnected. * The resulting settings change re-runs syncControlsFromSettings, which sees * an unchanged url and leaves the live client alone. */ function maybeCacheServerName(control: ControlConnection, serverName: string): void { if (!serverName || control.config.serverName === serverName) return; control.config.serverName = serverName; updateConnection(control.config.id, { serverName }); } function noteSessionUpdated(connectionId: string, socket: string): void { sessionRecency.set(recencyKey(connectionId, socket), Date.now()); } function noteSessionListRecency(control: ControlConnection, state: G2MirrorState): void { const connectionId = control.config.id; for (const session of state.sessions) { const key = recencyKey(connectionId, session.socket); const known = sessionRecency.get(key); if (known === undefined) { sessionRecency.set( key, Math.max(session.lastBellAt ?? 0, control.sessionsSeeded ? Date.now() : 0), ); } else if ((session.lastBellAt ?? 0) > known) { // A bell rang while we weren't connected to hear it (the live bell // message would have advanced the recency); deliver it late so the // missed attention flag / wake still happens. routeBell(connectionId, session.socket, session.lastBellAt!); } } if (state.sessions.length) control.sessionsSeeded = true; } /** * Retry a control connection after a backoff delay. The delay doubles per * scheduled attempt and resets when a connection reaches "connected" (or on * a manual Connect). Windows and a configured widget can both own the client. */ function scheduleControlReconnect(control: ControlConnection): void { if (control.reconnectTimer) return; if (!terminalAutoReconnectSetting.get()) return; if (windows.size === 0 && !hasTerminalBackgroundWork()) return; if (!control.config.enabled) return; const delayMs = control.reconnectDelayMs; control.reconnectDelayMs = Math.min(control.reconnectDelayMs * 2, RECONNECT_MAX_DELAY_MS); control.reconnectTimer = setTimeout(() => { control.reconnectTimer = null; if (!terminalAutoReconnectSetting.get() || (windows.size === 0 && !hasTerminalBackgroundWork())) return; if (controls.get(control.config.id) !== control || !control.config.enabled) return; if ((control.state?.phase ?? "idle") === "failed") startControl(control); }, delayMs); } function cancelControlReconnect(control: ControlConnection): void { if (control.reconnectTimer) { clearTimeout(control.reconnectTimer); control.reconnectTimer = null; } } function routeBell(connectionId: string, socket: string, lastBellAtMs: number): void { const key = recencyKey(connectionId, socket); const known = sessionRecency.get(key) ?? 0; if (lastBellAtMs > known) sessionRecency.set(key, lastBellAtMs); for (const window of windows.values()) { if ( window.kind === "view" && window.connectionId === connectionId && window.socket === socket && !window.foreground ) { post({ type: "set-attention", windowId: window.windowId, attention: true }); } } if (terminalWakeOnBellSetting.get()) { // Wake to the belling session's view window, or the hub if it has none. // The shell drops the message unless the glasses are actually asleep. const viewId = viewWindowIdForSocket(connectionId, socket); const hubId = [...windows.values()].find((window) => window.kind === "hub")?.windowId ?? null; const target = viewId ?? hubId; if (target) post({ type: "wake-window", windowId: target }); } } function renderHubWindows(): void { for (const window of windows.values()) { if (window.kind === "hub") scheduleRender(window); } // Every change the hub repaints for is one the published list may reflect. publishSessionsSnapshot(); } let lastPublishedSnapshot = ""; /** * Publish the session list for main-thread consumers (the Glanceboard's * Terminal widget): connected hosts with their sessions most-recently-updated * first, each with its activity deadline (local clock, so the consumer can * expire and animate it itself) and the glyph of its open view window. Posted * only when the JSON actually changed. */ function publishSessionsSnapshot(): void { const connected = connectedControls(); const snapshot: TerminalSessionsSnapshot = { hosts: connected.map((control) => { const connectionId = control.config.id; const sessions = (control.state?.sessions ?? []) .slice() .sort( (a, b) => (sessionRecency.get(recencyKey(connectionId, b.socket)) ?? 0) - (sessionRecency.get(recencyKey(connectionId, a.socket)) ?? 0), ); return { name: connectionDisplayName(control.config), sessions: sessions.map((session) => ({ key: recencyKey(connectionId, session.socket), label: sessionLabel(session), activeUntilMs: (sessionActivity.get(recencyKey(connectionId, session.socket)) ?? -ACTIVITY_ACTIVE_MS) + ACTIVITY_ACTIVE_MS, openGlyph: viewGlyphForSocket(connectionId, session.socket), })), }; }), status: sessionsStatusLine(), configured: controls.size > 0, }; const encoded = JSON.stringify(snapshot); if (encoded === lastPublishedSnapshot) return; lastPublishedSnapshot = encoded; post({ type: "publish-state", key: TERMINAL_SESSIONS_STATE_KEY, state: snapshot }); } // One animation clock for foreground hub rows and every terminal sidebar icon. // Keep ticking while the sidebar can show activity, even with the hub closed. let hubAnimationPhase = 0; let hubAnimationTimer: ReturnType | null = null; const windowIconActivity = new Map(); function isSessionActive(connectionId: string, socket: string): boolean { const at = sessionActivity.get(recencyKey(connectionId, socket)); return at !== undefined && Date.now() - at < ACTIVITY_ACTIVE_MS; } function isWindowSessionActive(window: TerminalWindow): boolean { if (window.kind === "view") return isSessionActive(window.connectionId, window.socket); const now = Date.now(); return [...sessionActivity.values()].some((at) => now - at < ACTIVITY_ACTIVE_MS); } function hubAnimationShouldRun(): boolean { return screenOn && [...windows.values()].some(isWindowSessionActive); } function syncWindowIconActivity(): void { for (const window of windows.values()) { const activity: IconActivity = screenOn && isWindowSessionActive(window) ? (hubAnimationPhase === 0 ? "on" : "off") : "idle"; if ((windowIconActivity.get(window.windowId) ?? "idle") === activity) continue; windowIconActivity.set(window.windowId, activity); post({ type: "set-icon-activity", windowId: window.windowId, activity }); } } /** Start or stop animation and publish changed icons, including expiry/wake. */ function updateHubAnimation(): void { const shouldRun = hubAnimationShouldRun(); if (shouldRun && !hubAnimationTimer) hubAnimationPhase = 0; syncWindowIconActivity(); if (shouldRun) { if (hubAnimationTimer) return; hubAnimationTimer = setInterval(() => { hubAnimationPhase = (hubAnimationPhase + 1) % 2; updateHubAnimation(); // Render even on the stopping tick, to clear expired indicators. renderHubWindows(); }, HUB_ANIMATION_STEP_MS); } else if (hubAnimationTimer) { clearInterval(hubAnimationTimer); hubAnimationTimer = null; } } /** An activity push arrived for a session: mark it and (re)start the animation. */ function noteSessionActivity(connectionId: string, socket: string): void { const key = recencyKey(connectionId, socket); const wasActive = isSessionActive(connectionId, socket); sessionActivity.set(key, Date.now()); sessionRecency.set(key, Date.now()); updateHubAnimation(); // A session just turned active: show its indicator now rather than up to // one animation step later. if (!wasActive) renderHubWindows(); } function createViewWindow( windowId: string, surfaceId: string, title: string, viewport: { width: number; height: number }, view: PendingView, ): ViewWindow { const { connectionId, socket, label, glyph } = view; // Capture the terminal font at open time: the grid dims go into the // websocket handshake and the emulator, so they must not change under a // live window (a font-setting change applies to the next window). const cell = getTerminalFontConfig(); const gridCols = Math.floor(viewport.width / cell.cellWidth); const gridRows = Math.floor(viewport.height / cell.cellHeight); const client = new G2MirrorClient({ ...view.options, cols: gridCols, rows: gridRows }); const window: ViewWindow = { kind: "view", windowId, surfaceId, title, viewportWidth: viewport.width, viewportHeight: viewport.height, gridCols, gridRows, font: cell.font, cellWidth: cell.cellWidth, cellHeight: cell.cellHeight, foreground: false, focused: false, renderScheduled: false, lastSubmittedFingerprint: "", menu: null, connectionId, socket, label, glyph, client, emulator: new TerminalEmulator(gridCols, gridRows), receivedData: false, attachRequested: false, status: "Connecting...", unsubscribers: [], historyNext: 0, historyOldest: 0, archive: [], archiveStart: 0, scrollTop: null, historyFetchInFlight: false, needsReconnect: false, reconnectTimer: null, reconnectDelayMs: RECONNECT_MIN_DELAY_MS, }; window.unsubscribers.push( client.onSnapshot((historyNext, historyOldest) => { // A (re)snapshot resets the emulator, so reset the scroll model too: // follow the bottom and drop any fetched archive (its splice may move). window.historyNext = historyNext; window.historyOldest = historyOldest; window.archive = []; window.archiveStart = historyNext; window.scrollTop = null; window.historyFetchInFlight = false; maybePrefetchHistory(window); scheduleRender(window); }), client.onHistoryLines((reply) => { applyHistoryReply(window, reply); scheduleRender(window); }), client.onStateChange((state) => { if (state.phase === "connected" && !window.attachRequested) { window.attachRequested = true; client.connectSession(socket); } if (state.phase === "connected") window.reconnectDelayMs = RECONNECT_MIN_DELAY_MS; if (state.phase === "failed") handleViewConnectionLost(window); window.status = state.status; scheduleRender(window); }), client.onSessionAttached(() => { client.view(); scheduleRender(window); }), client.onTerminalData((data, kind) => { if (kind === "snapshot") { window.emulator.reset(); } window.receivedData = true; noteSessionUpdated(window.connectionId, window.socket); window.emulator.write(data, () => scheduleRender(window)); }), client.onSessionDetached((reason) => { window.status = `Detached (${reason}).`; scheduleRender(window); }), ); client.start(); return window; } /** * The view's websocket dropped. While visible, retry on the backoff schedule; * while hidden, leave it stale (needsReconnect) so contents and scrollback * only resync once the view is next looked at. Bells still arrive via the * control connection either way. */ function handleViewConnectionLost(window: ViewWindow): void { window.needsReconnect = true; if (window.foreground && screenOn && terminalAutoReconnectSetting.get()) { scheduleViewReconnect(window); } } function scheduleViewReconnect(window: ViewWindow): void { if (window.reconnectTimer) return; const delayMs = window.reconnectDelayMs; window.reconnectDelayMs = Math.min(window.reconnectDelayMs * 2, RECONNECT_MAX_DELAY_MS); window.reconnectTimer = setTimeout(() => { window.reconnectTimer = null; if (!windows.has(window.windowId) || !window.needsReconnect) return; if (!terminalAutoReconnectSetting.get()) return; // Went invisible while waiting: defer to the next foreground/screen-on. if (!window.foreground || !screenOn) return; reconnectView(window); }, delayMs); } /** A stale view just became visible (foreground/screen-on): reconnect it now. */ function maybeReconnectView(window: ViewWindow): void { if (!window.needsReconnect || window.reconnectTimer) return; if (!terminalAutoReconnectSetting.get()) return; window.reconnectDelayMs = RECONNECT_MIN_DELAY_MS; reconnectView(window); } /** * Restart the view's websocket. On success the connected handler re-attaches * (attachRequested reset here) and the fresh snapshot resets the emulator and * scrollback archive, which is the content resync. */ function reconnectView(window: ViewWindow): void { window.needsReconnect = false; window.attachRequested = false; window.status = "Reconnecting..."; window.client.start(); scheduleRender(window); } /** The window's context menu, created lazily so window literals stay simple. */ function windowMenu(window: TerminalWindow): WindowMenu { if (!window.menu) { window.menu = new WindowMenu({ windowId: window.windowId, post, title: () => window.title, items: () => windowMenuItems(window), size: { width: window.viewportWidth, height: window.viewportHeight }, paintBase: () => paintContent(window), isFocused: () => window.focused, }); } return window.menu; } /** Whether a control's handshake has been accepted (it can list and launch sessions). */ function isControlConnected(control: ControlConnection): boolean { const phase = control.state?.phase; return phase === "connected" || phase === "attached"; } /** Controls currently connected (handshake accepted), in stored order. */ function connectedControls(): ControlConnection[] { return [...controls.values()].filter(isControlConnected); } function windowMenuItems(window: TerminalWindow): MenuItem[] { const items: MenuItem[] = [ submenuItem("Settings", (ctx) => { ctx.stack.push(new WindowMenuLayer("Terminal settings", settingsMenuItems())); }), ]; if (window.kind === "hub") { const connected = connectedControls(); const multiHost = connected.length > 1; for (const control of connected) { for (const preset of launchPresetNames()) { const label = multiHost ? `Launch ${preset} @ ${connectionDisplayName(control.config)}` : `Launch ${preset}`; items.push({ label, onSelect: (ctx) => { ctx.stack.pop(); launchFromUi(control, preset); }, }); } } } else { if (window.client.state().phase === "failed") { items.push({ label: "Reconnect", onSelect: (ctx) => { ctx.stack.pop(); if (window.reconnectTimer) { clearTimeout(window.reconnectTimer); window.reconnectTimer = null; } window.reconnectDelayMs = RECONNECT_MIN_DELAY_MS; reconnectView(window); }, }); } items.push( { label: "Send ", onSelect: (ctx) => { ctx.stack.pop(); window.client.sendInput("\r"); }, }, { label: "Send ", onSelect: (ctx) => { ctx.stack.pop(); window.client.sendInput("\u001b"); }, }, ); } return items; } /** * The app's settings (the window menu's Settings submenu). Connections are * managed in the hub's Manage Connections section instead. */ function settingsMenuItems(): MenuItem[] { return [ enumSettingMenuItem(terminalDisplayLayoutSetting), terminalFontPickerMenuItem(), // Opens the phone text editor; the settings listener repaints its page. textSettingMenuItem(terminalLaunchPresetsSetting), toggleSettingMenuItem(terminalAutoReconnectSetting), toggleSettingMenuItem(terminalWakeOnBellSetting), ]; } function handleInput(window: TerminalWindow, event: InputEvent, frameId: number): void { if (window.kind === "view") activeViewId = window.windowId; // An open window menu owns all input (it closes itself via pop). if (window.menu?.isOpen()) { void window.menu .handleInput(event) .catch((error) => console.error(`terminal menu input failed: ${error}`)) .then(() => renderAndSubmit(window, frameId)); return; } if (event.type === "short-then-long-press") { windowMenu(window).open(); renderAndSubmit(window, frameId); return; } if (event.type === "double-click") { // Inside the hub's sub-sections, double-click backs out one level; at the // top level (and in views) it yields focus to the sidebar as everywhere. if (window.kind === "hub" && window.mode === "add") { cancelAddConnection(window); renderAndSubmit(window, frameId); return; } if (window.kind === "hub" && window.mode === "connections") { setHubMode(window, "sessions"); renderAndSubmit(window, frameId); return; } frameTimings.finishFrame(frameId, "discarded: terminal yielded focus"); post({ type: "yield-focus", windowId: window.windowId }); return; } if (window.kind === "hub") { handleHubInput(window, event, frameId); return; } // View windows: scroll gestures page through scrollback; text input arrives // via the separate "text-input" message. if (event.type === "scroll-up" || event.type === "scroll-down") { handleViewScroll(window, event.type === "scroll-up" ? -1 : 1, frameId); return; } frameTimings.finishFrame(frameId, "discarded: terminal view ignored input"); } /** Top visible absolute line index when following the live bottom. */ function followTop(window: ViewWindow): number { return window.historyNext + window.emulator.bufferLength() - window.gridRows; } function handleViewScroll(window: ViewWindow, direction: -1 | 1, frameId: number): void { const page = Math.max(1, window.gridRows - 1); const bottomTop = followTop(window); const minTop = window.archiveStart; const currentTop = window.scrollTop ?? bottomTop; const newTop = clamp(currentTop + direction * page, Math.min(minTop, bottomTop), bottomTop); // Snapping to (or below) the live bottom re-locks to follow mode. window.scrollTop = newTop >= bottomTop ? null : newTop; maybePrefetchHistory(window); renderAndSubmit(window, frameId); } /** Fetch an older page of archive when the view nears the top of what's loaded. */ function maybePrefetchHistory(window: ViewWindow): void { if (window.historyFetchInFlight) return; if (window.archiveStart <= window.historyOldest) return; // nothing older retained const top = window.scrollTop ?? followTop(window); if (window.archive.length === 0 || top - window.archiveStart <= window.gridRows) { window.historyFetchInFlight = true; window.client.requestHistory(window.archiveStart, HISTORY_PAGE); } } function applyHistoryReply(window: ViewWindow, reply: { start: number; oldest: number; lines: string[] }): void { window.historyFetchInFlight = false; window.historyOldest = reply.oldest; if (!reply.lines.length) { // Nothing older was returned; stop asking below what we already have. window.historyOldest = window.archiveStart; return; } // The page ends just before our request (archiveStart); prepend it. if (reply.start < window.archiveStart) { window.archive = reply.lines.concat(window.archive); window.archiveStart = reply.start; } } type HubItem = { label: string; /** * Group heading (host name): drawn unindented and dimmer. Selectable only * when it has an onSelect (launch a shell on that host). */ heading?: boolean; /** * Top-level action (Manage Connections, Settings): drawn * unindented like a heading but at full brightness, rather than as an * indented session row. */ topLevel?: boolean; /** Opens a nested menu: a right-edge ">" marks the row. */ submenu?: boolean; /** Session with recent output: an animated indicator marks the row. */ active?: boolean; /** Glyph of the view window showing this session (the number column). */ openGlyph?: string | null; onSelect?: () => void; }; /** Vertical offset of a row's text line from the top of its selection box. */ const HUB_ROW_TEXT_INSET = 4; /** Left edge of the list's selection boxes. */ const HUB_LIST_LEFT = 12; /** Right inset of the selection boxes, clear of the scrollbar. */ const HUB_LIST_RIGHT = 20; /** Left padding of unindented (heading and top-level) row text inside its selection box. */ const HUB_TOP_LEVEL_TEXT_X = 6; /** The hub window's list, created on first use so openWindow stays free of paint dependencies. */ function hubMenu(window: HubWindow): Menu { window.list ??= new Menu({ wrap: false, rowGap: 1, getHeight: () => listRowHeight(chromeFont()), isSelectable: (item) => Boolean(item.onSelect), onSelect: (item) => item.onSelect?.(), draw: drawHubRow, }); return window.list; } function drawHubRow({ image, item, x, y, width, height, selected }: MenuDrawArgs): void { const font = chromeFont(); if (item.heading || item.topLevel) { const value = selected ? 255 : item.heading ? 140 : 200; image.drawText(font, x + HUB_TOP_LEVEL_TEXT_X, y + HUB_ROW_TEXT_INSET, item.label, value); if (item.submenu) drawSubmenuIndicator(image, font, x, y, width, height, value); return; } // Activity gutter, open-window number column, then the label, truncated // to the row (shared with the Glanceboard's Terminal widget). drawSessionRow(image, font, { x: x + 2, y: y + HUB_ROW_TEXT_INSET, width: width - 8, label: item.label, openGlyph: item.openGlyph ?? null, active: Boolean(item.active), phase: hubAnimationPhase, value: selected ? 255 : 200, }); } /** Switch the hub between its sections, resetting selection state. */ function setHubMode(window: HubWindow, mode: HubMode): void { window.mode = mode; window.list?.select(0); window.addError = ""; } /** * One control connection's sessions in this hub window's display order: * most-recently-updated first as of when the window became visible, with * sessions that appeared since then at the end. The captured order lives in * window.sessionOrder (cleared when the window becomes visible; keys are * connection-scoped) so the list doesn't reshuffle while the user is looking * at it. */ function orderedSessions(window: HubWindow, control: ControlConnection): G2MirrorSession[] { const connectionId = control.config.id; const sessions = control.state?.sessions ?? []; const position = new Map(); for (const key of window.sessionOrder) { if (!position.has(key)) position.set(key, position.size); } const fresh = sessions .filter((session) => !position.has(recencyKey(connectionId, session.socket))) .sort( (a, b) => (sessionRecency.get(recencyKey(connectionId, b.socket)) ?? 0) - (sessionRecency.get(recencyKey(connectionId, a.socket)) ?? 0), ); for (const session of fresh) { const key = recencyKey(connectionId, session.socket); position.set(key, position.size); window.sessionOrder.push(key); } return sessions .slice() .sort( (a, b) => position.get(recencyKey(connectionId, a.socket))! - position.get(recencyKey(connectionId, b.socket))!, ); } function hubItems(window: HubWindow): HubItem[] { return window.mode === "connections" ? hubConnectionItems(window) : hubSessionItems(window); } function hubSessionItems(window: HubWindow): HubItem[] { const items: HubItem[] = [ { label: "Manage Connections", topLevel: true, onSelect: () => setHubMode(window, "connections"), }, { label: "Settings", topLevel: true, submenu: true, onSelect: () => windowMenu(window).open(settingsMenuItems(), "Terminal settings"), }, ]; const multiHost = controls.size > 1; const canLaunch = launchPresetNames().length > 0; // Every configured host is listed under its own heading, in stored order, // whatever its connection state: a connected host lists its sessions, any // other shows its state on the heading plus a Connect row (unless it is // already connecting). Full management (remove, add) lives in Manage // Connections. for (const control of controls.values()) { const name = connectionDisplayName(control.config); if (!isControlConnected(control)) { items.push({ label: `${name} (${controlStatusWord(control)})`, heading: true }); const connecting = control.config.enabled && control.state?.phase === "connecting"; if (!connecting && clientOptionsFor(control.config)) { items.push({ label: control.reconnectTimer ? "Connect now" : "Connect", onSelect: () => connectControl(control), }); } continue; } items.push({ label: name, heading: true, onSelect: canLaunch ? () => launchOnHost(window, control) : undefined, }); const sessions = orderedSessions(window, control); for (const session of sessions) { items.push({ label: sessionLabel(session), active: isSessionActive(control.config.id, session.socket), openGlyph: viewGlyphForSocket(control.config.id, session.socket), onSelect: () => { const windowId = viewWindowIdForSocket(control.config.id, session.socket); if (windowId) { post({ type: "focus-window", windowId }); } else { openViewWindowFor(control, session); } }, }); } if (!sessions.length) { items.push({ label: multiHost ? "(no live sessions)" : "(no live sessions; run g2mirror )", onSelect: () => control.client?.listSessions(), }); } } return items; } function hubConnectionItems(window: HubWindow): HubItem[] { const items: HubItem[] = []; for (const control of controls.values()) { items.push({ label: `${connectionDisplayName(control.config)} (${controlStatusWord(control)})`, onSelect: () => openConnectionActions(window, control), }); } items.push( { label: "Add connection", onSelect: () => beginAddConnection(window), }, { label: "Done", onSelect: () => setHubMode(window, "sessions"), }, ); return items; } function controlStatusWord(control: ControlConnection): string { if (!control.config.enabled) return "off"; switch (control.state?.phase) { case "connected": case "attached": return "connected"; case "connecting": return "connecting"; case "failed": return control.reconnectTimer ? "retrying" : "failed"; default: return clientOptionsFor(control.config) ? "off" : "bad connection string"; } } /** Per-connection action menu (reuses the window-menu machinery). */ function openConnectionActions(window: HubWindow, control: ControlConnection): void { const name = connectionDisplayName(control.config); const items: MenuItem[] = [ control.config.enabled ? { label: "Disconnect", onSelect: (ctx) => { ctx.stack.pop(); disconnectControl(control); }, } : { label: "Connect", onSelect: (ctx) => { ctx.stack.pop(); connectControl(control); }, }, { label: `Remove ${name}`, onSelect: (ctx) => { ctx.stack.pop(); removeControl(control); }, }, { label: "Cancel", onSelect: (ctx) => { ctx.stack.pop(); }, }, ]; windowMenu(window).open(items); } /** Enable and (re)connect now; also the manual retry path, so reset backoff. */ function connectControl(control: ControlConnection): void { control.reconnectDelayMs = RECONNECT_MIN_DELAY_MS; if (!control.config.enabled) { control.config.enabled = true; updateConnection(control.config.id, { enabled: true }); } startControl(control); renderHubWindows(); } function disconnectControl(control: ControlConnection): void { control.config.enabled = false; updateConnection(control.config.id, { enabled: false }); stopControl(control); renderHubWindows(); } function removeControl(control: ControlConnection): void { stopControl(control); controls.delete(control.config.id); saveConnections(loadConnections().filter((connection) => connection.id !== control.config.id)); renderHubWindows(); } /** * Enter the Add-connection screen: clear the draft and ask the shell to open * the phone text editor on it. The user types (or voice-inputs) the * g2mirror:// string, then clicks to save or double-clicks to cancel. */ function beginAddConnection(window: HubWindow): void { terminalNewConnectionSetting.set(""); setHubMode(window, "add"); post({ type: "start-text-setting-edit", settingId: terminalNewConnectionSetting.id }); } function saveAddConnection(window: HubWindow): void { const url = terminalNewConnectionSetting.get(); if (!parseConnectionString(url)) { window.addError = url ? "Not a g2mirror://token@host connection string." : "Enter a g2mirror:// connection string first."; scheduleRender(window); return; } const connections = loadConnections(); connections.push({ id: `c${Date.now()}`, url, serverName: null, enabled: true }); saveConnections(connections); endAddConnection(window); setHubMode(window, "connections"); // Start it immediately rather than waiting for the settings-change tick. syncControlsFromSettings(); } function cancelAddConnection(window: HubWindow): void { endAddConnection(window); setHubMode(window, "connections"); } /** Common teardown for leaving the add screen: clear draft, close phone editor. */ function endAddConnection(window: HubWindow): void { window.addError = ""; terminalNewConnectionSetting.set(""); post({ type: "end-text-setting-edit" }); } function handleHubInput(window: HubWindow, event: InputEvent, frameId: number): void { if (window.mode === "add") { if (event.type === "click") { saveAddConnection(window); renderAndSubmit(window, frameId); return; } frameTimings.finishFrame(frameId, "discarded: terminal add-connection ignored input"); return; } const list = hubMenu(window); list.setItems(hubItems(window)); switch (event.type) { case "scroll-up": case "scroll-down": case "click": // The menu's input handler is async only to await onSelect; hub item // callbacks are synchronous, so the selection move or action has // already applied when it returns and the frame can paint right away. list.handleInput(event).catch((error) => console.error("terminal hub action failed", error)); renderAndSubmit(window, frameId); return; default: frameTimings.finishFrame(frameId, "discarded: terminal hub ignored input"); return; } } /** * Window id of the view already showing this session's terminal, if any. * Includes views that were requested but whose surface hasn't opened yet, so * a quick double-select can't spawn two windows for one session. */ /** Sidebar glyph of the (open or opening) view window on a session, or null. */ function viewGlyphForSocket(connectionId: string, socket: string): string | null { for (const window of windows.values()) { if (window.kind === "view" && window.connectionId === connectionId && window.socket === socket) { return window.glyph || null; } } for (const pending of pendingViews.values()) { if (pending.connectionId === connectionId && pending.socket === socket) return pending.glyph || null; } return null; } function viewWindowIdForSocket(connectionId: string, socket: string): string | null { for (const window of windows.values()) { if (window.kind === "view" && window.connectionId === connectionId && window.socket === socket) { return window.windowId; } } for (const [windowId, pending] of pendingViews) { if (pending.connectionId === connectionId && pending.socket === socket) return windowId; } return null; } function openViewWindowFor(control: ControlConnection, session: G2MirrorSession): void { openViewWindow(control, session.socket, sessionLabel(session)); } /** * Lowest unused sidebar-icon character for a new view window (its terminal * icon shows ">N"). Glyphs free up when their window closes, since usage is * recomputed from the live windows; "" (plain ">_" icon) if all are taken. */ function allocateViewGlyph(): string { const used = new Set(); for (const window of windows.values()) { if (window.kind === "view") used.add(window.glyph); } for (const pending of pendingViews.values()) used.add(pending.glyph); for (const glyph of TERMINAL_ICON_GLYPHS) { if (!used.has(glyph)) return glyph; } return ""; } function openViewWindow(control: ControlConnection, socket: string, label: string): void { const options = clientOptionsFor(control.config); if (!options) return; const windowId = `terminal:view:${nextViewSerial++}`; const glyph = allocateViewGlyph(); pendingViews.set(windowId, { connectionId: control.config.id, socket, label, glyph, options }); post({ type: "open-window-request", windowId, title: label, iconLetter: "T", icon: "terminal", iconGlyph: glyph || undefined, focus: true, // Default to tall sessions; the app display setting can override this. heightMode: "max", }); } /** Preset names the user listed in the app's settings (the wire protocol has no way to enumerate the server's). */ function launchPresetNames(): string[] { const names: string[] = []; for (const piece of terminalLaunchPresetsSetting.get().split(",")) { const name = piece.trim(); if (name && !names.includes(name)) names.push(name); } return names; } /** * A host heading in the hub was selected: launch a shell there. With a single * launch preset it starts right away; with several, a submenu titled with the * host's name picks which. */ function launchOnHost(window: HubWindow, control: ControlConnection): void { const presets = launchPresetNames(); if (presets.length === 1) { launchFromUi(control, presets[0]!); return; } windowMenu(window).open( presets.map((preset) => ({ label: `Launch ${preset}`, onSelect: (ctx) => { ctx.stack.pop(); launchFromUi(control, preset); }, })), connectionDisplayName(control.config), ); } /** Launch started from a menu or list row; failures only get logged. */ function launchFromUi(control: ControlConnection, preset: string): void { launchAndOpenView(control, preset).catch((error) => { // The hub status line also shows the server's error message. console.warn(`terminal launch ${preset} failed: ${error}`); }); } /** Launch a preset on a host and open a view window on the new session. */ async function launchAndOpenView(control: ControlConnection, preset: string): Promise { if (!control.client) throw new Error("Not connected to the g2mirror server."); const socket = await control.client.launchSession(preset); openViewWindow(control, socket, preset); return socket; } function paint(window: TerminalWindow): Plane[] { return windowMenu(window).paint(); } function paintContent(window: TerminalWindow): GrayImage { return window.kind === "hub" ? paintHub(window) : paintView(window); } function paintHub(window: HubWindow): GrayImage { if (window.mode === "add") { return paintAddConnection(window); } const image = new GrayImage(window.viewportWidth, window.viewportHeight, 0); const font = chromeFont(); const step = lineStep(font); // No border box: the shell chrome (top bar + sidebar) already frames the app. // Long statuses get a wrapped block and move the list below it. const title = window.mode === "connections" ? "Terminal - Connections" : "Terminal"; image.drawText(font, HUB_TITLE_X, 10, title, 220); const header = layoutHubHeader(font, title, hubStatusLine(window), window.viewportWidth, step); header.lines.forEach((line, index) => image.drawText(font, header.x, header.y + index * step, line, 170)); let listTop = header.listTop; if (window.mode === "sessions" && controls.size === 0) { image.drawText(font, HUB_TITLE_X + 6, listTop, "Add a g2mirror:// connection to get started, see:", 150); image.drawText(font, HUB_TITLE_X + 6, listTop + step, "https://github.com/jimrandomh/g2mirror", 190); listTop += 2 * step + 6; } const list = hubMenu(window); list.setItems(hubItems(window)); // Selection boxes start above the text line; the menu fills the selected // box only while this window has focus (an outline alone means the sidebar // owns input), matching the shell convention. const listHeight = window.viewportHeight - 6 - listTop; list.paint( image, { x: HUB_LIST_LEFT, y: listTop - 2, width: window.viewportWidth - HUB_LIST_LEFT - HUB_LIST_RIGHT, height: listHeight }, window.focused, ); list.drawScrollbar(image, window.viewportWidth - 10, listTop, listHeight - 4); return image; } function paintAddConnection(window: HubWindow): GrayImage { const image = new GrayImage(window.viewportWidth, window.viewportHeight, 0); const font = chromeFont(); const step = lineStep(font); image.drawText(font, 18, 10, "Add connection", 220); const instructionsY = 20 + step; image.drawText(font, 24, instructionsY, "Type the g2mirror://token@host string in the", 170); image.drawText(font, 24, instructionsY + step, "phone app (or use voice input from the menu).", 170); const draftY = instructionsY + 3 * step; const draft = terminalNewConnectionSetting.get(); image.drawText(font, 24, draftY, truncateLabel(draft || "(empty)", 52), 220); if (window.addError) { image.drawText(font, 24, draftY + step + 6, window.addError, 150); } image.drawText(font, 24, window.viewportHeight - font.lineHeight - 12, `click save ${GESTURE_DOUBLE_CLICK} cancel`, 110); return image; } function truncateLabel(text: string, maxLength: number): string { return text.length <= maxLength ? text : `${text.slice(0, Math.max(0, maxLength - 3))}...`; } function hubStatusLine(window: HubWindow): string { if (window.mode === "connections") { return "Select a connection to connect, disconnect, or remove."; } return sessionsStatusLine(); } /** The sessions view's status line (also published with the session snapshot). */ function sessionsStatusLine(): string { if (controls.size === 0) { return "No connections configured."; } const anyRetrying = [...controls.values()].some((control) => control.reconnectTimer); if (controls.size === 1) { const control = [...controls.values()][0]!; const status = control.config.enabled ? (control.state?.status ?? "Not connected.") : "Disconnected."; return anyRetrying ? `${status} Retrying...` : status; } const summary = `${connectedControls().length} of ${controls.size} hosts connected.`; return anyRetrying ? `${summary} Retrying...` : summary; } /** * Draw one terminal row at a fixed integer cell pitch, so glyph columns stay * aligned with the emulator's grid arithmetic even when a TTF face has * fractional advances. Identical to drawText for the 6px bitmap default. */ function drawGridRow( image: GrayImage, font: UiFont, cellWidth: number, rowY: number, text: string, value: number, ): void { let col = 0; for (const char of text) { const codePoint = char.codePointAt(0) ?? 32; if (codePoint !== 32) { const glyph = font.getGlyph(codePoint); if (glyph && glyph.bbxWidth > 0) { image.drawGlyph(font, glyph, col * cellWidth, rowY, value); } } col++; } } function paintView(window: ViewWindow): GrayImage { const image = new GrayImage(window.viewportWidth, window.viewportHeight, 0); if (!window.receivedData) { const font = chromeFont(); image.drawText(font, 24, 110, window.status, 170); return image; } const rows = window.gridRows; const historyNext = window.historyNext; const bufferLength = window.emulator.bufferLength(); const bottomTop = historyNext + bufferLength - rows; const following = window.scrollTop === null; const top = following ? bottomTop : clamp(window.scrollTop!, window.archiveStart, bottomTop); // Draw the cursor only if its line is within the visible window. const cursorScreenRow = historyNext + window.emulator.cursorRow() - top; if (cursorScreenRow >= 0 && cursorScreenRow < rows) { image.fillRect(window.emulator.cursorCol() * window.cellWidth, cursorScreenRow * window.cellHeight, window.cellWidth, window.cellHeight, 70); } // Stale content stays visible across a disconnect, so flag it: a status // line over the bottom row(s) whenever the session isn't actually attached. // It's in the UI font, which can be taller than a terminal cell, so it's // sized to that font's ink. Text is deferred glyphs (always on top of // raster), so the covered rows must be suppressed rather than painted over. const statusFont = chromeFont(); const statusBannerHeight = Math.max(window.cellHeight, textInkHeight(statusFont)); const statusBannerY = window.client.state().phase !== "attached" ? window.viewportHeight - statusBannerHeight : null; for (let row = 0; row < rows; row++) { const rowY = row * window.cellHeight; if (statusBannerY !== null && rowY + window.cellHeight > statusBannerY) continue; const absolute = top + row; let text = ""; if (absolute >= historyNext) { const bufferIndex = absolute - historyNext; if (bufferIndex >= 0 && bufferIndex < bufferLength) text = window.emulator.lineAt(bufferIndex); } else if (absolute >= window.archiveStart) { text = window.archive[absolute - window.archiveStart] ?? ""; } if (text.length) drawGridRow(image, window.font, window.cellWidth, rowY, text, 200); } if (!following) { drawScrollIndicator(image, top, window.archiveStart, bottomTop); } if (statusBannerY !== null) { image.fillRect(0, statusBannerY, window.viewportWidth, statusBannerHeight, 0); image.drawText(statusFont, 0, centeredTextY(statusFont, statusBannerY, statusBannerHeight), window.status, 170); } return image; } /** Right-edge scrollbar showing the view position within the scrollback. */ function drawScrollIndicator(image: GrayImage, top: number, minTop: number, maxTop: number): void { const trackX = image.width - 3; image.fillRect(trackX, 0, 3, image.height, 30); const fraction = clamp((top - minTop) / Math.max(1, maxTop - minTop), 0, 1); const thumbHeight = 24; const thumbY = Math.round((image.height - thumbHeight) * fraction); image.fillRect(trackX, thumbY, 3, thumbHeight, 150); } /** Coalesce bursty repaint triggers (terminal output) into ~30fps renders. */ function scheduleRender(window: TerminalWindow): void { if (window.renderScheduled) return; window.renderScheduled = true; setTimeout(() => { window.renderScheduled = false; renderAndSubmit(window, 0); }, RENDER_COALESCE_MS); } function renderAndSubmit(window: TerminalWindow, inputFrameId: number): void { if (!window.foreground || !screenOn) { frameTimings.finishFrame(inputFrameId, "discarded: terminal window not visible"); return; } const frameId = inputFrameId > 0 ? inputFrameId : frameTimings.startFrame(`render:${window.windowId}`); try { const paintStartedAtMs = Date.now(); const planes = frameTimings.span(frameId, "paint", () => frameTimings.runWithFrame(frameId, () => paint(window)), ); const paintMs = Date.now() - paintStartedAtMs; const fingerprint = planesFingerprint(planes); if (fingerprint === window.lastSubmittedFingerprint) { frameTimings.finishFrame(frameId, "discarded: terminal content unchanged"); return; } const communicator = getActiveDisplay(); if (!communicator) { frameTimings.finishFrame(frameId, "discarded: no active display"); return; } const { image, draws } = frameTimings.span(frameId, "flatten", () => flattenPlanesWithDraws(planes)); const buffer = frameTimings.span(frameId, "to8bpp", () => image.to8bppBuffer()); communicator.submitSurfaceFrame( buffer.buffer, window.surfaceId, 0, 0, image.width, image.height, fingerprint, paintMs, frameId, frameTimings.span(frameId, "prepareFrameDraws", () => prepareFrameDraws(draws)), ); window.lastSubmittedFingerprint = fingerprint; } catch (error) { frameTimings.finishFrame(frameId, "discarded: terminal render failed"); console.error(`terminal worker render failed: ${error}`); } } function sessionLabel(session: G2MirrorSession): string { if (session.title) { return session.title; } const hint = session.cwdHint.replace(/^_+/, "").replace(/_+/g, "/"); return hint || "session"; } /** Dispatch an assistant tool-call (unprefixed name) to its handler. */ function handleTerminalTool(name: string, args: any): ToolResult | Promise { switch (name) { case "list_sessions": return toolListSessions(); case "send_input": return toolSendInput(args); case "read_screen": return toolReadScreen(); case "list_launch_presets": return toolListLaunchPresets(); case "launch_session": return toolLaunchSession(args); default: return { ok: false, error: `Unknown terminal tool: ${name}` }; } } function toolListLaunchPresets(): ToolResult { const presets = launchPresetNames(); if (!presets.length) { return { ok: true, content: "No launch presets configured (Terminal window menu > Settings > Launch presets)." }; } return { ok: true, content: presets.map((preset) => `- ${preset}`).join("\n") }; } /** * Pick the host a launch_session call targets: by (partial) server-name match * when `host` is given, else the sole connected host; ambiguity is an error * listing the choices. */ function resolveLaunchControl(host: string): ControlConnection | { error: string } { const connected = connectedControls(); if (!connected.length) return { error: "Not connected to any g2mirror server." }; if (host) { const matches = connected.filter((control) => connectionDisplayName(control.config).toLowerCase().includes(host.toLowerCase()), ); if (matches.length === 1) return matches[0]!; return { error: `Host "${host}" ${matches.length ? "is ambiguous among" : "does not match any of"}: ${connected .map((control) => connectionDisplayName(control.config)) .join(", ")}`, }; } if (connected.length === 1) return connected[0]!; return { error: `Multiple hosts connected; pass host: ${connected .map((control) => connectionDisplayName(control.config)) .join(", ")}`, }; } async function toolLaunchSession(args: any): Promise { const preset = String(args?.preset ?? "").trim(); if (!preset) return { ok: false, error: "launch_session requires a preset name." }; const control = resolveLaunchControl(String(args?.host ?? "").trim()); if ("error" in control) return { ok: false, error: control.error }; const socket = await launchAndOpenView(control, preset); return { ok: true, content: `Launched "${preset}" (session ${socket}) and opened a window viewing it.` }; } function toolListSessions(): ToolResult { const connected = connectedControls(); const multiHost = connected.length > 1; const lines: string[] = []; for (const control of connected) { const sessions = control.state?.sessions ?? []; if (multiHost) { lines.push(`${connectionDisplayName(control.config)}:`); } for (const session of sessions) { const glyph = viewGlyphForSocket(control.config.id, session.socket); const open = glyph ? ` [open in window ${glyph}]` : viewWindowIdForSocket(control.config.id, session.socket) ? " [open]" : ""; lines.push(`- ${sessionLabel(session)}${open}`); } if (!sessions.length && multiHost) { lines.push("- (no live sessions)"); } } if (!lines.length) { return { ok: true, content: "No live terminal sessions (run g2mirror on a host)." }; } return { ok: true, content: lines.join("\n") }; } function toolSendInput(args: any): ToolResult { const text = String(args?.text ?? ""); if (!text) return { ok: false, error: "send_input requires non-empty text." }; const view = resolveActiveView(); if (!view) return { ok: false, error: "No terminal session is open to send input to." }; view.client.submitInput(text); return { ok: true, content: `Sent to ${view.label}.` }; } function toolReadScreen(): ToolResult { const view = resolveActiveView(); if (!view) return { ok: false, error: "No terminal session is open." }; const length = view.emulator.bufferLength(); const start = Math.max(0, length - view.gridRows); const lines: string[] = []; for (let index = start; index < length; index++) { lines.push(view.emulator.lineAt(index)); } const text = lines.join("\n").replace(/\s+$/, ""); return { ok: true, content: text || "(screen is empty)" }; } /** * The terminal view an `open`-tier tool acts on: a foregrounded view if any, * else the last view to be active, else the sole open view. Null when no view * is open (the model gets a tool error it can relay). */ function resolveActiveView(): ViewWindow | null { const views: ViewWindow[] = []; let foreground: ViewWindow | null = null; for (const window of windows.values()) { if (window.kind !== "view") continue; views.push(window); if (window.foreground) foreground = window; } if (foreground) return foreground; if (activeViewId) { const window = windows.get(activeViewId); if (window && window.kind === "view") return window; } return views.length === 1 ? views[0]! : null; }