ompchamber 0.8.0 → 1.0.0

package/src/server/lib/terminal/shell.ts

@@ -0,0 +1,103 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Which shell the PTY runtime launches, with which argv, and with which
+ * environment.
+ *
+ * Resolution is a pure function of the environment plus an existence probe, so
+ * the preference order stays testable without spawning anything: the user's
+ * `$SHELL` first, then the platform's usual suspects.
+ */
+
+const POSIX_FALLBACKS = ['/bin/zsh', '/bin/bash', '/bin/sh'];
+
+/** Candidate executables, most preferred first. */
+export function shellCandidates(
+  env: Record<string, string | undefined> = Bun.env,
+  platform: NodeJS.Platform = process.platform,
+): string[] {
+  if (platform === 'win32') {
+    const comspec = env.COMSPEC?.trim();
+    return comspec ? [comspec] : ['cmd.exe'];
+  }
+  const candidates: string[] = [];
+  const preferred = env.SHELL?.trim();
+  // Only an absolute $SHELL is trusted: a bare name would be resolved against
+  // PATH at spawn time, which is not the login shell the user configured.
+  if (preferred && preferred.startsWith('/')) candidates.push(preferred);
+  for (const fallback of POSIX_FALLBACKS) {
+    if (!candidates.includes(fallback)) candidates.push(fallback);
+  }
+  return candidates;
+}
+
+/**
+ * `-i -l` for POSIX shells: interactive (prompt, line editing, job control —
+ * job control is what makes Ctrl+Z/`fg` work at all) and login (the user's
+ * profile, so PATH and aliases match a normal terminal). cmd.exe takes neither.
+ */
+export function shellArgs(platform: NodeJS.Platform = process.platform): string[] {
+  return platform === 'win32' ? [] : ['-i', '-l'];
+}
+
+/**
+ * Full argv for the PTY child.
+ *
+ * POSIX shells are launched through a one-line `/bin/sh` shim that re-acquires
+ * the PTY as its controlling terminal before `exec`-ing the real shell:
+ *
+ *     T=$(tty); exec <shell> -i -l <"$T" >"$T" 2>&1
+ *
+ * This is required, not cosmetic. The runtime must spawn with
+ * `detached: true` — without it the child lands in the *server's* process
+ * group, where a group signal would take the chamber down and `SIGWINCH`
+ * cannot be addressed to the shell alone. But `setsid()` also drops the
+ * controlling terminal, and a shell with no controlling tty silently disables
+ * job control (`setopt monitor` fails): Ctrl+Z, `fg` and `jobs` stop working,
+ * and typing while a foreground command runs goes to that command instead of
+ * the shell. Opening the slave device as stdin/stdout restores it. Verified on
+ * macOS: with the shim `tpgid` is the shell's own pid and Ctrl+Z suspends;
+ * without it `tpgid` is 0 and Ctrl+Z is swallowed.
+ *
+ * `exec` keeps the pid, so the shell stays the session leader and group kill
+ * still reaches everything it starts. If `tty` fails the shell runs
+ * unredirected — stdio is already the PTY, only job control is lost.
+ */
+export function shellLaunch(executable: string, platform: NodeJS.Platform = process.platform): string[] {
+  if (platform === 'win32') return [executable];
+  const inner = [executable, ...shellArgs(platform)].join(' ');
+  return ['/bin/sh', '-c', `T=$(tty 2>/dev/null); [ -n "$T" ] && exec ${inner} <"$T" >"$T" 2>&1; exec ${inner}`];
+}
+
+/**
+ * Environment for the PTY child. `TERM`/`COLORTERM` describe the renderer on
+ * the other end of the socket; `COLORFGBG` carries the active chamber theme so
+ * prompts that read it (zsh themes, vim) pick readable colors.
+ */
+export function terminalEnv(
+  base: Record<string, string | undefined>,
+  theme: 'light' | 'dark' = 'dark',
+): Record<string, string | undefined> {
+  const env: Record<string, string | undefined> = { ...base };
+  // The chamber's own IPC descriptor is host-private and meaningless inside the
+  // PTY; an inherited value makes Node CLIs fail to parse their IPC channel.
+  delete env.NODE_CHANNEL_FD;
+  env.TERM = 'xterm-256color';
+  env.COLORTERM = 'truecolor';
+  env.COLORFGBG = theme === 'light' ? '0;15' : '15;0';
+  return env;
+}
+
+/** First candidate that exists on disk, or null when none does. */
+export async function resolveShellExecutable(
+  candidates: string[],
+  exists: (target: string) => Promise<boolean> = async (target) => Bun.file(target).exists(),
+): Promise<string | null> {
+  for (const candidate of candidates) {
+    if (await exists(candidate)) return candidate;
+  }
+  return null;
+}

package/src/server/routes/fs/git.ts

@@ -5,6 +5,7 @@ import { resolveRoot } from '@/server/lib/fs/root';
 import { runShell } from '@/server/lib/fs/shell';
 import { fetchFileDiff, fetchGitCommits } from '@/server/lib/fs/git-log';
 import { fetchWorkingFileDiff } from '@/server/lib/fs/git-diff';
+import { gitSyncCount, invalidateRemoteRefs, markRemoteRefsFresh, refreshRemoteRefs } from '@/server/lib/fs/git-sync';
 
 const MAX_GIT_DEPTH = 8;
 
@@ -117,7 +118,17 @@ export async function loader({ request }: LoaderFunctionArgs) {
     });
   }
 
+  // Ahead/behind are only requested by the git panel (`?sync=1`); the
+  // status-only polls (activity bar, file explorer) must not trigger a network
+  // fetch, and must not pay for a count they never read.
+  const syncRequested = url.searchParams.get('sync') === '1';
+
   try {
+    // Started before the local probes below so the fetch overlaps them instead
+    // of adding up; TTL'd inside the helper, so the panel's 5s poll is not a 5s
+    // fetch loop.
+    const remoteRefresh = syncRequested ? refreshRemoteRefs(targetDir) : Promise.resolve();
+
     // Use --porcelain=v1 -uall so all individual edited/untracked files are listed
     const statusOut = (await runShell('git status --porcelain=v1 -uall', { cwd: targetDir, maxBuffer: 1024 * 1024 })).stdout;
 
@@ -167,18 +178,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
         };
       });
 
-    // `git rev-list --left-right --count HEAD...@{upstream}` prints "<ahead>\t<behind>".
-    let syncCount = { ahead: 0, behind: 0 };
-    try {
-      const syncOut = await runShell(
-        'git rev-list --left-right --count HEAD...@{upstream}',
-        { cwd: targetDir, timeout: 8000 }
-      );
-      const [ahead, behind] = syncOut.stdout.trim().split(/\s+/).map(Number);
-      syncCount = { ahead: ahead || 0, behind: behind || 0 };
-    } catch {
-      // No upstream configured — nothing to sync against.
-    }
+    await remoteRefresh;
+    const syncCount = syncRequested ? await gitSyncCount(targetDir) : undefined;
 
     return json({
       changes,
@@ -262,9 +263,13 @@ export async function action({ request }: ActionFunctionArgs) {
           await expectOk(`git checkout -b "${localName}" --track "${branch}"`, targetDir);
         }
       }
+      // The counts are per-branch: the refs the previous branch refreshed say
+      // nothing about the new one's upstream.
+      invalidateRemoteRefs(targetDir);
     } else if (actionType === 'create_branch') {
       const branch = formData.get('branch') as string;
       await expectOk(`git checkout -b "${branch}"`, targetDir);
+      invalidateRemoteRefs(targetDir);
     } else if (actionType === 'history' || actionType === 'graph') {
       const limit = parseInt((formData.get('limit') as string) || '50', 10);
       const skip = parseInt((formData.get('skip') as string) || '0', 10);
@@ -306,11 +311,16 @@ export async function action({ request }: ActionFunctionArgs) {
       await expectOk(`git rebase "${hash}"`, targetDir);
     } else if (actionType === 'push') {
       await expectOk('git push', targetDir, 120000);
+      markRemoteRefsFresh(targetDir);
     } else if (actionType === 'pull') {
       await expectOk('git pull --ff-only', targetDir, 120000);
+      markRemoteRefsFresh(targetDir);
     } else if (actionType === 'sync') {
       await expectOk('git pull --ff-only', targetDir, 120000);
       await expectOk('git push', targetDir, 120000);
+      // Both commands already moved the tracking ref; the next poll must not
+      // fetch again to see a state it just produced.
+      markRemoteRefsFresh(targetDir);
     }
     return json({ success: true });
   } catch (error: any) {

package/src/server/routes/index.ts

@@ -10,6 +10,7 @@ import { foldersBindings } from '@/server/routes/folders';
 import { filesBindings } from '@/server/routes/files';
 import { telemetryBindings } from '@/server/routes/telemetry';
 import { terminalBindings } from '@/server/routes/terminal';
+import { terminalWsRoutes } from '@/server/routes/terminal/ws';
 import { browserBindings } from '@/server/routes/browser';
 import { modelsBindings } from '@/server/routes/models';
 import { ompBindings } from '@/server/routes/omp';
@@ -35,4 +36,4 @@ const allBindings: HandlerBinding[] = [
   ...wellKnownBindings,
 ];
 
-export const apiRoutes = mountBindings(new Elysia(), allBindings).use(agentWsRoutes);
+export const apiRoutes = mountBindings(new Elysia(), allBindings).use(agentWsRoutes).use(terminalWsRoutes);

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

@@ -1,12 +1,11 @@
 import { actionBindings, bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
 import * as sessionsList from '@/server/routes/sessions/list';
 import * as sessionsFolder from '@/server/routes/sessions/folder';
+import * as sessionsQueue from '@/server/routes/sessions/queue';
 import {
   archiveSession,
-  getQueue,
   getSessionState,
   markSeen,
-  putQueue,
   putSessionState,
   renameSession,
 } from '@/server/routes/sessions/session';
@@ -16,7 +15,16 @@ export const sessionsBindings: HandlerBinding[] = [
   ...bindingsFor(sessionsList, '/api/sessions/list'),
   ...bindingsFor(sessionsFolder, '/api/sessions/:sessionId'),
   ...actionBindings(archiveSession, '/api/sessions/:sessionId/archive'),
-  ...actionBindings(putQueue, '/api/sessions/:sessionId/queue', getQueue),
+  // Per-item queue routes. `actionBindings` mounts ALL four mutating verbs on
+  // one path, and Elysia lets a later registration override an earlier one —
+  // mounting reorder on the same `/queue` path that way would clobber the
+  // add/GET bindings with its 405 GET fallback. Only reorder gets an explicit
+  // PUT-only binding; add carries the shared GET loader.
+  ...actionBindings(sessionsQueue.addQueueItem, '/api/sessions/:sessionId/queue', sessionsQueue.getQueue),
+  ...actionBindings(sessionsQueue.editQueueItem, '/api/sessions/:sessionId/queue/:itemId'),
+  { method: 'PUT', path: '/api/sessions/:sessionId/queue', handler: sessionsQueue.reorderQueueItems },
+  { method: 'DELETE', path: '/api/sessions/:sessionId/queue/:itemId', handler: sessionsQueue.removeQueueItem },
+  ...actionBindings(sessionsQueue.nudgeQueueDelivery, '/api/sessions/:sessionId/queue/deliver'),
   ...actionBindings(renameSession, '/api/sessions/:sessionId/rename'),
   ...actionBindings(putSessionState, '/api/sessions/:sessionId/state', getSessionState),
   ...actionBindings(markSeen, '/api/sessions/:sessionId/stream-seen'),

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

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Per-item follow-up queue routes (`queued_messages` table). The client panel
+ * is a VIEW: every mutation goes through one of these endpoints and returns
+ * the canonical queue, so the client never ships a full-list replacement
+ * (that shape is what let a reload wipe the table and a session switch copy
+ * one session's queue into another).
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { requireParam } from '@/server/lib/route-adapter';
+import {
+  appendQueueItem,
+  deleteQueueItem,
+  listQueue,
+  patchQueueItem,
+  reorderQueue,
+} from '@/server/lib/queue/store.server';
+import { getRpcSession } from '@/server/lib/omp/rpc/manager';
+import { scheduleQueueDelivery } from '@/server/lib/queue/delivery.server';
+
+/** GET — the session's queued follow-ups in delivery order. */
+export async function getQueue({ params }: LoaderFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  return json({ queue: await listQueue(sessionId) });
+}
+
+/**
+ * POST — append one queued item. Body: `{ text, attachments?, model? }`.
+ * Returns the canonical queue.
+ */
+export async function addQueueItem({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'POST') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const body = (await request.json().catch(() => null)) as Record<string, unknown> | null;
+  if (!body || typeof body.text !== 'string' || (!body.text.trim() && !Array.isArray(body.attachments))) {
+    return json({ error: 'Invalid body: expected { text: string, attachments?, model? }' }, { status: 400 });
+  }
+  const queue = await appendQueueItem(sessionId, {
+    text: body.text,
+    attachments: body.attachments,
+    model: body.model,
+  });
+  return json({ queue });
+}
+
+/**
+ * PATCH — edit one item's text and/or model snapshot. Body: `{ text?, model? }`.
+ * Returns the canonical queue; 404 when the id is unknown or already claimed.
+ */
+export async function editQueueItem({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'PATCH') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const itemId = params.itemId;
+  if (!itemId) return json({ error: 'Item ID is required' }, { status: 400 });
+  const body = (await request.json().catch(() => null)) as Record<string, unknown> | null;
+  if (!body) return json({ error: 'Invalid JSON body' }, { status: 400 });
+
+  const queue = await patchQueueItem(sessionId, itemId, { text: body.text, model: body.model });
+  if (!queue) return json({ error: 'Queue item not found' }, { status: 404 });
+  return json({ queue });
+}
+
+/**
+ * DELETE — remove one item by id. 404 when it was already claimed for
+ * delivery or never existed (both leave nothing to remove).
+ */
+export async function removeQueueItem({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'DELETE') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const itemId = params.itemId;
+  if (!itemId) return json({ error: 'Item ID is required' }, { status: 400 });
+  const removed = await deleteQueueItem(sessionId, itemId);
+  if (!removed) return json({ error: 'Queue item not found' }, { status: 404 });
+  return json({ success: true });
+}
+
+/**
+ * PUT — reorder the queue to exactly `{ orderedIds: string[] }` (a drag in the
+ * panel ships ids only, never item payloads). Returns the canonical queue.
+ */
+export async function reorderQueueItems({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'PUT') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const body = (await request.json().catch(() => null)) as { orderedIds?: unknown } | null;
+  if (!body || !Array.isArray(body.orderedIds) || body.orderedIds.some((id) => typeof id !== 'string')) {
+    return json({ error: 'Invalid body: expected { orderedIds: string[] }' }, { status: 400 });
+  }
+  return json({ queue: await reorderQueue(sessionId, body.orderedIds) });
+}
+
+/**
+ * POST /queue/deliver — client nudge: a tab that (re)opens a session offers
+ * the server a delivery slot. The server-side claim makes this a no-op when a
+ * run is active or the head was already claimed; an idle session with queued
+ * items gets its head delivered exactly once.
+ */
+export async function nudgeQueueDelivery({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'POST') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const session = getRpcSession(sessionId);
+  if (!session?.isAlive()) return json({ success: true, delivered: false, reason: 'session-not-live' });
+  scheduleQueueDelivery(session);
+  return json({ success: true });
+}

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

@@ -21,7 +21,7 @@ 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']);
+    const agentSources = new Set(['builtin', 'skill', 'custom', 'extension', 'file']);
     return available
       .filter((c) => agentSources.has((c as { source?: string })?.source ?? ''))
       .map((c) => {

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')),
+  });
+}