@juspay/shooter 1.14.0 → 1.16.0

package/src/lib/modules/server/sessions/codex-reader.ts

@@ -0,0 +1,293 @@
+/**
+ * Codex CLI session reader — listing + conversation retrieval.
+ *
+ * Mirrors jsonl-reader.ts (Claude) and opencode-reader.ts (OpenCode): produces
+ * the same SessionInfo / ProjectGroup / ConversationMessage shapes so the rest
+ * of the app is provider-agnostic.
+ *
+ * Codex sessions live at ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl
+ * (and ~/.codex/archived_sessions/). These files can be very large (hundreds of
+ * MB), so listing only reads a bounded prefix of each file for metadata/title
+ * and estimates the message count from file size; the conversation reader bounds
+ * its read for oversized files.
+ */
+
+import type { ConversationMessage, ProjectGroup, SessionInfo } from '$lib/types';
+
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+
+import { parseCodexMeta, parseCodexRollout } from './codex-parser';
+
+/** Bytes read from the head of a rollout file when listing (enough for meta + first prompts). */
+const LIST_PREFIX_BYTES = 256 * 1024;
+/** Above this size, the conversation reader reads only the tail to bound memory. */
+const MAX_FULL_READ_BYTES = 16 * 1024 * 1024;
+/** Rough average bytes per Codex message line, used to estimate message counts cheaply. */
+const APPROX_BYTES_PER_MESSAGE = 3000;
+
+/** User-message wrappers that Codex injects automatically — not real prompts. */
+const SYNTHETIC_PROMPT_PREFIXES = ['<environment_context>', '<user_instructions>', '<permissions'];
+
+/**
+ * Find Codex sessions whose rollout file was written within `thresholdMs` —
+ * i.e. sessions that are currently (or very recently) active. Uses filesystem
+ * mtime rather than ~/.codex/state_5.sqlite, which is WAL-locked while Codex runs.
+ */
+export function detectActiveCodexSessions(
+  thresholdMs: number
+): { cwd: string; id: string; startedAt: number }[] {
+  const cutoff = Date.now() - thresholdMs;
+  const out: { cwd: string; id: string; startedAt: number }[] = [];
+  for (const filePath of collectRolloutFiles()) {
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.mtimeMs < cutoff) {
+        continue;
+      }
+      const meta = parseCodexMeta(readPrefix(filePath).split('\n')[0] ?? '');
+      if (meta) {
+        out.push({ cwd: meta.cwd, id: meta.id, startedAt: stat.birthtimeMs });
+      }
+    } catch {
+      // skip unreadable files
+    }
+  }
+  return out;
+}
+
+/**
+ * Find the rollout file for a Codex session launched in `cwd` after `sinceMs`
+ * (used by pty-manager to link a freshly-launched `codex` terminal to its file).
+ * Picks the newest matching file by creation time.
+ */
+export function findCodexRolloutForCwd(cwd: string, sinceMs: number): null | string {
+  let best: null | { birthtime: number; path: string } = null;
+  for (const filePath of collectRolloutFiles()) {
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.birthtimeMs <= sinceMs) {
+        continue;
+      }
+      const meta = parseCodexMeta(readPrefix(filePath).split('\n')[0] ?? '');
+      if (meta?.cwd === cwd && (!best || stat.birthtimeMs > best.birthtime)) {
+        best = { birthtime: stat.birthtimeMs, path: filePath };
+      }
+    } catch {
+      // skip unreadable files
+    }
+  }
+  return best?.path ?? null;
+}
+
+/**
+ * Return a page of a Codex session's conversation. With `offset` 0 the most
+ * recent `limit` messages are returned, backed up to a user-message boundary so
+ * turns aren't clipped; otherwise the `offset`..`offset + limit` slice is returned.
+ */
+export function getCodexConversation(
+  sessionId: string,
+  offset = 0,
+  limit = 200
+): ConversationMessage[] {
+  const filePath = findRolloutPath(sessionId);
+  if (!filePath || !fs.existsSync(filePath)) {
+    return [];
+  }
+
+  try {
+    const { messages } = parseCodexRollout(readRolloutText(filePath));
+
+    // Match the Claude reader: with no explicit offset, return the most recent
+    // `limit` messages, backing up to a user-message boundary so turns aren't clipped.
+    if (offset === 0 && messages.length > limit) {
+      let startIdx = messages.length - limit;
+      while (startIdx > 0 && messages[startIdx].role !== 'user') {
+        startIdx--;
+      }
+      return messages.slice(startIdx);
+    }
+    return messages.slice(offset, offset + limit);
+  } catch (error) {
+    console.error('[codex] Failed to read conversation:', error);
+    return [];
+  }
+}
+
+/** List all Codex sessions grouped by working directory, most-recently-modified first. */
+export function listCodexProjects(): ProjectGroup[] {
+  const files = collectRolloutFiles();
+  const byCwd = new Map<string, SessionInfo[]>();
+
+  for (const filePath of files) {
+    let stat: fs.Stats;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+    let prefix: string;
+    try {
+      prefix = readPrefix(filePath);
+    } catch {
+      continue;
+    }
+
+    const firstLine = prefix.slice(0, Math.max(0, prefix.indexOf('\n')) || prefix.length);
+    const meta = parseCodexMeta(firstLine);
+    if (!meta) {
+      continue;
+    }
+
+    const session: SessionInfo = {
+      created: meta.startedAt || stat.birthtime.toISOString(),
+      gitBranch: '',
+      id: meta.id,
+      messageCount: Math.max(1, Math.round(stat.size / APPROX_BYTES_PER_MESSAGE)),
+      modified: stat.mtime.toISOString(),
+      projectPath: meta.cwd,
+      source: 'codex' as const,
+      summary: '',
+      title: cleanTitle(firstUserPrompt(prefix)),
+    };
+
+    const bucket = byCwd.get(meta.cwd);
+    if (bucket) {
+      bucket.push(session);
+    } else {
+      byCwd.set(meta.cwd, [session]);
+    }
+  }
+
+  const projects: ProjectGroup[] = [];
+  for (const [cwd, sessions] of byCwd) {
+    sessions.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+    const segments = cwd.split('/').filter(Boolean);
+    projects.push({
+      fullPath: cwd,
+      id: shortHash(cwd),
+      lastModified: sessions[0]?.modified ?? '',
+      name: segments.slice(-2).join('/'),
+      sessionCount: sessions.length,
+      sessions,
+    });
+  }
+
+  return projects.sort(
+    (a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+  );
+}
+
+function cleanTitle(prompt: string): string {
+  const firstLine = prompt.replace(/\s+/g, ' ').trim().split('\n')[0]?.trim() ?? '';
+  if (!firstLine) {
+    return 'Untitled Session';
+  }
+  return firstLine.length > 80 ? `${firstLine.slice(0, 77)}...` : firstLine;
+}
+
+function codexSessionsDirs(): string[] {
+  const home = homedir();
+  return [path.join(home, '.codex', 'sessions'), path.join(home, '.codex', 'archived_sessions')];
+}
+
+/** Recursively collect all rollout-*.jsonl file paths under the Codex session roots. */
+function collectRolloutFiles(): string[] {
+  const out: string[] = [];
+  const walk = (dir: string): void => {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.name.startsWith('rollout-') && entry.name.endsWith('.jsonl')) {
+        out.push(full);
+      }
+    }
+  };
+  for (const root of codexSessionsDirs()) {
+    walk(root);
+  }
+  return out;
+}
+
+/** Locate a rollout file by its session UUID (embedded in the filename and session_meta.id). */
+function findRolloutPath(sessionId: string): null | string {
+  if (!/^[0-9a-f-]+$/i.test(sessionId)) {
+    return null;
+  }
+  const suffix = `-${sessionId}.jsonl`;
+  return collectRolloutFiles().find((p) => path.basename(p).endsWith(suffix)) ?? null;
+}
+
+/** Pull the first genuine user prompt (skipping Codex's auto-injected wrappers) for a title. */
+function firstUserPrompt(prefixText: string): string {
+  for (const line of prefixText.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.includes('"type":"message"') || !trimmed.includes('"role":"user"')) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(trimmed) as {
+        payload?: { content?: { text?: string; type?: string }[] };
+      };
+      const text = (entry.payload?.content ?? [])
+        .filter((c) => c.type === 'input_text' && typeof c.text === 'string')
+        .map((c) => c.text ?? '')
+        .join('\n')
+        .trim();
+      if (text && !SYNTHETIC_PROMPT_PREFIXES.some((p) => text.startsWith(p))) {
+        return text;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return '';
+}
+
+/** Read the first `LIST_PREFIX_BYTES` of a file as UTF-8 (complete lines only). */
+function readPrefix(filePath: string): string {
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const buf = Buffer.alloc(LIST_PREFIX_BYTES);
+    const bytesRead = fs.readSync(fd, buf, 0, LIST_PREFIX_BYTES, 0);
+    const text = buf.toString('utf-8', 0, bytesRead);
+    const lastNl = text.lastIndexOf('\n');
+    return lastNl === -1 ? text : text.slice(0, lastNl);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/** Read a rollout file's text, bounded to the tail for oversized files. */
+function readRolloutText(filePath: string): string {
+  const stat = fs.statSync(filePath);
+  if (stat.size <= MAX_FULL_READ_BYTES) {
+    return fs.readFileSync(filePath, 'utf-8');
+  }
+  // Oversized: keep session_meta (first line) + the tail (most recent messages).
+  const head = readPrefix(filePath).split('\n')[0] ?? '';
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const start = stat.size - MAX_FULL_READ_BYTES;
+    const buf = Buffer.alloc(MAX_FULL_READ_BYTES);
+    const bytesRead = fs.readSync(fd, buf, 0, MAX_FULL_READ_BYTES, start);
+    const tail = buf.toString('utf-8', 0, bytesRead);
+    // Drop the first (likely partial) line of the tail.
+    return `${head}\n${tail.slice(tail.indexOf('\n') + 1)}`;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function shortHash(input: string): string {
+  return crypto.createHash('sha256').update(input).digest('hex').slice(0, 8);
+}

package/src/lib/modules/server/sessions/process-detector.ts

@@ -1,5 +1,6 @@
 import type { ClaudeSessionFile, DetectedProcess } from '$lib/types';
 
+import { detectActiveCodexSessions } from '$lib/modules/server/sessions/codex-reader';
 import { resolveOpenCodeDbPath } from '$lib/modules/server/sessions/opencode-db-path';
 import Database from 'better-sqlite3';
 import { execSync } from 'child_process';
@@ -45,6 +46,9 @@ const CLAUDE_SESSIONS_DIR = join(homedir(), '.claude', 'sessions');
 // OpenCode sessions updated within this window are considered "live"
 const OPENCODE_ACTIVE_THRESHOLD_MS = 3 * 60_000; // 3 minutes
 
+// Codex rollout files written within this window are considered "live"
+const CODEX_ACTIVE_THRESHOLD_MS = 3 * 60_000; // 3 minutes
+
 /**
  * Scan ~/.claude/sessions/*.json to find running Claude Code processes,
  * and query the OpenCode SQLite DB for recently active sessions.
@@ -137,6 +141,25 @@ export function detectRunningAISessions(): DetectedProcess[] {
     }
   }
 
+  // --- Codex sessions ---
+  // Codex has no PID file; a rollout file written in the last few minutes
+  // indicates an active session. cwd/id come from its session_meta line.
+  try {
+    for (const s of detectActiveCodexSessions(CODEX_ACTIVE_THRESHOLD_MS)) {
+      results.push({
+        command: 'codex',
+        cwd: s.cwd,
+        kind: 'interactive',
+        pid: 0, // Codex doesn't expose a per-session PID
+        projectPath: cwdToProjectPath(s.cwd),
+        sessionId: s.id,
+        startedAt: s.startedAt,
+      });
+    }
+  } catch {
+    // ~/.codex/sessions missing or unreadable — skip silently
+  }
+
   // Sort by startedAt descending (most recent first)
   results.sort((a, b) => b.startedAt - a.startedAt);
 

package/src/lib/modules/server/terminal/codex-watcher.ts

@@ -0,0 +1,179 @@
+/**
+ * Codex live session watcher.
+ *
+ * Codex rollout files are append-only JSONL (like Claude's), so this mirrors
+ * SessionWatcher: chokidar detects writes, only the newly-appended bytes are
+ * read, and lines are fed to a CodexStreamParser that emits messages as each
+ * conversation run completes. Because Codex's role-run grouping only flushes a
+ * run when the *next* run begins, an idle timer flushes the final open run when
+ * writing stops, so the last message isn't withheld.
+ */
+
+import type { ConversationMessage, CodexWatchState as WatchState } from '$lib/types';
+
+import { watch as chokidarWatch } from 'chokidar';
+import * as fs from 'fs';
+
+import { CodexStreamParser, parseCodexRollout } from '../sessions/codex-parser';
+
+/** Flush the open run after this many ms without a write. */
+const IDLE_FLUSH_MS = 1500;
+
+class CodexWatcher {
+  private watched = new Map<string, WatchState>();
+
+  /** One-shot full-history read of a rollout file (bypasses the live watch). */
+  getHistory(filePath: string): ConversationMessage[] {
+    if (!fs.existsSync(filePath)) {
+      return [];
+    }
+    try {
+      return parseCodexRollout(fs.readFileSync(filePath, 'utf-8')).messages;
+    } catch (error) {
+      console.error(`[codex-watcher] Failed to read history for ${filePath}:`, error);
+      return [];
+    }
+  }
+
+  /** Detach one `callback` (closing the watcher only when none remain), or stop entirely if no callback is given. */
+  stop(filePath: string, callback?: (messages: ConversationMessage[]) => void): void {
+    const state = this.watched.get(filePath);
+    if (!state) {
+      return;
+    }
+    if (callback) {
+      state.callbacks.delete(callback);
+      if (state.callbacks.size > 0) {
+        return;
+      }
+    }
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+    }
+    void state.watcher.close();
+    this.watched.delete(filePath);
+    console.log(`[codex-watcher] Stopped watching: ${filePath}`);
+  }
+
+  /** Stop watching every file. */
+  stopAll(): void {
+    for (const [filePath] of this.watched) {
+      this.stop(filePath);
+    }
+  }
+
+  /** Watch a rollout file for appended messages; returns an unsubscribe function. */
+  subscribe(filePath: string, callback: (messages: ConversationMessage[]) => void): () => void {
+    const existing = this.watched.get(filePath);
+    if (existing) {
+      existing.callbacks.add(callback);
+      return () => {
+        this.stop(filePath, callback);
+      };
+    }
+
+    const watcher = chokidarWatch(filePath, {
+      awaitWriteFinish: { pollInterval: 100, stabilityThreshold: 200 },
+      ignoreInitial: true,
+    });
+
+    const state: WatchState = {
+      callbacks: new Set([callback]),
+      idleTimer: null,
+      lineBuffer: '',
+      offset: fs.existsSync(filePath) ? fs.statSync(filePath).size : 0,
+      parser: new CodexStreamParser(),
+      watcher,
+    };
+
+    watcher.on('change', () => {
+      this.readNew(filePath);
+    });
+    watcher.on('add', () => {
+      this.readNew(filePath);
+    });
+    watcher.on('error', (err) => {
+      console.error(`[codex-watcher] watch error ${filePath}:`, err);
+    });
+
+    this.watched.set(filePath, state);
+    console.log(`[codex-watcher] Watching: ${filePath} (offset ${state.offset})`);
+    return () => {
+      this.stop(filePath, callback);
+    };
+  }
+
+  private emit(state: WatchState, messages: ConversationMessage[]): void {
+    if (messages.length === 0) {
+      return;
+    }
+    for (const cb of state.callbacks) {
+      try {
+        cb(messages);
+      } catch (err) {
+        console.error('[codex-watcher] callback error:', err);
+      }
+    }
+  }
+
+  private readNew(filePath: string): void {
+    const state = this.watched.get(filePath);
+    if (!state) {
+      return;
+    }
+
+    let stat: fs.Stats;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      return;
+    }
+    if (stat.size < state.offset) {
+      // Truncated/rotated — reset.
+      state.offset = 0;
+      state.lineBuffer = '';
+      state.parser = new CodexStreamParser();
+    }
+    if (stat.size <= state.offset) {
+      return;
+    }
+
+    const fd = fs.openSync(filePath, 'r');
+    try {
+      const buf = Buffer.alloc(stat.size - state.offset);
+      fs.readSync(fd, buf, 0, buf.length, state.offset);
+      state.offset = stat.size;
+
+      const combined = state.lineBuffer + buf.toString('utf-8');
+      const segments = combined.split('\n');
+      state.lineBuffer = combined.endsWith('\n') ? '' : (segments.pop() ?? '');
+
+      const emitted: ConversationMessage[] = [];
+      for (const line of segments) {
+        if (line.trim()) {
+          emitted.push(...state.parser.pushLine(line));
+        }
+      }
+      this.emit(state, emitted);
+    } finally {
+      fs.closeSync(fd);
+    }
+
+    // Reset the idle timer; flush the final open run once writes stop.
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+    }
+    state.idleTimer = setTimeout(() => {
+      const current = this.watched.get(filePath);
+      if (current) {
+        this.emit(current, current.parser.flushOpen());
+      }
+    }, IDLE_FLUSH_MS);
+  }
+}
+
+// Single shared instance across module loaders (same pattern as the other watchers).
+const CW_GLOBAL_KEY = '__shooter_codex_watcher';
+export const codexWatcher: CodexWatcher =
+  ((globalThis as Record<string, unknown>)[CW_GLOBAL_KEY] as CodexWatcher) || new CodexWatcher();
+(globalThis as Record<string, unknown>)[CW_GLOBAL_KEY] = codexWatcher;

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

@@ -12,6 +12,7 @@ import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from 'fs'
 import path from 'path';
 import { fileURLToPath } from 'url';
 
+import { findCodexRolloutForCwd } from '../sessions/codex-reader';
 import { broadcastEvent } from '../ws/server.js';
 import { HolderClient } from './holder-client';
 import { openCodeWatcher } from './opencode-watcher';
@@ -964,6 +965,46 @@ class PtyManager {
         5 * 60 * 1000
       );
     }
+
+    // For Codex: poll ~/.codex/sessions for the rollout file created after
+    // launch whose session_meta.cwd matches. Codex reuses the sessionFile
+    // field (a JSONL path, like Claude); the WS adapter routes it to the
+    // Codex watcher by its /.codex/ path.
+    if (command === 'codex') {
+      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 rollout = findCodexRolloutForCwd(cwd, launchTime);
+          if (rollout) {
+            terminal.sessionFile = rollout;
+            if (terminal.pollTimer) {
+              clearInterval(terminal.pollTimer);
+              terminal.pollTimer = null;
+            }
+            terminalStore.update(id, { sessionFile: rollout });
+          }
+        } catch {
+          // ignore filesystem errors
+        }
+      }, 1500);
+
+      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/theme.css

@@ -486,7 +486,7 @@
   --pill-cursor: inherit;
 }
 
-.pill-source-claude {
+.pill-source-claude-code {
   --pill-background: var(--ds-blue-100);
   --pill-color: var(--ds-blue-900);
   --pill-font-size: 10px;
@@ -506,6 +506,26 @@
   --pill-cursor: inherit;
 }
 
+.pill-source-codex {
+  --pill-background: var(--ds-green-100);
+  --pill-color: var(--ds-green-900);
+  --pill-font-size: 10px;
+  --pill-padding: 2px 8px;
+  --pill-hover-background: var(--ds-green-100);
+  --pill-hover-color: var(--ds-green-900);
+  --pill-cursor: inherit;
+}
+
+.pill-source-gemini {
+  --pill-background: var(--ds-gray-100);
+  --pill-color: var(--ds-gray-900);
+  --pill-font-size: 10px;
+  --pill-padding: 2px 8px;
+  --pill-hover-background: var(--ds-gray-100);
+  --pill-hover-color: var(--ds-gray-900);
+  --pill-cursor: inherit;
+}
+
 /* ===== Icon Sizes ===== */
 .icon-14 {
   --icon-width: 14px;

package/src/lib/types/codex.ts

@@ -0,0 +1,21 @@
+// Codex CLI session types (hand-written: the rollout record shapes are
+// provider-specific and not worth round-tripping through the YAML codegen).
+// Codex stores sessions as JSONL "rollout" files under
+// ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl.
+
+import type { ConversationMessage } from './sessions';
+
+/** Result of parsing a Codex rollout file into the canonical message model. */
+export interface CodexParseResult {
+  messages: ConversationMessage[];
+  meta: CodexSessionMeta | null;
+}
+
+/** First-line `session_meta` payload of a Codex rollout file. */
+export interface CodexSessionMeta {
+  cliVersion: string;
+  cwd: string;
+  id: string;
+  model: string;
+  startedAt: string;
+}

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

@@ -14,12 +14,14 @@ import {
  * @type { SessionSource }
  * @description Source tool that produced the session
  */
-export type SessionSource = 'claude-code' | 'opencode';
+export type SessionSource = 'claude-code' | 'opencode' | 'codex' | 'gemini';
 
 export function decodeSessionSource(rawInput: unknown): SessionSource | null {
   switch (rawInput) {
     case 'claude-code':
     case 'opencode':
+    case 'codex':
+    case 'gemini':
       return rawInput;
   }
   return null;
@@ -29,6 +31,8 @@ export function _decodeSessionSource(rawInput: unknown): SessionSource | undefin
   switch (rawInput) {
     case 'claude-code':
     case 'opencode':
+    case 'codex':
+    case 'gemini':
       return rawInput;
   }
   return;

package/src/lib/types/index.ts

@@ -4,6 +4,7 @@
 export type * from './activity';
 export type * from './apn';
 export type * from './cli';
+export type * from './codex';
 export type * from './common';
 export type * from './dashboard';
 export * from './decision';