ompchamber 0.8.0 → 1.1.0

package/src/server/routes/sessions/session.ts

@@ -2,15 +2,12 @@ import { json } from '@/server/lib/remix-compat';
 import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
 import { methodNotAllowed } from '@/server/lib/route-adapter';
 import { getDb } from '@/server/db.server';
-import { withTransaction } from '@/shared/lib/db/transaction.server';
-import { isApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { markStreamSeen } from '@/shared/lib/omp/session/stream-state.server';
 import { isMockMode } from '@/server/mock.server';
 import { getRpcSession } from '@/server/lib/omp/rpc/manager';
 import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
 import { resolveSessionFileOr404 } from '@/server/lib/omp/session/locator';
 import { setSessionTitle } from '@/server/lib/omp/session/title-slot';
-import type { QueuedMessage, QueuedMessageModel } from '@/shared/types/chat';
 
 /**
  * POST /api/sessions/:sessionId/archive — toggle archive state for a session.
@@ -46,134 +43,6 @@ export async function archiveSession({ request, params }: ActionFunctionArgs) {
   return json({ success: true, sessionId, archived });
 }
 
-/**
- * SQLite-backed queue for a session (`queued_messages` table). Rows carry a
- * model snapshot (provider, model_id, thinking_level, access_mode) so the
- * auto-delivery replays the exact settings the item was queued with, instead
- * of whatever the session runs with at delivery time.
- */
-
-interface QueueRow {
-  id: string;
-  session_id: string;
-  position: number;
-  message: string;
-  attachments: string;
-  provider: string | null;
-  model_id: string | null;
-  thinking_level: string | null;
-  access_mode: string | null;
-}
-
-function rowToQueuedMessage(row: QueueRow): QueuedMessage {
-  let attachments: unknown = [];
-  try {
-    attachments = JSON.parse(row.attachments);
-  } catch {
-    attachments = [];
-  }
-  const model: QueuedMessageModel | null =
-    row.provider && row.model_id
-      ? {
-          provider: row.provider,
-          modelId: row.model_id,
-          thinkingLevel: row.thinking_level ?? 'auto',
-          accessMode: isApprovalMode(row.access_mode) ? row.access_mode : 'always-ask',
-        }
-      : null;
-  return {
-    id: row.id,
-    text: row.message,
-    attachments: Array.isArray(attachments) ? (attachments as QueuedMessage['attachments']) : [],
-    model,
-  };
-}
-
-/** GET — the session's queued follow-ups in delivery order. */
-export async function getQueue({ params }: LoaderFunctionArgs) {
-  const { sessionId } = params;
-  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
-
-  const db = await getDb();
-  const rows = (await db.all(
-    'SELECT * FROM queued_messages WHERE session_id = ? ORDER BY position ASC',
-    [sessionId],
-  )) as QueueRow[];
-  return json({ queue: rows.map(rowToQueuedMessage) });
-}
-
-interface QueuePayload {
-  id?: unknown;
-  text?: unknown;
-  attachments?: unknown;
-  model?: unknown;
-}
-
-function normalizeModel(raw: unknown): QueuedMessageModel | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const m = raw as Record<string, unknown>;
-  if (typeof m.provider !== 'string' || typeof m.modelId !== 'string') return null;
-  return {
-    provider: m.provider,
-    modelId: m.modelId,
-    thinkingLevel: typeof m.thinkingLevel === 'string' ? m.thinkingLevel : 'auto',
-    accessMode: isApprovalMode(m.accessMode) ? m.accessMode : 'always-ask',
-  };
-}
-
-/**
- * PUT — replace the session's whole queue with the posted list (the client
- * queue panel is the source of truth: reorder, edit, delete all ship the full
- * remaining list back). Ids are preserved so in-flight mirrors and React keys
- * stay stable.
- */
-export async function putQueue({ request, params }: ActionFunctionArgs) {
-  const { sessionId } = params;
-  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
-  if (request.method !== 'PUT') {
-    return methodNotAllowed({ request, params });
-  }
-
-  const body = (await request.json().catch(() => null)) as { queue?: unknown } | null;
-  if (!body || !Array.isArray(body.queue)) {
-    return json({ error: 'Invalid body: expected { queue: QueuedMessage[] }' }, { status: 400 });
-  }
-
-  const db = await getDb();
-  const items = body.queue
-    .filter((raw): raw is QueuePayload => Boolean(raw) && typeof raw === 'object')
-    .map((raw, index) => ({
-      id: typeof raw.id === 'string' && raw.id ? raw.id : `queue-${Date.now()}-${index}`,
-      text: typeof raw.text === 'string' ? raw.text : '',
-      attachments: Array.isArray(raw.attachments) ? JSON.stringify(raw.attachments) : '[]',
-      model: normalizeModel(raw.model),
-      position: index,
-    }));
-
-  withTransaction(db, () => {
-    db.raw.run('DELETE FROM queued_messages WHERE session_id = ?', [sessionId]);
-    const insert = db.raw.query(
-      `INSERT INTO queued_messages (id, session_id, position, message, attachments, provider, model_id, thinking_level, access_mode)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    );
-    for (const item of items) {
-      insert.run(
-        item.id,
-        sessionId,
-        item.position,
-        item.text,
-        item.attachments,
-        item.model?.provider ?? null,
-        item.model?.modelId ?? null,
-        item.model?.thinkingLevel ?? null,
-        item.model?.accessMode ?? null,
-      );
-    }
-  });
-
-  return json({ success: true });
-}
-
 const MAX_SESSION_NAME_LENGTH = 200;
 
 /**
@@ -316,7 +185,7 @@ export async function putSessionState({ request, params }: ActionFunctionArgs) {
 
 /**
  * POST /api/sessions/:sessionId/stream-seen — acknowledge the session's
- * one-shot stream badge (`finish` / `abort` / `error`). Called when the
+ * one-shot stream badge (`finish` / `abort`). Called when the
  * session is opened; deletes the terminal row so the check shows exactly
  * once. A `stream` row (live run) is never deleted — a client acking from a
  * stale status map must not kill the spinner of a running session.

package/src/server/routes/settings/commands.ts

@@ -5,6 +5,7 @@ import { getDb } from '@/server/db.server';
 import { DEFAULT_COMMANDS_LIST } from '@/client/data/settings/command';
 import { isMockMode } from '@/server/mock.server';
 import type { CommandItem } from '@/shared/types';
+import { isRecord } from '@/shared/lib/util/guards';
 import { createSettingsListStore } from '@/server/lib/db/settings-store';
 import { runUtilityCommand } from '@/server/lib/omp/rpc/utility';
 
@@ -16,27 +17,67 @@ const commandsStore = createSettingsListStore<CommandItem>({
   plural: 'commands',
 });
 
-/** Read live agent commands (skill/custom/extension/file sources) via RPC. */
+/** Command sources the chamber surfaces in the composer (mcp_prompt is not user-typable). */
+const AGENT_COMMAND_SOURCES: Record<string, true> = {
+  builtin: true,
+  skill: true,
+  custom: true,
+  extension: true,
+  file: true,
+};
+
+/**
+ * Live slash commands from the agent's `get_available_commands`, mapped into
+ * the chamber's CommandItem. Aliases, subcommands and the argument hint ride
+ * along: they are what the composer's `/` popup needs to behave like omp's own
+ * editor (`/models` completing to the alias, `/fast ` offering on|off|status).
+ * Anything malformed is dropped rather than trusted.
+ */
+function toLiveCommandItem(value: unknown): CommandItem | null {
+  if (!isRecord(value)) return null;
+  const name = typeof value.name === 'string' ? value.name : '';
+  if (!name) return null;
+  if (typeof value.source !== 'string' || !AGENT_COMMAND_SOURCES[value.source]) return null;
+
+  const aliases = Array.isArray(value.aliases)
+    ? value.aliases.filter((alias): alias is string => typeof alias === 'string' && alias.length > 0)
+    : [];
+
+  const hint = isRecord(value.input) && typeof value.input.hint === 'string' ? value.input.hint : undefined;
+
+  const subcommands = Array.isArray(value.subcommands)
+    ? value.subcommands.flatMap((sub) => {
+        if (!isRecord(sub) || typeof sub.name !== 'string' || !sub.name) return [];
+        return [{
+          name: sub.name,
+          ...(typeof sub.description === 'string' ? { description: sub.description } : {}),
+          ...(typeof sub.usage === 'string' ? { usage: sub.usage } : {}),
+        }];
+      })
+    : [];
+
+  return {
+    id: `omp-live-${name}`,
+    name,
+    description: typeof value.description === 'string' ? value.description : '',
+    scope: 'user',
+    template: `/${name}`,
+    isBuiltIn: true,
+    ...(aliases.length ? { aliases } : {}),
+    ...(subcommands.length ? { subcommands } : {}),
+    ...(hint ? { inputHint: hint } : {}),
+  };
+}
+
+/** Read live agent commands (builtin/skill/custom/extension/file sources) via RPC. */
 async function loadAgentCommands(): Promise<CommandItem[]> {
   try {
     const data = await runUtilityCommand<{ commands?: unknown }>({ type: 'get_available_commands' }, 30_000);
-    const available = Array.isArray(data.commands) ? data.commands : [];
-    const agentSources = new Set(['skill', 'custom', 'extension', 'file']);
-    return available
-      .filter((c) => agentSources.has((c as { source?: string })?.source ?? ''))
-      .map((c) => {
-        const command = c as { name?: string; description?: string; source?: string };
-        const name = typeof command.name === 'string' ? command.name : '';
-        return {
-          id: `omp-live-${name}`,
-          name,
-          description: typeof command.description === 'string' ? command.description : '',
-          scope: 'user' as const,
-          template: `/${name}`,
-          isBuiltIn: true,
-        };
-      })
-      .filter((c) => c.name.length > 0);
+    if (!Array.isArray(data.commands)) return [];
+    return data.commands.flatMap((command) => {
+      const item = toLiveCommandItem(command);
+      return item ? [item] : [];
+    });
   } catch {
     return [];
   }

package/src/server/routes/terminal/index.ts

@@ -1,8 +1,8 @@
 import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
 import * as terminalRun from '@/server/routes/terminal/run';
-import * as terminalStream from '@/server/routes/terminal/stream';
+import * as terminalSessions from '@/server/routes/terminal/sessions';
 
 export const terminalBindings: HandlerBinding[] = [
   ...bindingsFor(terminalRun, '/api/terminal/run'),
-  ...bindingsFor(terminalStream, '/api/terminal/stream'),
+  ...bindingsFor(terminalSessions, '/api/terminal/sessions'),
 ];

package/src/server/routes/terminal/run.ts

@@ -1,10 +1,15 @@
-import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
-import path from 'path';
+import { json, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
 import { runShell } from '@/server/lib/fs/shell';
 import { resolveRoot } from '@/server/lib/fs/root';
 import { scopeToRepo } from '@/server/lib/fs/repo-scope';
-import { matchCdCommand, resolveCdTarget, resolveTerminalCwd } from '@/server/lib/fs/terminal-cwd';
 
+/**
+ * Launch context for the terminal header: which directory the shell opens in,
+ * the git branch checked out there, and the runtime versions.
+ *
+ * Command execution used to live here as a one-shot `action`; the PTY socket
+ * replaced it, so only the display half remains.
+ */
 export async function loader({ request }: LoaderFunctionArgs) {
   const url = new URL(request.url);
   const rootDir = await resolveRoot(url.searchParams.get('root'), process.cwd());
@@ -36,100 +41,3 @@ export async function loader({ request }: LoaderFunctionArgs) {
     relativePath: '.',
   });
 }
-
-export async function action({ request }: ActionFunctionArgs) {
-  let command = '';
-  let requestedCwd = '';
-  let requestedRoot = '';
-  let requestedRepo = '';
-
-  const contentType = request.headers.get('content-type') || '';
-  if (contentType.includes('application/json')) {
-    const body = await request.json();
-    command = (body.command || '').trim();
-    requestedCwd = (body.cwd || '').trim();
-    requestedRoot = (body.root || '').trim();
-    requestedRepo = (body.repo || '').trim();
-  } else {
-    const formData = await request.formData();
-    command = ((formData.get('command') as string) || '').trim();
-    requestedCwd = ((formData.get('cwd') as string) || '').trim();
-    requestedRoot = ((formData.get('root') as string) || '').trim();
-    requestedRepo = ((formData.get('repo') as string) || '').trim();
-  }
-
-  const baseDir = await resolveRoot(requestedRoot, process.cwd());
-  const rootDir = await scopeToRepo(baseDir, requestedRepo);
-  const currentDir = await resolveTerminalCwd(rootDir, requestedCwd);
-
-  if (!command) {
-    return json({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
-      durationMs: 0,
-      cwd: path.relative(rootDir, currentDir) || '.',
-    });
-  }
-
-  // Handle 'cd' commands directly to track directory state across calls
-  const cdTarget = matchCdCommand(command);
-  if (cdTarget !== null) {
-    if (!cdTarget || cdTarget === '~' || cdTarget === '/') {
-      return json({
-        stdout: '',
-        stderr: '',
-        exitCode: 0,
-        durationMs: 1,
-        cwd: '.',
-      });
-    }
-
-    const cd = await resolveCdTarget(rootDir, currentDir, cdTarget);
-    if (!cd.ok) {
-      return json({
-        stdout: '',
-        stderr: cd.reason === 'above-root'
-          ? `cd: permission denied: cannot navigate above workspace root`
-          : `cd: no such file or directory: ${cdTarget}`,
-        exitCode: 1,
-        durationMs: 1,
-        cwd: path.relative(rootDir, currentDir) || '.',
-      });
-    }
-
-    return json({
-      stdout: '',
-      stderr: '',
-      exitCode: 0,
-      durationMs: 1,
-      cwd: cd.cwd,
-    });
-  }
-
-  const startTime = Date.now();
-  const result = await runShell(command, {
-    cwd: currentDir,
-    timeout: 30000,
-    maxBuffer: 1024 * 1024 * 2,
-    env: {
-      PAGER: 'cat',
-      FORCE_COLOR: '0',
-    },
-  });
-  const durationMs = Date.now() - startTime;
-  // Timeout detection uses signalCode (SIGTERM from Bun), not `killed` —
-  // Bun 1.4 sets killed=true even for normal non-zero exits.
-  const timedOut = result.signalCode !== null;
-  const exitCode = timedOut ? 1 : (result.exitCode ?? 1);
-  const stderr = result.stderr || (timedOut ? 'Command timed out' : '') || (exitCode === 0 ? '' : result.error?.message || 'Command execution failed');
-
-  return json({
-    stdout: result.stdout,
-    stderr,
-    exitCode,
-    durationMs,
-    cwd: path.relative(rootDir, currentDir) || '.',
-    ...(exitCode === 0 ? {} : { error: result.error?.message || (timedOut ? 'Command timed out' : `Command exited with code ${exitCode}`) }),
-  });
-}

package/src/server/routes/terminal/sessions.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Live terminal inventory.
+ *
+ * The panel persists its terminal id per chamber session, so a reload normally
+ * reattaches to the shell it already owns. This endpoint covers the case where
+ * that id is gone (cleared storage, a second browser, a new tab): the client can
+ * see which shells are alive in the active scope and adopt one instead of
+ * leaving it to the idle reaper.
+ */
+
+import { json, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { listTerminals } from '@/server/lib/terminal/runtime.server';
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const url = new URL(request.url);
+  return json({
+    terminals: await listTerminals(url.searchParams.get('root'), url.searchParams.get('repo')),
+  });
+}

package/src/server/routes/terminal/ws.ts

@@ -0,0 +1,149 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Terminal WebSocket: the only transport between a terminal panel and its PTY.
+ *
+ * Text frames are JSON control, binary frames are raw PTY bytes in both
+ * directions. The client's first frame is `attach`, which also creates the
+ * shell when the id is new — one round trip, and no separate create endpoint to
+ * race against.
+ *
+ * The upgrade is origin-checked. Browsers happily open a WebSocket to
+ * `localhost` from any page, and there is no preflight to stop them, so a
+ * cross-origin page could otherwise drive a shell on this machine.
+ *
+ * Per-connection state lives on `ws.data`, not in a `WeakMap` keyed by the `ws`
+ * object: Elysia hands a *different* wrapper to `message`/`close` than the one
+ * `open` received (verified on 1.4.30), so a WeakMap lookup finds nothing and
+ * every frame is silently dropped. `ws.data` is the same object throughout.
+ */
+
+import { Elysia, t } from 'elysia';
+import {
+  attachTerminal,
+  closeTerminal,
+  detachTerminal,
+  resizeTerminalDebounced,
+  writeTerminalInput,
+} from '@/server/lib/terminal/runtime.server';
+import { TerminalRuntimeError, type TerminalViewer } from '@/server/lib/terminal/session.server';
+import {
+  decodeClientFrame,
+  encodeServerFrame,
+  isValidTerminalId,
+} from '@/shared/lib/workspace/terminal/protocol';
+
+interface Attachment {
+  id: string;
+  viewer: TerminalViewer;
+  /** One attach per socket; a duplicate would replay the scrollback twice. */
+  attached: boolean;
+}
+
+/** Elysia's ws context, narrowed to the per-connection store this route adds. */
+type TerminalWsData = { params: { terminalId: string }; terminal?: Attachment };
+
+export const terminalWsRoutes = new Elysia({ prefix: '/api/terminal' }).ws('/:terminalId/ws', {
+  params: t.Object({ terminalId: t.String() }),
+
+  beforeHandle({ request, status }) {
+    if (!isSameOriginUpgrade(request)) return status(403, 'Cross-origin terminal upgrade rejected');
+  },
+
+  open(ws) {
+    const data = ws.data as unknown as TerminalWsData;
+    const id = data.params.terminalId;
+    if (!isValidTerminalId(id)) {
+      ws.close();
+      return;
+    }
+    data.terminal = {
+      id,
+      attached: false,
+      viewer: {
+        send(frame) {
+          try {
+            ws.send(frame);
+          } catch {
+            // Socket closed mid-send; the close handler detaches.
+          }
+        },
+      },
+    };
+  },
+
+  async message(ws, raw) {
+    const attachment = (ws.data as unknown as TerminalWsData).terminal;
+    if (!attachment) return;
+
+    // Raw PTY input (keystrokes, paste, mouse reports) — never JSON-escaped.
+    if (raw instanceof Uint8Array) {
+      writeTerminalInput(attachment.id, raw);
+      return;
+    }
+
+    const frame = decodeClientFrame(raw);
+    if (!frame) return;
+
+    if (frame.t === 'resize') {
+      resizeTerminalDebounced(attachment.id, frame.cols, frame.rows);
+      return;
+    }
+
+    if (frame.t === 'close') {
+      closeTerminal(attachment.id);
+      return;
+    }
+
+    if (attachment.attached) return;
+
+    try {
+      const { snapshot, replay } = await attachTerminal(attachment.viewer, {
+        id: attachment.id,
+        cols: frame.cols,
+        rows: frame.rows,
+        root: frame.root,
+        repo: frame.repo,
+        theme: frame.theme,
+      });
+      attachment.attached = true;
+      ws.send(encodeServerFrame({ t: 'ready', ...snapshot, replayBytes: replay.length }));
+      // Ordering is safe without sequence numbers: attach captured the history
+      // and registered this viewer in one synchronous block, so nothing can be
+      // delivered between this frame and the replay that follows it.
+      if (replay.length > 0) ws.send(replay);
+    } catch (error) {
+      const code = error instanceof TerminalRuntimeError ? error.code : 'unknown';
+      const message = error instanceof Error ? error.message : String(error);
+      ws.send(encodeServerFrame({ t: 'error', code, message }));
+    }
+  },
+
+  close(ws) {
+    const data = ws.data as unknown as TerminalWsData;
+    const attachment = data.terminal;
+    if (!attachment) return;
+    data.terminal = undefined;
+    detachTerminal(attachment.viewer, attachment.id);
+  },
+});
+
+/**
+ * A WebSocket upgrade carries the page's `Origin`, and no preflight protects
+ * it. Requests without one (curl, tests) are allowed: they are not a browser
+ * being tricked into dialing localhost.
+ */
+function isSameOriginUpgrade(request: Request): boolean {
+  const origin = request.headers.get('origin');
+  if (!origin) return true;
+  const host = request.headers.get('host');
+  if (!host) return false;
+  try {
+    return new URL(origin).host === host;
+  } catch {
+    return false;
+  }
+}

package/src/shared/lib/chat/composer/client.ts

@@ -56,8 +56,13 @@ export function toFilePickItems(files: FsFileEntry[]): ComposerPickItem[] {
 }
 
 /**
- * Combine commands (`/name`) then skills (`/skill:name`). A skill is skipped
- * when a command already covers its plain name or `skill:<name>`; commands win.
+ * Combine live command items (`/name`, including omp's own `skill:<name>`
+ * entries) with the chamber's skill list. Commands win: a skill whose plain or
+ * `skill:`-namespaced name a command already covers is skipped, so the two
+ * sources never double-list the same skill.
+ *
+ * The description carries the argument hint exactly as oh-my-pi renders it
+ * (`[on|off|status] - Toggle fast mode`) so the popup matches the CLI.
  */
 export function mergeCommandAndSkillItems(commands: CommandItem[], skills: SkillItem[]): ComposerPickItem[] {
   const result: ComposerPickItem[] = [];
@@ -67,13 +72,17 @@ export function mergeCommandAndSkillItems(commands: CommandItem[], skills: Skill
     const key = command.name.toLowerCase();
     if (seen.has(key)) continue;
     seen.add(key);
+    const description = command.description ?? '';
     result.push({
       id: `command-${command.name}`,
       name: command.name,
-      description: command.description,
-      kind: 'command',
-      source: 'command',
+      description: command.inputHint ? (description ? `${command.inputHint} - ${description}` : command.inputHint) : description,
+      kind: command.name.toLowerCase().startsWith('skill:') ? 'skill' : 'command',
+      source: command.name.toLowerCase().startsWith('skill:') ? 'skill' : 'command',
       token: `/${command.name}`,
+      ...(command.aliases?.length ? { aliases: command.aliases } : {}),
+      ...(command.subcommands?.length ? { subcommands: command.subcommands } : {}),
+      ...(command.inputHint ? { inputHint: command.inputHint } : {}),
     });
   }
 
@@ -84,11 +93,11 @@ export function mergeCommandAndSkillItems(commands: CommandItem[], skills: Skill
     seen.add(prefixed);
     result.push({
       id: `skill-${skill.name}`,
-      name: skill.name,
+      name: prefixed,
       description: skill.description,
-      kind: 'command',
+      kind: 'skill',
       source: 'skill',
-      token: `/skill:${skill.name}`,
+      token: `/${prefixed}`,
     });
   }