@oar-sh/oar 0.9.10 → 0.9.11

package/server/db-schema.mjs

@@ -18,6 +18,10 @@ import { migrateSubagentTimeline } from './migrations/0009-subagent-timeline.mjs
 import { migrateSubagentTimelinePruning } from './migrations/0010-subagent-timeline-pruning.mjs';
 import { migrateRelayEventSubscriptions } from './migrations/0011-relay-event-subscriptions.mjs';
 import { migrateCrossRelayEventSubscriptions } from './migrations/0012-cross-relay-event-subscriptions.mjs';
+import { migratePreviews } from './migrations/0013-previews.mjs';
+import { migrateConversationGroups } from './migrations/0014-conversation-groups.mjs';
+import { migrateConversationGroupPosition } from './migrations/0015-conversation-group-position.mjs';
+import { migrateShareAccessLog } from './migrations/0016-share-access-log.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -426,8 +430,8 @@ export const SCHEMA_SQL = `
     ON workflow_runs(conversation_id);
 
   -- Previews published mid-turn, pinned to the transcript. Snapshot JSON, not a
-  -- registry reference: the registry is in-memory and the card must still
-  -- render after the preview closes or the relay restarts. Written with the
+  -- registry reference: the card must still render after the preview closes
+  -- (or after a restart dropped it as no longer valid). Written with the
   -- queue id (the response id does not exist yet mid-turn) and linked to the
   -- response at finalize, exactly like relay_activity.
   CREATE TABLE IF NOT EXISTS preview_cards (
@@ -445,6 +449,24 @@ export const SCHEMA_SQL = `
   CREATE INDEX IF NOT EXISTS idx_preview_cards_queue
     ON preview_cards(queue_message_id);
 
+  -- Published previews, restored at boot so their public links survive a
+  -- restart. Existing databases get the table from migration 0013 (same
+  -- columns; a test keeps the two declarations equal). Times are epoch ms.
+  -- Its index comes from the migration only, which skips a previews table of
+  -- other columns instead of failing the boot over it.
+  CREATE TABLE IF NOT EXISTS previews (
+    token           TEXT PRIMARY KEY,
+    mode            TEXT NOT NULL,
+    conversation_id TEXT,
+    label           TEXT NOT NULL,
+    target_host     TEXT,
+    target_port     INTEGER,
+    root_dir        TEXT,
+    created_at      INTEGER NOT NULL,
+    last_hit_at     INTEGER,
+    host_boot_id    TEXT
+  );
+
   CREATE TABLE IF NOT EXISTS uploaded_files (
     sha256        TEXT PRIMARY KEY,
     original_name TEXT,
@@ -778,6 +800,41 @@ try {
 } catch (error) {
   console.warn(`[relay-events] migration 0012 failed; retrying on next boot: ${error?.message || error}`);
 }
+// Persisted previews: one new table. The preview store checks for it and keeps
+// previews in memory only without it, so a failure is logged and retried next
+// boot like 0012.
+try {
+  migratePreviews(db);
+} catch (error) {
+  console.warn(`[previews] migration 0013 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// Session groups: the group table and the conversations' group column. The
+// group repository checks for them and sees no groups without them, so a
+// failure is logged and retried next boot like 0012.
+try {
+  migrateConversationGroups(db);
+} catch (error) {
+  console.warn(`[session-groups] migration 0014 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// A hand order inside a session group: one column. The group repository
+// checks for it and keeps the activity order without it, so a failure is
+// logged and retried next boot like 0014.
+try {
+  migrateConversationGroupPosition(db);
+} catch (error) {
+  console.warn(`[session-groups] migration 0015 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// Share lineages and the share access log: one column, one table. The share
+// repository checks for them; without them a renew starts a fresh lineage and
+// no open is logged, so a failure is logged and retried next boot like 0015.
+try {
+  migrateShareAccessLog(db);
+} catch (error) {
+  console.warn(`[shares] migration 0016 failed; retrying on next boot: ${error?.message || error}`);
+}
 
 const runtimeSessionColumns = db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((c) => c.name);
 if (runtimeSessionColumns.length) {

package/server/grok-worker/acp-client.mjs

@@ -12,6 +12,7 @@ import {
   createTurnStalledError,
   resolveTurnStallWindows,
 } from '../../shared/worker-runtime/turn-liveness.mjs';
+import { windowsSystemToolPath } from '../../shared/windows-system-tools.mjs';
 
 function whichCommand(command = 'grok') {
   const value = String(command || 'grok').trim() || 'grok';
@@ -522,7 +523,7 @@ export class AcpClient extends EventEmitter {
       this.proc.kill();
       if (process.platform === 'win32' && this.proc.pid) {
         try {
-          this.spawnImpl('taskkill', ['/pid', String(this.proc.pid), '/t', '/f'], {
+          this.spawnImpl(windowsSystemToolPath('taskkill'), ['/pid', String(this.proc.pid), '/t', '/f'], {
             stdio: 'ignore',
             windowsHide: true,
           });

package/server/grok-worker/acp-host-services.mjs

@@ -12,6 +12,7 @@
  */
 import { spawn, spawnSync } from 'node:child_process';
 import fs from 'node:fs/promises';
+import { windowsSystemToolPath } from '../../shared/windows-system-tools.mjs';
 
 const DEFAULT_OUTPUT_BYTE_LIMIT = 1024 * 1024;
 const MAX_OUTPUT_BYTE_LIMIT = 8 * 1024 * 1024;
@@ -55,9 +56,9 @@ export function createAcpHostServices({
         timeout: 10_000,
         stdio: 'ignore',
       });
-      cachedWindowsShell = probe && probe.status === 0 ? 'pwsh' : 'powershell';
+      cachedWindowsShell = probe && probe.status === 0 ? 'pwsh' : windowsSystemToolPath('powershell');
     } catch {
-      cachedWindowsShell = 'powershell';
+      cachedWindowsShell = windowsSystemToolPath('powershell');
     }
     return cachedWindowsShell;
   }
@@ -178,7 +179,7 @@ export function createAcpHostServices({
     if (platform === 'win32' && entry.proc.pid) {
       // proc.kill() only reaches the shell; shells leave grandchildren behind.
       try {
-        spawnImpl('taskkill', ['/pid', String(entry.proc.pid), '/t', '/f'], {
+        spawnImpl(windowsSystemToolPath('taskkill'), ['/pid', String(entry.proc.pid), '/t', '/f'], {
           stdio: 'ignore',
           windowsHide: true,
         });

package/server/migrations/0013-previews.mjs

@@ -0,0 +1,130 @@
+'use strict';
+
+/**
+ * Migration: persisted previews.
+ *
+ * `previews` holds every published preview (a public link to a dev-server port
+ * or to a folder the relay serves), so a restarted runtime can restore them and
+ * a link handed out before the restart keeps working. One row per token:
+ *
+ * - `mode` is 'port' or 'static'. A port row has `target_host` and
+ *   `target_port`, a static row `root_dir` (the folder's realpath).
+ * - `conversation_id` is NULL for a preview registered without one.
+ * - `created_at` and `last_hit_at` are epoch milliseconds.
+ * - `host_boot_id` names the host boot the preview was registered in. A port
+ *   preview is restored only in the same boot (a dev server does not survive a
+ *   reboot, and the port may later belong to something else).
+ *
+ * No foreign key on `conversation_id`: deleting a conversation closes its
+ * previews through the registry, and a restore drops rows whose conversation
+ * is gone.
+ *
+ * Additive and idempotent. Safe to run on every boot, and from the command line
+ * against a database a running relay has open (one CREATE TABLE in WAL mode).
+ * An older build never reads the table.
+ *
+ * A `previews` table this migration did not create (other columns) is left
+ * alone and reported as not compatible; the relay then keeps previews in
+ * memory only, it never refuses to start over it.
+ *
+ * Usage: node server/migrations/0013-previews.mjs [path/to/copilot.db]
+ * The file must exist: a wrong path is refused rather than creating an empty
+ * database.
+ */
+
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export const PREVIEWS_COLUMNS = Object.freeze([
+  'token', 'mode', 'conversation_id', 'label', 'target_host', 'target_port', 'root_dir',
+  'created_at', 'last_hit_at', 'host_boot_id',
+]);
+
+/**
+ * Why the `previews` table cannot be used, or '' when it can: every column
+ * this build reads and writes is there, and any other column takes a NULL or
+ * has a default (an insert would fail otherwise). '' too when the table is
+ * missing; the caller checks that separately.
+ */
+export function previewsTableProblem(db) {
+  const info = db.prepare(`PRAGMA table_info(previews)`).all();
+  if (info.length === 0) return '';
+  const names = new Set(info.map((column) => column.name));
+  const missing = PREVIEWS_COLUMNS.filter((name) => !names.has(name));
+  if (missing.length) return `the previews table lacks column(s) ${missing.join(', ')}`;
+  const blocking = info.filter((column) => !PREVIEWS_COLUMNS.includes(column.name)
+    && column.notnull && column.dflt_value === null && !column.pk);
+  if (blocking.length) {
+    return `the previews table has required column(s) this build does not write: ${blocking.map((column) => column.name).join(', ')}`;
+  }
+  return '';
+}
+
+export function migratePreviews(db) {
+  let tablesAdded = 0;
+  if (!tableExists(db, 'previews')) {
+    db.exec(`
+      CREATE TABLE previews (
+        token           TEXT PRIMARY KEY,
+        mode            TEXT NOT NULL,
+        conversation_id TEXT,
+        label           TEXT NOT NULL,
+        target_host     TEXT,
+        target_port     INTEGER,
+        root_dir        TEXT,
+        created_at      INTEGER NOT NULL,
+        last_hit_at     INTEGER,
+        host_boot_id    TEXT
+      )
+    `);
+    tablesAdded += 1;
+  }
+  const problem = previewsTableProblem(db);
+  if (problem) return { applied: false, tablesAdded, compatible: false, problem };
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_previews_conversation ON previews(conversation_id)`);
+  return { applied: tablesAdded > 0, tablesAdded, compatible: true };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  if (!fs.existsSync(dbPath)) throw new Error(`no database at ${dbPath}`);
+  const db = new Database(dbPath, { fileMustExist: true, ...options });
+  try {
+    return migratePreviews(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0013 on ${dbPath}`);
+    if (!result.compatible) {
+      console.error(`  not compatible: ${result.problem}; the relay will keep previews in memory only`);
+      process.exit(1);
+    }
+    console.log(result.applied
+      ? `  previews: tables added ${result.tablesAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0013 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0014-conversation-groups.mjs

@@ -0,0 +1,89 @@
+'use strict';
+
+/**
+ * Migration: session groups in the sidebar.
+ *
+ * A group is the set of conversations that share a `group_id`. The table
+ * `conversation_groups` holds what the set itself needs: a name given by hand
+ * (NULL means "shown under the head's title") and the head, the session that
+ * created the others with the remote_relay tool (NULL for a group made by
+ * hand, or once the head is deleted). A conversation an agent creates on this
+ * relay joins its creator's group at bootstrap; everything else is done by
+ * hand in the sidebar. Nothing is backfilled.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0014-conversation-groups.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function migrateConversationGroups(db) {
+  if (!tableExists(db, 'conversations')) {
+    throw new Error('conversations is missing (the base schema has not run)');
+  }
+  let tablesAdded = 0;
+  if (!tableExists(db, 'conversation_groups')) {
+    db.exec(`
+      CREATE TABLE conversation_groups (
+        id                     TEXT PRIMARY KEY,
+        name                   TEXT,
+        parent_conversation_id TEXT,
+        created_at             TEXT NOT NULL,
+        updated_at             TEXT NOT NULL
+      )
+    `);
+    tablesAdded += 1;
+  }
+  const present = new Set(db.prepare(`PRAGMA table_info(conversations)`).all().map((column) => column.name));
+  let columnsAdded = 0;
+  if (!present.has('group_id')) {
+    db.exec(`ALTER TABLE conversations ADD COLUMN group_id TEXT`);
+    columnsAdded += 1;
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_conversations_group
+    ON conversations(group_id)
+    WHERE group_id IS NOT NULL
+  `);
+  return { applied: columnsAdded > 0 || tablesAdded > 0, columnsAdded, tablesAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateConversationGroups(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0014 on ${dbPath}`);
+    console.log(result.applied
+      ? `  conversation groups: columns added ${result.columnsAdded}, tables added ${result.tablesAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0014 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0015-conversation-group-position.mjs

@@ -0,0 +1,76 @@
+'use strict';
+
+/**
+ * Migration: a hand order inside a session group.
+ *
+ * `group_position` is a member's place in its group once the owner has
+ * dragged a row there: the members with one come first, by position, the
+ * others after them, newest first. The head keeps NULL (it always leads),
+ * and so does every member of a group nobody reordered. A row that leaves
+ * its group loses its position.
+ *
+ * Additive and idempotent. Safe to run on every boot. Rolling back needs no
+ * data change: older code ignores the column; a row it moves out of a group
+ * keeps a stale place, which the next run here clears.
+ *
+ * Usage: node server/migrations/0015-conversation-group-position.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function migrateConversationGroupPosition(db) {
+  if (!tableExists(db, 'conversations')) {
+    throw new Error('conversations is missing (the base schema has not run)');
+  }
+  const present = new Set(db.prepare(`PRAGMA table_info(conversations)`).all().map((column) => column.name));
+  let columnsAdded = 0;
+  if (!present.has('group_position')) {
+    db.exec(`ALTER TABLE conversations ADD COLUMN group_position INTEGER`);
+    columnsAdded += 1;
+  }
+  // A place without a group: an older release (which ignores the column)
+  // moved the row out of its group after a roll back. Cleared on every run.
+  const placesCleared = present.has('group_id')
+    ? db.prepare(`UPDATE conversations SET group_position = NULL WHERE group_id IS NULL AND group_position IS NOT NULL`).run().changes
+    : 0;
+  return { applied: columnsAdded > 0 || placesCleared > 0, columnsAdded, placesCleared };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateConversationGroupPosition(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0015 on ${dbPath}`);
+    console.log(result.applied
+      ? `  group position: columns added ${result.columnsAdded}, stale places cleared ${result.placesCleared}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0015 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0016-share-access-log.mjs

@@ -0,0 +1,110 @@
+'use strict';
+
+/**
+ * Migration: share lineages and the share access log.
+ *
+ * A share link can be renewed: the conversation gets a new token and the old
+ * one stops at once. What the link has been through (its opens) belongs to the
+ * share, not to one token, so every row of `conversation_shares` gets a
+ * `lineage_id`: the token the share started with, carried over to every
+ * renewed token. Existing rows start their own lineage (`lineage_id = token`).
+ *
+ * `conversation_share_opens` holds one row per open of a shared page:
+ *
+ * - `lineage_id` names the share; the log survives a renew.
+ * - `opened_at` is an ISO timestamp.
+ * - `ip` is NULL when the relay does not store viewer addresses (a setting).
+ * - `country` is the edge's two-letter country, NULL when unknown.
+ * - `viewer_key` is a keyed hash of address and browser, so distinct viewers
+ *   can be counted when the address itself is not stored.
+ *
+ * Stopping a share deletes its log; deleting the conversation does too (the
+ * foreign key, and the delete route by hand). Nothing else prunes it.
+ *
+ * Additive and idempotent. Safe to run on every boot. An older build never
+ * reads the new table, and a share it creates has no lineage, which this build
+ * reads as the share's own token.
+ *
+ * Usage: node server/migrations/0016-share-access-log.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function migrateShareAccessLog(db) {
+  if (!tableExists(db, 'conversation_shares')) {
+    throw new Error('conversation_shares is missing (the base schema has not run)');
+  }
+  let columnsAdded = 0;
+  let tablesAdded = 0;
+  const present = new Set(db.prepare(`PRAGMA table_info(conversation_shares)`).all().map((column) => column.name));
+  if (!present.has('lineage_id')) {
+    db.exec(`ALTER TABLE conversation_shares ADD COLUMN lineage_id TEXT`);
+    columnsAdded += 1;
+  }
+  // Every run: a share an older build created after this migration has none.
+  const lineagesSet = db.prepare(`UPDATE conversation_shares SET lineage_id = token WHERE lineage_id IS NULL OR lineage_id = ''`).run().changes;
+  if (!tableExists(db, 'conversation_share_opens')) {
+    db.exec(`
+      CREATE TABLE conversation_share_opens (
+        id              INTEGER PRIMARY KEY AUTOINCREMENT,
+        lineage_id      TEXT NOT NULL,
+        conversation_id TEXT NOT NULL,
+        opened_at       TEXT NOT NULL,
+        ip              TEXT,
+        user_agent      TEXT,
+        country         TEXT,
+        viewer_key      TEXT NOT NULL,
+        FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+      )
+    `);
+    tablesAdded += 1;
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_conversation_share_opens_lineage
+    ON conversation_share_opens(lineage_id, opened_at DESC)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_conversation_share_opens_conversation
+    ON conversation_share_opens(conversation_id)
+  `);
+  return { applied: columnsAdded > 0 || tablesAdded > 0 || lineagesSet > 0, columnsAdded, tablesAdded, lineagesSet };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateShareAccessLog(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0016 on ${dbPath}`);
+    console.log(result.applied
+      ? `  share access log: columns added ${result.columnsAdded}, tables added ${result.tablesAdded}, lineages set ${result.lineagesSet}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0016 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/public/app/about-ui.js

@@ -0,0 +1,73 @@
+// ⋯ → About OAR: the menu entry's label and the modal (about-view.mjs builds
+// its HTML from GET /api/about).
+
+import {
+  closeSummaryModal,
+  escHtml,
+  getUpdateState,
+  openSummaryModal,
+  renderSummaryModalContent,
+  setSummaryModalLoading,
+} from './store.js';
+import { apiFetchOrThrow } from './api-client.js';
+import { openSettingsModal } from './settings-modal.js';
+import { aboutMenuLabel, buildAboutModalHtml } from './about-view.mjs';
+
+const ABOUT_KIND = 'about';
+const ABOUT_TITLE = 'About OAR';
+
+/** The entry carries the running version; /api/status brings it on load. */
+export function syncAboutMenuLabel(version = getUpdateState()?.runningVersion) {
+  const button = document.getElementById('chat-menu-about');
+  if (button) button.textContent = aboutMenuLabel(version);
+}
+
+function bindAboutModalActions() {
+  const body = document.getElementById('summary-modal-body');
+  const button = body?.querySelector('[data-about-open-settings]');
+  if (!button) return;
+  button.addEventListener('click', (event) => {
+    event.preventDefault();
+    closeSummaryModal();
+    openSettingsModal('general');
+    document.getElementById('update-auto-check-toggle')?.scrollIntoView?.({ block: 'center' });
+  });
+}
+
+async function loadAboutAndRender() {
+  const about = await apiFetchOrThrow('/api/about');
+  if (!about) throw new Error('The relay is not reachable right now.');
+  renderSummaryModalContent({
+    title: ABOUT_TITLE,
+    subtitle: about.version ? `Version ${about.version}` : '',
+    bodyHtml: buildAboutModalHtml(about),
+    refresh: loadAboutAndRender,
+    kind: ABOUT_KIND,
+  });
+  bindAboutModalActions();
+  syncAboutMenuLabel(about.version);
+}
+
+export async function showAbout() {
+  openSummaryModal({
+    title: ABOUT_TITLE,
+    subtitle: 'Loading…',
+    bodyHtml: '<div class="summary-loading">Reading the relay…</div>',
+    refresh: loadAboutAndRender,
+    kind: ABOUT_KIND,
+  });
+  setSummaryModalLoading(true);
+  try {
+    await loadAboutAndRender();
+  } catch (error) {
+    renderSummaryModalContent({
+      title: ABOUT_TITLE,
+      subtitle: 'Unable to load',
+      bodyHtml: `<div class="summary-error">${escHtml(error?.message || 'Unknown error')}</div>`,
+      refresh: loadAboutAndRender,
+      kind: ABOUT_KIND,
+    });
+  } finally {
+    setSummaryModalLoading(false);
+  }
+}