ompchamber 0.3.0

package/src/server/db.server.ts

@@ -0,0 +1,338 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { createDb, type DbClient } from '@/server/lib/db/client';
+import { isMockMode } from '@/server/mock.server';
+import { SAMPLE_TOOLS_SESSION_ID, getSampleToolsSession } from '@/client/data/samples/tools-session';
+import { SAMPLE_DIALOGUE_SESSION_ID, getSampleDialogueSession } from '@/client/data/samples/dialogue-session';
+import { SAMPLE_DEVICES_SESSION_ID, getSampleDevicesSession } from '@/client/data/samples/virtual-devices-session';
+import { loadOmpSidebarData } from '@/server/lib/omp/session/reader';
+import { pathExists, projectPathKey } from '@/server/lib/omp/core/paths';
+
+let dbPromise: Promise<DbClient> | null = null;
+
+/** SYNC_WORKSPACE env flag (default true when unset). When enabled in real
+ *  mode, workspace folders are auto-created from discovered omp projects. */
+export function isWorkspaceSyncEnabled(): boolean {
+  const raw = (Bun.env.SYNC_WORKSPACE || '').trim().toLowerCase();
+  if (raw === '') return true;
+  return raw !== 'false' && raw !== '0' && raw !== 'off' && raw !== 'no';
+}
+
+export async function getDatabasePath(): Promise<string> {
+  if (isMockMode()) {
+    return path.join(process.cwd(), 'workspace.db');
+  }
+
+  const customPath = Bun.env.OMPCHAMBER_DB_PATH || Bun.env.DB_PATH;
+  if (customPath) {
+    const resolvedPath = customPath.startsWith('~')
+      ? path.join(os.homedir(), customPath.slice(1))
+      : path.resolve(customPath);
+    const dir = path.dirname(resolvedPath);
+    if (!(await pathExists(dir))) {
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    return resolvedPath;
+  }
+
+  const defaultDir = path.join(os.homedir(), '.ompchamber');
+  if (!(await pathExists(defaultDir))) {
+    await fs.promises.mkdir(defaultDir, { recursive: true });
+  }
+  return path.join(defaultDir, 'db.sqlite');
+}
+
+export async function getDb(): Promise<DbClient> {
+  if (dbPromise) return dbPromise;
+
+  dbPromise = (async () => {
+    const dbPath = await getDatabasePath();
+    const db = createDb(dbPath);
+
+    await db.exec(`
+      CREATE TABLE IF NOT EXISTS workspace_folders (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        is_expanded BOOLEAN DEFAULT 0,
+        project_path TEXT,
+        model TEXT DEFAULT 'Not selected',
+        accent_color TEXT DEFAULT '',
+        icon TEXT DEFAULT 'default',
+        custom_icon_url TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      
+      CREATE TABLE IF NOT EXISTS sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        folder_id INTEGER NOT NULL,
+        title TEXT NOT NULL,
+        is_active BOOLEAN DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (folder_id) REFERENCES workspace_folders (id)
+      );
+
+      CREATE TABLE IF NOT EXISTS app_settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS chat_sessions (
+        session_id TEXT PRIMARY KEY,
+        title TEXT,
+        messages TEXT NOT NULL,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS deleted_workspaces (
+        project_path TEXT PRIMARY KEY,
+        deleted_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS archived_sessions (
+        session_id TEXT PRIMARY KEY,
+        archived_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS session_ui_state (
+        session_id TEXT PRIMARY KEY,
+        state TEXT NOT NULL DEFAULT '{}',
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS queued_messages (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        position INTEGER NOT NULL,
+        message TEXT NOT NULL DEFAULT '',
+        attachments TEXT NOT NULL DEFAULT '[]',
+        provider TEXT,
+        model_id TEXT,
+        thinking_level TEXT,
+        access_mode TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE INDEX IF NOT EXISTS idx_queued_messages_session ON queued_messages (session_id, position);
+
+      CREATE TABLE IF NOT EXISTS session_stream_state (
+        session_id TEXT PRIMARY KEY,
+        status TEXT NOT NULL,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+
+    const { migrateWorkspaceFolderColumns } = await import('@/shared/lib/workspace/schema-migrations');
+    await migrateWorkspaceFolderColumns(db);
+
+    await db.exec(`
+      CREATE TABLE IF NOT EXISTS files (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id INTEGER NOT NULL,
+        parent_id INTEGER,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL,
+        is_expanded BOOLEAN DEFAULT 0,
+        FOREIGN KEY (session_id) REFERENCES sessions (id),
+        FOREIGN KEY (parent_id) REFERENCES files (id)
+      );
+    `);
+
+    // Seed data based on MOCK mode
+    const folderCount = await db.get('SELECT COUNT(*) as count FROM workspace_folders');
+
+    if (isMockMode()) {
+      // MOCK=true: Seed demo workspace folders, sample chats, and session files
+      if (folderCount.count === 0) {
+        await db.exec(`
+          INSERT OR IGNORE INTO workspace_folders (id, name, is_expanded) VALUES 
+            (1, 'Chats', 1), 
+            (2, 'Workspace', 1), 
+            (3, 'drrealhandler', 1);
+        `);
+      }
+
+      // Ensure ompchamber, Workspace, drrealhandler folders exist
+      await db.run("INSERT OR IGNORE INTO workspace_folders (id, name, is_expanded) VALUES (1, 'ompchamber', 1)");
+      await db.run("INSERT OR IGNORE INTO workspace_folders (id, name, is_expanded) VALUES (2, 'Workspace', 1)");
+      await db.run("INSERT OR IGNORE INTO workspace_folders (id, name, is_expanded) VALUES (3, 'drrealhandler', 1)");
+      await db.run("UPDATE workspace_folders SET name = 'ompchamber' WHERE id = 1");
+
+      // Seed specific sessions matching screenshot
+      const existingChats = await db.all("SELECT * FROM sessions WHERE folder_id = 1");
+      const title1 = 'Cek stream subagent di ompweb';
+      const title2 = 'Fitur Diff Panel dan Git Status Files';
+      const title3 = 'Implementasi Saved State UI per Session ID';
+      const title4 = 'Review loading indicator, model & intent title';
+      const title5 = 'Status fitur streer dan queue';
+
+      if (existingChats.length === 0) {
+        await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [title1]);
+        await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [title2]);
+        await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 1)", [title3]);
+        await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [title4]);
+        await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [title5]);
+      } else {
+        await db.run("UPDATE sessions SET title = ? WHERE id = 1", [title1]);
+        await db.run("UPDATE sessions SET title = ? WHERE id = 2", [title2]);
+        await db.run("UPDATE sessions SET title = ? WHERE id = 3", [title3]);
+        await db.run("UPDATE sessions SET title = ? WHERE id = 4", [title4]);
+        await db.run("UPDATE sessions SET title = ? WHERE id = 5", [title5]);
+        await db.run("UPDATE sessions SET is_active = 0 WHERE folder_id = 1");
+        await db.run("UPDATE sessions SET is_active = 1 WHERE id = 3");
+      }
+
+      // Pre-seed sample sessions data
+      try {
+        const s1 = getSampleToolsSession();
+        await db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)', ['1', s1.title, JSON.stringify(s1.messages)]);
+        await db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)', [SAMPLE_TOOLS_SESSION_ID, s1.title, JSON.stringify(s1.messages)]);
+
+        const s2 = getSampleDialogueSession();
+        await db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)', ['2', s2.title, JSON.stringify(s2.messages)]);
+        await db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)', [SAMPLE_DIALOGUE_SESSION_ID, s2.title, JSON.stringify(s2.messages)]);
+
+        const s3 = getSampleDevicesSession();
+        await db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)', ['3', s3.title, JSON.stringify(s3.messages)]);
+        await db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)', [SAMPLE_DEVICES_SESSION_ID, s3.title, JSON.stringify(s3.messages)]);
+        const s3Row = await db.get("SELECT id FROM sessions WHERE folder_id = 1 AND title = ?", [title3]);
+        if (s3Row) {
+          await db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)', [String(s3Row.id), s3.title, JSON.stringify(s3.messages)]);
+        }
+      } catch (e) {
+        console.error('Failed to pre-seed sample sessions:', e);
+      }
+
+      const existingWorkspace = await db.all("SELECT * FROM sessions WHERE folder_id = 2");
+      if (existingWorkspace.length === 0) {
+        const workspaceTitles = [
+          'History Commit 2026-09-05 23:00',
+          'History Commit 2026-09-04 23:00',
+          'History Commit 2026-09-03 23:00',
+          'Error SMSC latency pada jns6.5 smppv2',
+          'Penyebab provider_submit_status=-1 di jns6.5 Smartfren SMPP',
+          'jns6.5 filevalidator error Mask Code di Release',
+          'Union query transaksi 202607 dan 202606'
+        ];
+        for (const t of workspaceTitles) {
+          await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (2, ?, 0)", [t]);
+        }
+      }
+
+      const existingDrreal = await db.all("SELECT * FROM sessions WHERE folder_id = 3");
+      if (existingDrreal.length === 0) {
+        const drrealTitles = [
+          'Buat branch feat/add-provider-err-telco-to-dr-smpp',
+          'Update wiki v1.5.0 & testing dari add-configurabel',
+          'Konfigurasi rute DR SMPP via config lookup',
+          'drrealhandler update v1.5.0',
+          'Gitlab wiki clone isi kosong'
+        ];
+        for (const t of drrealTitles) {
+          await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (3, ?, 0)", [t]);
+        }
+      }
+
+      // Add random sessions if we don't have enough to demonstrate the UI
+      const sessionCount = await db.get('SELECT COUNT(*) as count FROM sessions');
+      if (sessionCount.count < 15) {
+        const titles = [
+          'Fix header styling issue', 'Implement authentication flow', 'Setup CI/CD pipeline',
+          'Debug database connection', 'Update README.md docs', 'Refactor UI components'
+        ];
+        
+        for (let i = 1; i <= 3; i++) {
+          const numSessions = 3;
+          for (let j = 0; j < numSessions; j++) {
+            const title = titles[Math.floor(Math.random() * titles.length)] + ' #' + Math.floor(Math.random() * 1000);
+            await db.run('INSERT INTO sessions (folder_id, title, is_active) VALUES (?, ?, 0)', [i, title]);
+          }
+        }
+      }
+
+      // Seed random files for all sessions if files table is empty
+      const fileCount = await db.get('SELECT COUNT(*) as count FROM files');
+      if (fileCount.count === 0) {
+        const allSessions = await db.all('SELECT id FROM sessions');
+        for (const session of allSessions) {
+          // Create root folders
+          const res = await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, NULL, ?, ?, ?)', [session.id, 'src', 'folder', 1]);
+          const srcId = res.lastID;
+          
+          const res2 = await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, NULL, ?, ?, ?)', [session.id, 'components', 'folder', 0]);
+          const componentsId = res2.lastID;
+
+          // Create files in src
+          await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, ?, ?, ?, ?)', [session.id, srcId, 'index.tsx', 'file', 0]);
+          await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, ?, ?, ?, ?)', [session.id, srcId, 'App.tsx', 'file', 0]);
+          await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, ?, ?, ?, ?)', [session.id, srcId, 'styles.css', 'file', 0]);
+
+          // Create files in components
+          await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, ?, ?, ?, ?)', [session.id, componentsId, 'Button.tsx', 'file', 0]);
+          await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, ?, ?, ?, ?)', [session.id, componentsId, 'Header.tsx', 'file', 0]);
+          
+          // Some root files
+          await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, NULL, ?, ?, ?)', [session.id, 'package.json', 'file', 0]);
+          await db.run('INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, NULL, ?, ?, ?)', [session.id, 'README.md', 'file', 0]);
+        }
+      }
+    } else {
+      // MOCK=false (Real Data Mode): when SYNC_WORKSPACE is enabled (default),
+      // auto-create workspace folders from discovered omp projects. User-made
+      // folders are never deleted; only additive sync.
+      if (isWorkspaceSyncEnabled()) {
+        try {
+          await syncWorkspaceFoldersWithOmp(db);
+        } catch (err) {
+          // Discovery must never block app startup.
+          console.error('OMP workspace sync failed:', err);
+        }
+      }
+    }
+
+    const { migrateLegacyProjectSettings } = await import('@/shared/lib/workspace/project-settings-migration');
+    await migrateLegacyProjectSettings(db);
+
+    return db;
+  })();
+
+  return dbPromise;
+}
+
+/**
+ * Additive-only folder ↔ omp project sync: creates a workspace folder for
+ * every project discovered from ~/.omp/agent (folder name = lowercase
+ * basename, bound via project_path). It never modifies or deletes existing
+ * user data — no renames, no re-binding of unbound folders — and it skips
+ * projects the user has explicitly deleted (tombstoned in
+ * `deleted_workspaces`), so a deleted workspace stays deleted.
+ */
+async function syncWorkspaceFoldersWithOmp(db: DbClient): Promise<void> {
+  const { orderedOmpProjects, projectDisplayName } = await import('@/shared/lib/omp/session/sidebar');
+
+  const data = await loadOmpSidebarData();
+  const existing = await db.all('SELECT id, name, project_path FROM workspace_folders');
+  const tombstoned = await db.all('SELECT project_path FROM deleted_workspaces');
+
+  // Compare by canonical key, not raw string: tombstones may predate the
+  // directory (unresolved symlink spelling) while project.path is realpath'd.
+  const byPath = new Set(existing.map((r) => r.project_path).filter(Boolean).map(projectPathKey));
+  const usedNames = new Set(existing.map((r) => (r.name as string).toLowerCase()));
+  const deletedPaths = new Set(tombstoned.map((r) => projectPathKey(r.project_path as string)));
+
+  for (const project of orderedOmpProjects(data)) {
+    if (deletedPaths.has(projectPathKey(project.path))) continue;
+    if (byPath.has(projectPathKey(project.path))) continue;
+
+    const name = projectDisplayName(project);
+    let candidate = name;
+    let suffix = 2;
+    while (usedNames.has(candidate)) {
+      candidate = `${name}-${suffix++}`;
+    }
+    usedNames.add(candidate);
+    await db.run(
+      'INSERT INTO workspace_folders (name, is_expanded, project_path) VALUES (?, 1, ?)',
+      [candidate, project.path],
+    );
+  }
+}

package/src/server/index.ts

@@ -0,0 +1,19 @@
+import { Elysia } from 'elysia';
+import { apiRoutes } from '@/server/routes';
+import { ssrRoutes } from '@/server/plugins/ssr';
+
+const port = Number(Bun.env.PORT) || 3000;
+const host = Bun.env.HOST || 'localhost';
+
+const app = new Elysia().use(apiRoutes).use(ssrRoutes);
+
+await app.listen({ port, hostname: host });
+
+console.log(`[ompchamber] listening on http://${host}:${port}`);
+
+for (const signal of ['SIGTERM', 'SIGINT'] as const) {
+  process.once(signal, () => {
+    void app.stop();
+    process.exit(0);
+  });
+}

package/src/server/lib/browser/runtime.test.ts

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterAll, afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+import { findProjectRuntimeDir, isTcpPortLive } from '@/server/lib/browser/runtime';
+
+const tempRoots: string[] = [];
+const savedEnv: Record<string, string | undefined> = {};
+
+async function makeRuntimeDir(name: string): Promise<string> {
+  const dir = join(homedir(), Bun.env.PI_CONFIG_DIR!, 'run', 'daemons', name);
+  await fs.promises.mkdir(join(dir, 'omp.browser.headless.profile'), { recursive: true });
+  await Bun.write(join(dir, 'scope.json'), JSON.stringify({ projectDir: '/tmp/fake-project' }));
+  return dir;
+}
+
+async function writeDevToolsActivePort(runtimeDir: string, port: number, wsPath: string): Promise<void> {
+  await Bun.write(join(runtimeDir, 'omp.browser.headless.profile', 'DevToolsActivePort'), `${port}\n${wsPath}\n`);
+}
+
+beforeEach(async () => {
+  // getConfigRoot() = homedir()/getConfigDirName(), and os.homedir() is
+  // snapshotted at process start — a runtime HOME change is invisible.
+  // PI_CONFIG_DIR is a *relative name* joined onto homedir, so isolate via a
+  // uniquely named config dir inside the real home.
+  savedEnv.PI_CONFIG_DIR = Bun.env.PI_CONFIG_DIR;
+  savedEnv.XDG_STATE_HOME = Bun.env.XDG_STATE_HOME;
+  const name = `.omp-browser-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  tempRoots.push(join(homedir(), name));
+  await fs.promises.mkdir(join(homedir(), name, 'run', 'daemons'), { recursive: true });
+  Bun.env.PI_CONFIG_DIR = name;
+  Bun.env.XDG_STATE_HOME = '';
+});
+
+afterEach(() => {
+  if (savedEnv.PI_CONFIG_DIR === undefined) delete Bun.env.PI_CONFIG_DIR;
+  else Bun.env.PI_CONFIG_DIR = savedEnv.PI_CONFIG_DIR;
+  if (savedEnv.XDG_STATE_HOME === undefined) delete Bun.env.XDG_STATE_HOME;
+  else Bun.env.XDG_STATE_HOME = savedEnv.XDG_STATE_HOME;
+});
+
+afterAll(() => {
+  for (const root of tempRoots) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe('isTcpPortLive', () => {
+  test('true for a listening port', async () => {
+    const server = Bun.listen({ hostname: '127.0.0.1', port: 0, socket: { data() {}, close() {}, error() {} } });
+    try {
+      expect(await isTcpPortLive(server.port)).toBe(true);
+    } finally {
+      server.stop(true);
+    }
+  });
+
+  test('false for a closed port', async () => {
+    // Grab a free port, then release it so nothing listens there.
+    const server = Bun.listen({ hostname: '127.0.0.1', port: 0, socket: { data() {}, close() {}, error() {} } });
+    const port = server.port;
+    server.stop(true);
+    expect(await isTcpPortLive(port)).toBe(false);
+  });
+});
+
+describe('findProjectRuntimeDir', () => {
+  test('returns endpoint for a live daemon', async () => {
+    const runtimeDir = await makeRuntimeDir('live');
+    const server = Bun.listen({ hostname: '127.0.0.1', port: 0, socket: { data() {}, close() {}, error() {} } });
+    try {
+      await writeDevToolsActivePort(runtimeDir, server.port, '/devtools/browser/live-id');
+      const found = await findProjectRuntimeDir('/tmp/fake-project');
+      expect(found).not.toBeNull();
+      expect(found?.port).toBe(server.port);
+      expect(found?.wsUrl).toBe(`ws://127.0.0.1:${server.port}/devtools/browser/live-id`);
+      expect(found?.daemonName).toBe('omp.browser.headless');
+    } finally {
+      server.stop(true);
+    }
+  });
+
+  test('rejects a stale DevToolsActivePort whose port is dead', async () => {
+    const runtimeDir = await makeRuntimeDir('stale');
+    const server = Bun.listen({ hostname: '127.0.0.1', port: 0, socket: { data() {}, close() {}, error() {} } });
+    const port = server.port;
+    server.stop(true);
+    await writeDevToolsActivePort(runtimeDir, port, '/devtools/browser/dead-id');
+    expect(await findProjectRuntimeDir('/tmp/fake-project')).toBeNull();
+  });
+
+  test('returns null for an unknown project', async () => {
+    await makeRuntimeDir('other');
+    const server = Bun.listen({ hostname: '127.0.0.1', port: 0, socket: { data() {}, close() {}, error() {} } });
+    try {
+      await writeDevToolsActivePort(
+        join(homedir(), Bun.env.PI_CONFIG_DIR!, 'run', 'daemons', 'other'),
+        server.port,
+        '/devtools/browser/other',
+      );
+      expect(await findProjectRuntimeDir('/tmp/never-registered')).toBeNull();
+    } finally {
+      server.stop(true);
+    }
+  });
+});

package/src/server/lib/browser/runtime.ts

@@ -0,0 +1,160 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Discovery of omp's project-shared Chromium runtime state.
+ *
+ * For a project directory omp runs one broker-supervised browser daemon under
+ * `~/.omp/run/daemons/<hash>/` (or `$XDG_STATE_HOME/omp/run/daemons/<hash>/`).
+ * `scope.json` maps the runtime dir back to its project; `<daemon>.profile/
+ * DevToolsActivePort` carries the live CDP port and WebSocket path; and
+ * `<daemon>.targets/<ompPid>.json` lists the page target ids that the omp
+ * process with that pid opened. This module only reads that state — it never
+ * starts, mutates, or closes the browser.
+ */
+
+import { readdir, realpath } from 'fs/promises';
+import * as path from 'path';
+import { getConfigRoot } from '@/server/lib/omp/core/paths';
+
+/** Candidate daemon names, in the order the viewer prefers them. */
+const DAEMON_NAMES = ['omp.browser.headless', 'omp.browser.headed'] as const;
+
+/** File Chromium writes next to its profile with the live CDP endpoint. */
+const DEVTOOLS_ACTIVE_PORT = 'DevToolsActivePort';
+
+interface ProjectRuntime {
+  runtimeDir: string;
+  daemonName: string;
+  /** CDP TCP port (DevToolsActivePort line 1). */
+  port: number;
+  /** Browser-level CDP WebSocket URL: ws://127.0.0.1:<port><wsPath>. */
+  wsUrl: string;
+}
+
+/** Resolve symlinks when possible; fall back to a plain absolute path. */
+async function canonicalPath(value: string): Promise<string> {
+  try {
+    return await realpath(value);
+  } catch {
+    return path.resolve(value);
+  }
+}
+
+/** Runtime-dir roots to scan: the config root always, XDG state when set. */
+function candidateRoots(): string[] {
+  const roots = [path.join(getConfigRoot(), 'run', 'daemons')];
+  const stateHome = Bun.env.XDG_STATE_HOME?.trim();
+  if (stateHome) roots.push(path.join(stateHome, 'omp', 'run', 'daemons'));
+  return roots;
+}
+
+/**
+ * TCP probe with a short timeout — Chromium writes DevToolsActivePort before
+ * it starts listening, and the file survives a crash, so the port must be
+ * checked before the endpoint is trusted.
+ */
+export async function isTcpPortLive(port: number, host = '127.0.0.1', timeoutMs = 750): Promise<boolean> {
+  const socket = Bun.connect({
+    hostname: host,
+    port,
+    socket: {
+      data() {},
+      close() {},
+      error() {},
+    },
+  });
+  // Bun.connect resolves to a TCPSocket on success and rejects with
+  // "Failed to connect" when nothing listens — no timeout race needed for the
+  // loopback case, but guard against a hung connect anyway.
+  const opened = await Promise.race([
+    socket.then(() => true, () => false),
+    new Promise<boolean>((resolve) => setTimeout(() => resolve(false), timeoutMs)),
+  ]);
+  if (opened) await socket.then((s) => s.end());
+  return opened;
+}
+
+/** Read a daemon's live CDP endpoint from its DevToolsActivePort file. */
+async function readDaemonEndpoint(
+  runtimeDir: string,
+): Promise<{ daemonName: string; port: number; wsUrl: string } | null> {
+  for (const daemonName of DAEMON_NAMES) {
+    const file = path.join(runtimeDir, `${daemonName}.profile`, DEVTOOLS_ACTIVE_PORT);
+    let raw: string;
+    try {
+      raw = await Bun.file(file).text();
+    } catch {
+      continue;
+    }
+    const [portLine = '', pathLine = ''] = raw.split('\n');
+    const port = Number.parseInt(portLine.trim(), 10);
+    const wsPath = pathLine.trim();
+    if (!Number.isInteger(port) || port <= 0 || !wsPath) continue;
+    // Stale file: Chromium crashed or was killed after writing it. Treat the
+    // daemon as gone so callers report `browser-offline` instead of hanging.
+    if (!(await isTcpPortLive(port))) continue;
+    return { daemonName, port, wsUrl: `ws://127.0.0.1:${port}${wsPath}` };
+  }
+  return null;
+}
+
+/**
+ * Find the runtime dir whose `scope.json` points at `cwd` and return its live
+ * daemon endpoint, or null when the project has no running shared browser.
+ */
+export async function findProjectRuntimeDir(cwd: string): Promise<ProjectRuntime | null> {
+  if (!cwd) return null;
+  const target = await canonicalPath(cwd);
+  for (const root of candidateRoots()) {
+    let entries: string[];
+    try {
+      entries = await readdir(root);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const runtimeDir = path.join(root, entry);
+      let scopeRaw: string;
+      try {
+        scopeRaw = await Bun.file(path.join(runtimeDir, 'scope.json')).text();
+      } catch {
+        continue;
+      }
+      let projectDir: unknown;
+      try {
+        projectDir = (JSON.parse(scopeRaw) as { projectDir?: unknown }).projectDir;
+      } catch {
+        continue;
+      }
+      if (typeof projectDir !== 'string' || projectDir.length === 0) continue;
+      if ((await canonicalPath(projectDir)) !== target) continue;
+      const endpoint = await readDaemonEndpoint(runtimeDir);
+      if (endpoint) return { runtimeDir, ...endpoint };
+    }
+  }
+  return null;
+}
+
+/**
+ * Page target ids opened by the omp process with `pid`, in creation order.
+ * Missing or malformed registry files degrade to an empty list.
+ */
+export async function readOwnedTargetIds(
+  runtimeDir: string,
+  daemonName: string,
+  pid: number,
+): Promise<string[]> {
+  try {
+    const raw = await Bun.file(path.join(runtimeDir, `${daemonName}.targets`, `${pid}.json`)).text();
+    const parsed = JSON.parse(raw) as { pid?: unknown; targets?: unknown };
+    // Guard against a recycled pid inheriting a dead process's registry file.
+    if (parsed.pid !== pid) return [];
+    if (!Array.isArray(parsed.targets)) return [];
+    return parsed.targets.filter((target): target is string => typeof target === 'string');
+  } catch {
+    return [];
+  }
+}