@juspay/shooter 1.17.0 → 1.19.0

package/src/lib/modules/server/terminal/generic-session-watcher.ts

@@ -0,0 +1,163 @@
+/**
+ * GenericSessionWatcher — live tailing for the five read-only providers
+ * (cursor, copilot, qwen, gemini, amp).
+ *
+ * The byte-offset watchers (claude/codex) and the SQLite poller (opencode)
+ * each understand one wire format. These five providers store sessions in
+ * heterogeneous shapes — per-turn JSONL for some, a single rewritten JSON
+ * document for others — so a byte-incremental reader would need five bespoke
+ * parsers. Instead this watcher re-parses the whole file on each change via
+ * the shared `parseReadOnlyProviderFile` dispatch and emits only messages
+ * whose ID it has not delivered before. That makes it correct for both
+ * append-only and whole-document-rewrite formats with one code path.
+ *
+ * The public surface (getHistory + ref-counted subscribe) matches
+ * SessionWatcherLike, so the server's session-watcher adapter can route to it
+ * by path without any handler changes.
+ */
+
+import type { ConversationMessage, GenericWatchedFile, OnNewEntries } from '$lib/types';
+
+import { watch as chokidarWatch } from 'chokidar';
+
+import { parseReadOnlyProviderFile } from '../sessions/provider-paths';
+
+class GenericSessionWatcher {
+  private watched = new Map<string, GenericWatchedFile>();
+
+  /** Re-read the whole file and return the full parsed conversation. */
+  getHistory(filePath: string): ConversationMessage[] {
+    return parseReadOnlyProviderFile(filePath);
+  }
+
+  /** Stop watching a single file and release its chokidar handle. */
+  stop(filePath: string): void {
+    const watched = this.watched.get(filePath);
+    if (!watched) {
+      return;
+    }
+    void watched.watcher.close();
+    this.watched.delete(filePath);
+    console.log(`[generic-watcher] Stopped watching: ${filePath}`);
+  }
+
+  /** Stop watching every file. */
+  stopAll(): void {
+    for (const [filePath] of this.watched) {
+      this.stop(filePath);
+    }
+  }
+
+  /**
+   * Subscribe to new messages for a file. Adds the callback to an existing
+   * watcher when one is present (ref-counted), otherwise starts a chokidar
+   * watch. Returns an unsubscribe function that tears the watcher down once
+   * the last subscriber leaves — identical lifecycle to SessionWatcher.
+   */
+  subscribe(filePath: string, onNewEntries: OnNewEntries): () => void {
+    const existing = this.watched.get(filePath);
+    if (existing) {
+      existing.callbacks.add(onNewEntries);
+      return () => {
+        this.removeCallback(filePath, onNewEntries);
+      };
+    }
+
+    // Seed the emitted set with everything already in the file so the first
+    // change only surfaces genuinely new messages — history is sent separately
+    // via getHistory, mirroring the byte watchers' initial-offset behaviour.
+    const emittedMessageIds = new Set<string>();
+    try {
+      for (const msg of parseReadOnlyProviderFile(filePath)) {
+        emittedMessageIds.add(msg.id);
+      }
+    } catch (error) {
+      // Degrade gracefully: an unreadable/racy file at subscribe time must not
+      // prevent watching — the first change will just re-surface what's there.
+      console.error(`[generic-watcher] Failed to seed ${filePath}:`, error);
+    }
+
+    const watcher = chokidarWatch(filePath, {
+      awaitWriteFinish: { pollInterval: 100, stabilityThreshold: 200 },
+      ignoreInitial: true,
+      usePolling: false,
+    });
+
+    const watched: GenericWatchedFile = {
+      callbacks: new Set([onNewEntries]),
+      emittedMessageIds,
+      filePath,
+      watcher,
+    };
+
+    const onChange = (): void => {
+      this.readNew(watched);
+    };
+    watcher.on('add', onChange);
+    watcher.on('change', onChange);
+    watcher.on('error', (error) => {
+      console.error(`[generic-watcher] Error watching ${filePath}:`, error);
+    });
+
+    this.watched.set(filePath, watched);
+    console.log(`[generic-watcher] Watching: ${filePath} (seeded ${emittedMessageIds.size} msgs)`);
+
+    return () => {
+      this.removeCallback(filePath, onNewEntries);
+    };
+  }
+
+  /** Legacy fire-and-forget API matching SessionWatcher.watch(). */
+  watch(filePath: string, onNewEntries: OnNewEntries): void {
+    this.subscribe(filePath, onNewEntries);
+  }
+
+  /**
+   * Re-parse the file and deliver any messages whose ID has not been emitted.
+   * If a rewrite drops the count below what we have seen (truncation/reset),
+   * the new IDs simply won't match, so nothing spurious is sent.
+   */
+  private readNew(watched: GenericWatchedFile): void {
+    let messages: ConversationMessage[];
+    try {
+      messages = parseReadOnlyProviderFile(watched.filePath);
+    } catch (error) {
+      console.error(`[generic-watcher] Failed to re-read ${watched.filePath}:`, error);
+      return;
+    }
+
+    const fresh = messages.filter((msg) => !watched.emittedMessageIds.has(msg.id));
+    if (fresh.length === 0) {
+      return;
+    }
+    for (const msg of fresh) {
+      watched.emittedMessageIds.add(msg.id);
+    }
+    for (const cb of watched.callbacks) {
+      try {
+        cb(fresh);
+      } catch (cbError) {
+        console.error('[generic-watcher] Callback error:', cbError);
+      }
+    }
+  }
+
+  /** Remove one callback; stop watching when none remain. */
+  private removeCallback(filePath: string, onNewEntries: OnNewEntries): void {
+    const watched = this.watched.get(filePath);
+    if (!watched) {
+      return;
+    }
+    watched.callbacks.delete(onNewEntries);
+    if (watched.callbacks.size === 0) {
+      this.stop(filePath);
+    }
+  }
+}
+
+// Single shared instance across module loaders (matches sessionWatcher).
+const GW_GLOBAL_KEY = '__shooter_generic_session_watcher';
+export const genericSessionWatcher: GenericSessionWatcher =
+  ((globalThis as Record<string, unknown>)[GW_GLOBAL_KEY] as GenericSessionWatcher) ||
+  new GenericSessionWatcher();
+(globalThis as Record<string, unknown>)[GW_GLOBAL_KEY] = genericSessionWatcher;

package/src/lib/modules/server/terminal/pty-input.ts

@@ -0,0 +1,37 @@
+/**
+ * PTY input helpers.
+ *
+ * Submitting text to an interactive agent TUI (codex, claude, gemini, qwen, …)
+ * is not as simple as appending a newline. These TUIs read the PTY in raw mode:
+ *
+ *   - A bare LF (`\n`) is NOT the Enter key — it types a literal newline into
+ *     the prompt and never submits. (Verified: LF leaves codex sitting on its
+ *     prompt; the message just accumulates.)
+ *   - Even `"<text>\r"` written as a SINGLE chunk is treated as a bracketed
+ *     paste by the TUI, so the trailing CR is absorbed into the pasted body
+ *     instead of submitting. (Verified: codex types the text but does not run.)
+ *
+ * The reliable approach — the same bytes a real terminal emulator sends when a
+ * human pastes and presses Enter — is to wrap the body in an explicit bracketed
+ * paste (`ESC[200~` … `ESC[201~`) and then send a CR. The paste-end marker
+ * closes the paste unambiguously, so the following CR is a real Enter. This
+ * also preserves embedded newlines in multi-line messages (the whole point of
+ * bracketed paste) and submits correctly in modern interactive shells, where
+ * bracketed paste is enabled by default.
+ *
+ * Verified empirically against codex 0.136 and claude 2.1 — both receive the
+ * message and complete a turn.
+ */
+
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+
+/**
+ * Build the PTY byte sequence that delivers `text` to an interactive terminal
+ * and submits it (presses Enter). Any trailing newline the caller added is
+ * stripped — the CR after the paste-end marker is what submits.
+ */
+export function ptySubmitSequence(text: string): string {
+  const body = text.replace(/[\r\n]+$/, '');
+  return `${PASTE_START}${body}${PASTE_END}\r`;
+}

package/src/lib/modules/server/terminal/pty-manager.ts

@@ -13,6 +13,10 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 
 import { findCodexRolloutForCwd } from '../sessions/codex-reader';
+import {
+  discoverReadOnlyProviderSessionFile,
+  readOnlySourceForCommand,
+} from '../sessions/provider-paths';
 import { broadcastEvent } from '../ws/server.js';
 import { HolderClient } from './holder-client';
 import { openCodeWatcher } from './opencode-watcher';
@@ -1005,6 +1009,53 @@ class PtyManager {
         5 * 60 * 1000
       );
     }
+
+    // For the read-only providers (cursor/copilot/qwen/gemini/amp): poll their
+    // store for a session started after launch and matching this cwd, then set
+    // sessionFile to that path. The WS adapter routes it to the generic watcher
+    // by its provider-root path, giving the same live-tail the JSONL watchers
+    // provide for Claude/Codex.
+    const readOnlySource = readOnlySourceForCommand(command);
+    if (readOnlySource) {
+      const launchTime = terminal.createdAt.getTime();
+      terminal.pollTimer = setInterval(() => {
+        if (terminal.status === 'exited' || terminal.sessionFile) {
+          if (terminal.pollTimer) {
+            clearInterval(terminal.pollTimer);
+            terminal.pollTimer = null;
+          }
+          return;
+        }
+        try {
+          const file = discoverReadOnlyProviderSessionFile(
+            readOnlySource,
+            cwd,
+            launchTime,
+            Date.now()
+          );
+          if (file) {
+            terminal.sessionFile = file;
+            if (terminal.pollTimer) {
+              clearInterval(terminal.pollTimer);
+              terminal.pollTimer = null;
+            }
+            terminalStore.update(id, { sessionFile: file });
+          }
+        } catch {
+          // ignore filesystem errors
+        }
+      }, 2000);
+
+      setTimeout(
+        () => {
+          if (terminal.pollTimer) {
+            clearInterval(terminal.pollTimer);
+            terminal.pollTimer = null;
+          }
+        },
+        5 * 60 * 1000
+      );
+    }
   }
 
   /** Wire up all HolderClient callbacks (activity, CWD, output, exit, disconnect). */

package/src/lib/modules/server/ws/server.ts

@@ -15,6 +15,7 @@ import {
   handleEventsConnection,
 } from './events-handler.js';
 import { handleSessionConnection } from './session-handler.js';
+import { handleSuperSessionConnection } from './super-session-handler.js';
 import { handleTerminalConnection } from './terminal-handler.js';
 export type { WireShooterEvent as ShooterEvent } from '$lib/types';
 
@@ -61,10 +62,11 @@ export function setupWebSocketHandlers(
 
   // Route matching
   const terminalMatch = /^\/ws\/terminal\/(.+)$/.exec(pathname);
+  const superSessionMatch = /^\/ws\/super-session\/(.+)$/.exec(pathname);
   const sessionMatch = /^\/ws\/session\/(.+)$/.exec(pathname);
   const isEvents = pathname === '/ws/events';
 
-  if (!terminalMatch && !sessionMatch && !isEvents) {
+  if (!terminalMatch && !superSessionMatch && !sessionMatch && !isEvents) {
     socket.destroy();
     return;
   }
@@ -83,6 +85,9 @@ export function setupWebSocketHandlers(
     if (terminalMatch) {
       const terminalId = terminalMatch[1];
       handleTerminalConnection(ws, terminalId);
+    } else if (superSessionMatch) {
+      const superSessionId = superSessionMatch[1];
+      handleSuperSessionConnection(ws, superSessionId);
     } else if (sessionMatch) {
       const sessionId = sessionMatch[1];
       handleSessionConnection(ws, sessionId);

package/src/lib/modules/server/ws/session-handler.ts

@@ -23,6 +23,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 import { findCodexRolloutById } from '../sessions/codex-reader';
+import { ptySubmitSequence } from '../terminal/pty-input';
 
 // ── Module-level references ──────────────────────────────────────────
 
@@ -222,7 +223,17 @@ function findTerminalBySessionUuid(uuid: string): ManagedTerminal | undefined {
   // module-level _ptyManagerFull reference if available.
   if (_ptyManagerFull) {
     for (const t of _ptyManagerFull.list()) {
-      if (t.sessionFile?.includes(`${uuid}.jsonl`)) {
+      // Match across every provider's file naming so a running non-Claude
+      // agent can be reached (and replied to) by its session UUID:
+      //   claude/cursor/qwen: <uuid>.jsonl ; codex: -<uuid>.jsonl ;
+      //   copilot: <uuid>.jsonl OR <uuid>/events.jsonl ; amp: T-<uuid>.json ;
+      //   opencode: bare session id.
+      if (
+        t.sessionFile?.includes(`${uuid}.jsonl`) ||
+        t.sessionFile?.endsWith(`/${uuid}/events.jsonl`) ||
+        t.sessionFile?.endsWith(`/T-${uuid}.json`) ||
+        t.openCodeSessionId === uuid
+      ) {
         return _ptyManager.getTerminal(t.id);
       }
     }
@@ -537,7 +548,11 @@ function wireClientMessages(ws: WebSocket, state: ConnectionState): void {
             safeSend(ws, { message: 'Terminal has exited', type: 'error' });
             return;
           }
-          currentTerminal.pty.write(`${msg.text}\n`);
+          // Deliver + submit via a bracketed paste (see pty-input.ts): a bare
+          // LF never submits to an agent TUI and a trailing CR in the same
+          // write is absorbed as paste content. Bracketed paste closes the
+          // paste explicitly so the following CR is a real Enter.
+          currentTerminal.pty.write(ptySubmitSequence(msg.text));
           break;
         }
 

package/src/lib/modules/server/ws/super-session-handler.ts

@@ -0,0 +1,200 @@
+// WebSocket handler for /ws/super-session/:id — the merged Session-Over-Sessions
+// stream. On connect it replays the merged transcript (sos-history) and then
+// streams live tagged messages from every member. Accepts human-driven control
+// messages: relay-forward (inject into a member's terminal), member-add,
+// member-remove. Mirrors session-handler.ts in shape.
+
+import type { SessionSource, SosClientMessage, SosServerMessage } from '$lib/types';
+import type { WebSocket } from 'ws';
+
+import * as path from 'path';
+
+import { PROVIDERS } from '../sessions/registry';
+import { sosCoordinator } from '../sos/coordinator';
+
+const MAX_RELAY_TEXT = 10240; // 10 KB, same cap as /ws/session send-input
+// Stop streaming to a client whose outbound buffer exceeds this — bounds memory
+// growth when a slow consumer can't drain sos-history replay or a live burst.
+const MAX_WS_BUFFERED_BYTES = 1_000_000;
+const VALID_SOURCES = new Set<string>(PROVIDERS.map((p) => p.source));
+
+export function handleSuperSessionConnection(ws: WebSocket, id: string): void {
+  const session = sosCoordinator.getSuperSession(id);
+  if (!session) {
+    safeSend(ws, { message: `Super-session not found: ${id}`, type: 'sos-error' });
+    ws.close(1008, 'Super-session not found');
+    return;
+  }
+
+  // subscribe() replays the current transcript as an sos-history message, then
+  // streams live sos-message / sos-member-* events. If a send fails (socket
+  // closed or buffer over cap), stop feeding this client to bound memory.
+  let unsubscribe: (() => void) | null = null;
+  unsubscribe = sosCoordinator.subscribe(id, (msg) => {
+    if (!safeSend(ws, msg)) {
+      unsubscribe?.();
+      unsubscribe = null;
+    }
+  });
+
+  ws.on('message', (raw: Buffer | string) => {
+    const data = typeof raw === 'string' ? raw : raw.toString('utf-8');
+    const msg = parseClientMessage(data);
+    if (!msg) {
+      // Surface schema drift instead of silently dropping the frame — a dead
+      // control in the UI is much harder to debug than an explicit error.
+      safeSend(ws, { message: 'Invalid super-session control message', type: 'sos-error' });
+      return;
+    }
+    handleClientMessage(ws, id, msg);
+  });
+
+  ws.on('close', () => {
+    unsubscribe?.();
+  });
+  ws.on('error', () => {
+    // cleanup happens in 'close'
+  });
+}
+
+/** True when the string is a known provider source. */
+export function isValidProvider(value: string): value is SessionSource {
+  return VALID_SOURCES.has(value);
+}
+
+/** True for a bare session id (OpenCode) or an absolute path under HOME. */
+export function isValidSessionKey(key: string): boolean {
+  if (/^[A-Za-z0-9_-]+$/.test(key)) {
+    return true;
+  }
+  const home = process.env.HOME || '';
+  if (home === '' || !path.isAbsolute(key)) {
+    return false;
+  }
+  // Resolve before comparing so `..` segments cannot escape the HOME sandbox
+  // (e.g. /home/user/../etc/passwd passes a raw prefix check but not this).
+  const relative = path.relative(path.resolve(home), path.resolve(key));
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function handleClientMessage(ws: WebSocket, superSessionId: string, msg: SosClientMessage): void {
+  switch (msg.type) {
+    case 'member-add': {
+      const member = sosCoordinator.addMember(superSessionId, {
+        capability: msg.capability,
+        provider: msg.provider,
+        sessionKey: msg.sessionKey,
+        terminalId: msg.terminalId ?? null,
+      });
+      if (!member) {
+        safeSend(ws, { message: 'Failed to add member', type: 'sos-error' });
+      }
+      break;
+    }
+    case 'member-remove': {
+      const ok = sosCoordinator.removeMember(superSessionId, msg.memberId);
+      if (!ok) {
+        safeSend(ws, { message: 'Member not found', type: 'sos-error' });
+      }
+      break;
+    }
+    case 'relay-approve': {
+      if (!sosCoordinator.approveRelay(superSessionId, msg.relayId)) {
+        safeSend(ws, { message: 'Pending relay not found', type: 'sos-error' });
+      }
+      break;
+    }
+    case 'relay-deny': {
+      if (!sosCoordinator.denyRelay(superSessionId, msg.relayId)) {
+        safeSend(ws, { message: 'Pending relay not found', type: 'sos-error' });
+      }
+      break;
+    }
+    case 'relay-forward': {
+      const error = sosCoordinator.relayForward(superSessionId, msg.toMemberId, msg.text);
+      if (error) {
+        safeSend(ws, { message: error, type: 'sos-error' });
+      }
+      break;
+    }
+  }
+}
+
+function parseClientMessage(raw: string): null | SosClientMessage {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== 'object' || parsed === null) {
+    return null;
+  }
+  const msg = parsed as Record<string, unknown>;
+
+  switch (msg.type) {
+    case 'member-add': {
+      if (
+        typeof msg.sessionKey !== 'string' ||
+        !isValidSessionKey(msg.sessionKey) ||
+        typeof msg.provider !== 'string' ||
+        !isValidProvider(msg.provider)
+      ) {
+        return null;
+      }
+      return {
+        capability: typeof msg.capability === 'string' ? msg.capability : undefined,
+        provider: msg.provider,
+        sessionKey: msg.sessionKey,
+        terminalId: typeof msg.terminalId === 'string' ? msg.terminalId : undefined,
+        type: 'member-add',
+      };
+    }
+    case 'member-remove': {
+      if (typeof msg.memberId !== 'string' || msg.memberId.length === 0) {
+        return null;
+      }
+      return { memberId: msg.memberId, type: 'member-remove' };
+    }
+    case 'relay-approve': {
+      if (typeof msg.relayId !== 'string' || msg.relayId.length === 0) {
+        return null;
+      }
+      return { relayId: msg.relayId, type: 'relay-approve' };
+    }
+    case 'relay-deny': {
+      if (typeof msg.relayId !== 'string' || msg.relayId.length === 0) {
+        return null;
+      }
+      return { relayId: msg.relayId, type: 'relay-deny' };
+    }
+    case 'relay-forward': {
+      if (
+        typeof msg.toMemberId !== 'string' ||
+        typeof msg.text !== 'string' ||
+        msg.text.length === 0 ||
+        msg.text.length > MAX_RELAY_TEXT
+      ) {
+        return null;
+      }
+      return { text: msg.text, toMemberId: msg.toMemberId, type: 'relay-forward' };
+    }
+    default:
+      return null;
+  }
+}
+
+function safeSend(ws: WebSocket, msg: SosServerMessage): boolean {
+  try {
+    if (ws.readyState !== 1 /* OPEN */) {
+      return false;
+    }
+    if (ws.bufferedAmount > MAX_WS_BUFFERED_BYTES) {
+      return false;
+    }
+    ws.send(JSON.stringify(msg));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/lib/theme.css

@@ -527,8 +527,7 @@
 }
 
 /* Additional providers reuse the existing colour families (cosmetic only). */
-.pill-source-qwen,
-.pill-source-iflow {
+.pill-source-qwen {
   --pill-background: var(--ds-red-100);
   --pill-color: var(--ds-red-900);
   --pill-font-size: 10px;

package/src/lib/types/generated/Sessions.ts

@@ -22,8 +22,7 @@ export type SessionSource =
   | 'qwen'
   | 'cursor'
   | 'copilot'
-  | 'amp'
-  | 'iflow';
+  | 'amp';
 
 export function decodeSessionSource(rawInput: unknown): SessionSource | null {
   switch (rawInput) {
@@ -35,7 +34,6 @@ export function decodeSessionSource(rawInput: unknown): SessionSource | null {
     case 'cursor':
     case 'copilot':
     case 'amp':
-    case 'iflow':
       return rawInput;
   }
   return null;
@@ -51,7 +49,6 @@ export function _decodeSessionSource(rawInput: unknown): SessionSource | undefin
     case 'cursor':
     case 'copilot':
     case 'amp':
-    case 'iflow':
       return rawInput;
   }
   return;

package/src/lib/types/index.ts

@@ -12,8 +12,8 @@ export type * from './gemini';
 export * from './generated';
 export type * from './neurolink';
 export type * from './server';
-
 export type * from './sessions';
+
 // Explicit re-exports to resolve conflicts between generated types and the
 // hand-written sessions.ts versions. The generated Sessions module exports
 // wrapper-class variants (CMessagePartTextPart, etc.) with `type: string`
@@ -27,5 +27,6 @@ export type {
   ToolResultPart,
   ToolUsePart,
 } from './sessions';
+export type * from './sos';
 export type * from './terminal-client';
 export type * from './ws';

package/src/lib/types/server.ts

@@ -24,6 +24,23 @@ export interface CodexWatchState {
   watcher: FSWatcher;
 }
 
+/**
+ * Watch state for the generic re-read-on-change watcher used by the
+ * read-only providers (cursor, copilot, qwen, gemini, amp). Unlike the
+ * byte-offset watchers, it re-parses the whole file on each change and
+ * dedupes by message ID — robust for both append-only JSONL and
+ * whole-document JSON formats.
+ */
+export interface GenericWatchedFile {
+  callbacks: Set<OnNewEntries>;
+  /** Message IDs already delivered, so re-reads only emit genuinely new messages. */
+  emittedMessageIds: Set<string>;
+  filePath: string;
+  watcher: FSWatcher;
+}
+
+// ── pty-manager types ───────────────────────────────────────────────
+
 /** Messages received from the holder process (local ndjson protocol). */
 export type HolderIncomingMessage =
   | { active: boolean; type: 'activity' }
@@ -33,21 +50,19 @@ export type HolderIncomingMessage =
   | { exitCode: null | number; exited: boolean; pid: number; type: 'info' }
   | { path: string; type: 'cwd' };
 
-// ── pty-manager types ───────────────────────────────────────────────
-
 /** Messages sent to the holder process (local ndjson protocol). */
 export type HolderOutgoingMessage =
   | { cols: number; rows: number; type: 'resize' }
   | { data: string; type: 'input' }
   | { signal?: string; type: 'kill' };
 
+// ── session-watcher types ───────────────────────────────────────────
+
 /**
  * Callback invoked when new JSONL entries are parsed from a watched file.
  */
 export type OnNewEntries = (entries: ConversationMessage[]) => void;
 
-// ── session-watcher types ───────────────────────────────────────────
-
 export interface OpenCodeWatchState {
   callbacks: Set<(messages: ConversationMessage[]) => void>;
   /** Set of message IDs we have already emitted, to avoid duplicates. */
@@ -62,6 +77,8 @@ export interface OpenCodeWatchState {
   sessionId: string;
 }
 
+// ── opencode-watcher types ──────────────────────────────────────────
+
 export interface PtyManagedTerminal {
   args: string[];
   clients: Set<WebSocket>;
@@ -89,14 +106,14 @@ export interface PtyManagedTerminal {
   watcherOffset: number;
 }
 
-// ── opencode-watcher types ──────────────────────────────────────────
+// ── codex-watcher types ─────────────────────────────────────────────
 
 export interface PtyOutputBuffer {
   data: string[];
   size: number;
 }
 
-// ── codex-watcher types ─────────────────────────────────────────────
+// ── generic-session-watcher types ───────────────────────────────────
 
 export interface SessionWatchedFile {
   callbacks: Set<OnNewEntries>;

package/src/lib/types/sessions.ts

@@ -23,16 +23,7 @@ export interface ConversationMessage {
 }
 
 export interface DetectedProcess {
-  command:
-    | 'amp'
-    | 'claude'
-    | 'codex'
-    | 'copilot'
-    | 'cursor-agent'
-    | 'gemini'
-    | 'iflow'
-    | 'opencode'
-    | 'qwen';
+  command: 'amp' | 'claude' | 'codex' | 'copilot' | 'cursor-agent' | 'gemini' | 'opencode' | 'qwen';
   cwd: string;
   kind: string;
   pid: number;