ompchamber 1.0.0 → 1.2.0

package/src/server/lib/db/schema.ts

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Schema bootstrap for the chamber database: the `CREATE TABLE IF NOT EXISTS`
+ * block plus the in-place migrations that repair schemas written by older
+ * installs. Split out of `@/server/db.server` so the connection lifecycle
+ * there stays readable; the order below is load-bearing — the migrations run
+ * between the two DDL blocks, after the tables they touch exist.
+ */
+
+import type { DbClient } from '@/server/lib/db/client';
+import { migrateQueueTableFk } from '@/server/lib/queue/schema-migration.server';
+import { ensureBtwSchema } from '@/server/lib/btw/schema.server';
+import { migrateWorkspaceFolderColumns } from '@/shared/lib/workspace/schema-migrations';
+
+export async function initSchema(db: DbClient): Promise<void> {
+  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
+    );
+  `);
+
+  await migrateWorkspaceFolderColumns(db);
+  // Installs older `queued_messages` schemas carry an invalid FK (see the
+  // migration module); rebuild once so real-session queue inserts work.
+  await migrateQueueTableFk(db);
+  // Side-question tables live in their own module (see schema.server.ts).
+  await ensureBtwSchema(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)
+    );
+  `);
+}

package/src/server/lib/db/seed.ts

@@ -0,0 +1,160 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `MOCK=true` database seeding: demo workspace folders, screenshot-matching
+ * chat sessions, the bundled sample transcripts and a synthetic file tree.
+ * Split out of `@/server/db.server` so the connection lifecycle there stays
+ * readable. Runs only in mock mode and only on a database that has not been
+ * seeded before — every branch is idempotent, so a restart re-asserts the
+ * demo rows instead of duplicating them.
+ */
+
+import type { DbClient } from '@/server/lib/db/client';
+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';
+
+const INSERT_CHAT_SESSION =
+  'INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)';
+
+export async function seedMockData(db: DbClient): Promise<void> {
+  const folderCount = await db.get('SELECT COUNT(*) as count FROM workspace_folders');
+
+  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);
+    `);
+  }
+
+  await seedChatSessions(db);
+  await seedWorkspaceSessions(db, 2, [
+    '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',
+  ]);
+  await seedWorkspaceSessions(db, 3, [
+    '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',
+  ]);
+
+  await seedFillerSessions(db);
+  await seedSessionFiles(db);
+}
+
+/** Demo folders 1-3 and the five sessions the sidebar screenshots show. */
+async function seedChatSessions(db: DbClient): Promise<void> {
+  // 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");
+
+  const existingChats = await db.all("SELECT * FROM sessions WHERE folder_id = 1");
+  const titles = [
+    'Cek stream subagent di ompweb',
+    'Fitur Diff Panel dan Git Status Files',
+    'Implementasi Saved State UI per Session ID',
+    'Review loading indicator, model & intent title',
+    'Status fitur streer dan queue',
+  ];
+
+  if (existingChats.length === 0) {
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [titles[0]]);
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [titles[1]]);
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 1)", [titles[2]]);
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [titles[3]]);
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [titles[4]]);
+  } else {
+    await db.run("UPDATE sessions SET title = ? WHERE id = 1", [titles[0]]);
+    await db.run("UPDATE sessions SET title = ? WHERE id = 2", [titles[1]]);
+    await db.run("UPDATE sessions SET title = ? WHERE id = 3", [titles[2]]);
+    await db.run("UPDATE sessions SET title = ? WHERE id = 4", [titles[3]]);
+    await db.run("UPDATE sessions SET title = ? WHERE id = 5", [titles[4]]);
+    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_CHAT_SESSION, ['1', s1.title, JSON.stringify(s1.messages)]);
+    await db.run(INSERT_CHAT_SESSION, [SAMPLE_TOOLS_SESSION_ID, s1.title, JSON.stringify(s1.messages)]);
+
+    const s2 = getSampleDialogueSession();
+    await db.run(INSERT_CHAT_SESSION, ['2', s2.title, JSON.stringify(s2.messages)]);
+    await db.run(INSERT_CHAT_SESSION, [SAMPLE_DIALOGUE_SESSION_ID, s2.title, JSON.stringify(s2.messages)]);
+
+    const s3 = getSampleDevicesSession();
+    await db.run(INSERT_CHAT_SESSION, ['3', s3.title, JSON.stringify(s3.messages)]);
+    await db.run(INSERT_CHAT_SESSION, [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 = ?", [titles[2]]);
+    if (s3Row) {
+      await db.run(INSERT_CHAT_SESSION, [String(s3Row.id), s3.title, JSON.stringify(s3.messages)]);
+    }
+  } catch (e) {
+    console.error('Failed to pre-seed sample sessions:', e);
+  }
+}
+
+/** Add the given session titles to a folder when it has none yet. */
+async function seedWorkspaceSessions(db: DbClient, folderId: number, titles: string[]): Promise<void> {
+  const existing = await db.all('SELECT * FROM sessions WHERE folder_id = ?', [folderId]);
+  if (existing.length > 0) return;
+  for (const title of titles) {
+    await db.run('INSERT INTO sessions (folder_id, title, is_active) VALUES (?, ?, 0)', [folderId, title]);
+  }
+}
+
+/** Add random sessions if we don't have enough to demonstrate the UI. */
+async function seedFillerSessions(db: DbClient): Promise<void> {
+  const sessionCount = await db.get('SELECT COUNT(*) as count FROM sessions');
+  if (sessionCount.count >= 15) return;
+
+  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++) {
+    for (let j = 0; j < 3; 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 a demo file tree for every session when the files table is empty. */
+async function seedSessionFiles(db: DbClient): Promise<void> {
+  const fileCount = await db.get('SELECT COUNT(*) as count FROM files');
+  if (fileCount.count !== 0) return;
+
+  const insertFile =
+    'INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, ?, ?, ?, ?)';
+  const allSessions = await db.all('SELECT id FROM sessions');
+  for (const session of allSessions) {
+    const src = await db.run(insertFile, [session.id, null, 'src', 'folder', 1]);
+    const components = await db.run(insertFile, [session.id, null, 'components', 'folder', 0]);
+
+    await db.run(insertFile, [session.id, src.lastID, 'index.tsx', 'file', 0]);
+    await db.run(insertFile, [session.id, src.lastID, 'App.tsx', 'file', 0]);
+    await db.run(insertFile, [session.id, src.lastID, 'styles.css', 'file', 0]);
+
+    await db.run(insertFile, [session.id, components.lastID, 'Button.tsx', 'file', 0]);
+    await db.run(insertFile, [session.id, components.lastID, 'Header.tsx', 'file', 0]);
+
+    await db.run(insertFile, [session.id, null, 'package.json', 'file', 0]);
+    await db.run(insertFile, [session.id, null, 'README.md', 'file', 0]);
+  }
+}

package/src/server/lib/db/workspace-sync.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * 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.
+ */
+
+import type { DbClient } from '@/server/lib/db/client';
+import { projectPathKey } from '@/server/lib/omp/core/paths';
+import { loadOmpSidebarData } from '@/server/lib/omp/session/reader';
+import { orderedOmpProjects, projectDisplayName } from '@/shared/lib/omp/session/sidebar';
+
+/** SYNC_WORKSPACE env flag (default true when unset). When enabled in real
+ *  mode, workspace folders are auto-created from discovered omp projects. */
+function isWorkspaceSyncEnabled(): boolean {
+  const raw = (Bun.env.SYNC_WORKSPACE || '').trim().toLowerCase();
+  if (raw === '') return true;
+  return raw !== 'false' && raw !== '0' && raw !== 'off' && raw !== 'no';
+}
+
+/**
+ * Real-data workspace bootstrap: sync discovered omp projects into
+ * `workspace_folders` when SYNC_WORKSPACE allows it. Discovery must never
+ * block app startup, so a failure is logged rather than thrown.
+ */
+export async function syncWorkspaceFoldersFromDiscovery(db: DbClient): Promise<void> {
+  if (!isWorkspaceSyncEnabled()) return;
+  try {
+    await syncWorkspaceFoldersWithOmp(db);
+  } catch (err) {
+    // Discovery must never block app startup.
+    console.error('OMP workspace sync failed:', err);
+  }
+}
+
+async function syncWorkspaceFoldersWithOmp(db: DbClient): Promise<void> {
+  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/lib/fs/root.ts

@@ -28,6 +28,43 @@ export function resolveWithinRoot(root: string, rel: string): string | null {
   return isWithinRoot(root, target) ? target : null;
 }
 
+/**
+ * Resolve a file a drop or a link pointed at, which may live outside the active
+ * root.
+ *
+ * A dropped file is always named by an absolute path or URL — a file manager
+ * cannot know which workspace the page considers active — so
+ * {@link resolveWithinRoot} rejects exactly the references the composer needs.
+ * The allow-list that governs a client-supplied `root` governs these too: the
+ * app root, a path beneath it, or an exact registered workspace project path.
+ * Anything else resolves to null, so an arbitrary path from a page still cannot
+ * read the filesystem.
+ */
+export async function resolveReferencedPath(rawPath: string): Promise<string | null> {
+  const candidate = rawPath.trim();
+  if (!candidate) return null;
+
+  const resolved = path.resolve(candidate);
+  if (resolved === APP_ROOT || resolved.startsWith(APP_ROOT + path.sep)) {
+    return (await pathExists(resolved)) ? resolved : null;
+  }
+
+  try {
+    const db = await getDb();
+    const rows = (await db.all(
+      'SELECT project_path FROM workspace_folders WHERE project_path IS NOT NULL'
+    )) as { project_path: string }[];
+    for (const row of rows) {
+      const workspaceRoot = path.resolve(row.project_path);
+      if (isWithinRoot(workspaceRoot, resolved) && (await pathExists(resolved))) return resolved;
+    }
+  } catch {
+    // Database unavailable — nothing outside the app root can be verified.
+  }
+
+  return null;
+}
+
 /**
  * Default browsing root when no session-bound project is active. Mock/demo
  * mode browses the bundled `examples` tree; real mode browses the app root.

package/src/server/lib/models/preferences.server.ts

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Persistence for the user's favorite + last-used models.
+ *
+ * Lives apart from the model registry because a favorite is NOT a property of
+ * omp's registry: the catalog the route used to mutate (`omp_models_catalog`)
+ * is a MOCK-only demo list that real mode never reads back, so a star clicked
+ * on a real install was written into a dead row and lost on the next render.
+ * This store is the single source for both modes.
+ *
+ * Keys are composite (`provider:id`) — see `modelKey` — and stale ones are
+ * dropped on read, so a model removed from models.yml cannot hold a slot in the
+ * five-entry recent rail forever.
+ */
+
+import { getDb } from '@/server/db.server';
+import { readSettingsJson, writeSettingsJson } from '@/server/lib/db/settings-store';
+import { isMockMode } from '@/server/mock.server';
+import { INITIAL_MODELS_CATALOG } from '@/client/data/models/catalog';
+import {
+  EMPTY_MODEL_PREFERENCES,
+  RECENT_MODELS_LIMIT,
+  filterKnownKeys,
+  readModelPreferences,
+  recordRecentKey,
+  toggleFavoriteKey,
+} from '@/shared/lib/models/preferences';
+import { modelKey } from '@/shared/lib/models/identity';
+import type { ModelPreferences } from '@/shared/types';
+
+const MODEL_PREFERENCES_KEY = 'omp_model_preferences';
+
+/**
+ * Demo favorites/recents so a `MOCK=true` chamber still opens with the rails
+ * the shipped catalog advertises. Seeded on first read only — from then on the
+ * row is the user's, and the catalog's own flags are ignored.
+ */
+function mockSeedPreferences(): ModelPreferences {
+  return {
+    favorites: INITIAL_MODELS_CATALOG.filter((model) => model.isFavorite).map(modelKey),
+    recentKeys: INITIAL_MODELS_CATALOG.filter((model) => model.isRecent).map(modelKey).slice(0, RECENT_MODELS_LIMIT),
+  };
+}
+
+async function readStoredPreferences(): Promise<ModelPreferences> {
+  const db = await getDb();
+  const raw = await readSettingsJson<unknown>(db, MODEL_PREFERENCES_KEY, null);
+  if (raw === null) return isMockMode() ? mockSeedPreferences() : EMPTY_MODEL_PREFERENCES;
+  return readModelPreferences(raw);
+}
+
+/**
+ * Preferences narrowed to the models the registry actually serves right now —
+ * the shape every loader response carries.
+ */
+export async function readModelPreferencesFor(
+  models: readonly { provider: string; id: string }[],
+): Promise<ModelPreferences> {
+  try {
+    const known = new Set(models.map(modelKey));
+    const stored = await readStoredPreferences();
+    return {
+      favorites: filterKnownKeys(stored.favorites, known),
+      recentKeys: filterKnownKeys(stored.recentKeys, known),
+    };
+  } catch {
+    return EMPTY_MODEL_PREFERENCES;
+  }
+}
+
+/**
+ * Persist a mutation with the stale keys already removed, so a key the registry
+ * dropped cannot sit in the row holding one of the five recent slots. Reading
+ * prunes for display only — without this the slot stayed occupied across
+ * reloads and the RECENT rail silently showed four models instead of five.
+ */
+async function writePreferences(known: ReadonlySet<string>, mutate: (current: ModelPreferences) => ModelPreferences): Promise<ModelPreferences> {
+  const current = await readStoredPreferences();
+  const next = mutate({
+    favorites: filterKnownKeys(current.favorites, known),
+    recentKeys: filterKnownKeys(current.recentKeys, known),
+  });
+  const db = await getDb();
+  await writeSettingsJson(db, MODEL_PREFERENCES_KEY, next);
+  return next;
+}
+
+/** Flip one model's favorite flag, returning the full persisted pair. */
+export async function toggleFavoritePreference(key: string, known: ReadonlySet<string>): Promise<ModelPreferences> {
+  return writePreferences(known, (current) => ({
+    ...current,
+    favorites: toggleFavoriteKey(current.favorites, key),
+  }));
+}
+
+/**
+ * Record a model as last used. Called from the selection action rather than
+ * from a separate endpoint: "the user picked this model" is one event, and a
+ * second request would only add a way for the two to disagree.
+ */
+export async function recordRecentPreference(key: string, known: ReadonlySet<string>): Promise<ModelPreferences> {
+  return writePreferences(known, (current) => ({
+    ...current,
+    recentKeys: recordRecentKey(current.recentKeys, key),
+  }));
+}