@juspay/shooter 1.15.0 → 1.17.0

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

@@ -0,0 +1,310 @@
+/**
+ * Qwen Code session reader.
+ *
+ * Qwen Code (a Gemini-CLI fork) writes a HYBRID format: a Claude-style JSONL
+ * envelope (uuid/parentUuid/type per line) carrying a Gemini-style message body
+ * (`message: { role, parts: [{text}|{thought}|{functionCall}|{functionResponse}] }`).
+ * Stored at ~/.qwen/projects/<encoded-cwd>/chats/<id>.jsonl. So we parse the
+ * envelope ourselves and map the Gemini-style parts (NOT the Claude parser,
+ * which expects message.content).
+ */
+
+import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from '$lib/types';
+
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+
+const QWEN_PROJECTS = path.join(homedir(), '.qwen', 'projects');
+const PREFIX_BYTES = 64 * 1024;
+/** Cap conversation reads at 16 MB; oversized files are tail-read (matches the Codex reader). */
+const MAX_QWEN_FILE_BYTES = 16 * 1024 * 1024;
+const SYSTEM_TAG_PREFIXES = [
+  '<command-name>',
+  '<local-command',
+  '<system-reminder>',
+  '<task-notification>',
+];
+
+/** Find Qwen sessions whose file changed within `thresholdMs` — i.e. currently or recently active. */
+export function detectActiveQwenSessions(
+  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 collectQwenFiles()) {
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.mtimeMs < cutoff) {
+        continue;
+      }
+      const meta = readMeta(readPrefix(filePath));
+      if (meta) {
+        out.push({ cwd: meta.cwd, id: meta.id, startedAt: stat.birthtimeMs });
+      }
+    } catch {
+      // skip
+    }
+  }
+  return out;
+}
+
+/**
+ * Return a page of a Qwen 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 getQwenConversation(
+  sessionId: string,
+  offset = 0,
+  limit = 200
+): ConversationMessage[] {
+  if (!/^[A-Za-z0-9_-]+$/.test(sessionId)) {
+    return [];
+  }
+  const filePath = collectQwenFiles().find((p) => path.basename(p) === `${sessionId}.jsonl`);
+  if (!filePath) {
+    return [];
+  }
+  try {
+    const messages: ConversationMessage[] = [];
+    for (const line of readQwenTextBounded(filePath).split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      try {
+        const msg = qwenLineToMessage(JSON.parse(trimmed) as Record<string, unknown>);
+        if (msg) {
+          messages.push(msg);
+        }
+      } catch {
+        // skip malformed line
+      }
+    }
+    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('[qwen] Failed to read conversation:', error);
+    return [];
+  }
+}
+
+/** List all Qwen sessions grouped by working directory, most-recently-modified first. */
+export function listQwenProjects(): ProjectGroup[] {
+  const byCwd = new Map<string, SessionInfo[]>();
+  for (const filePath of collectQwenFiles()) {
+    let stat: fs.Stats;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+    const meta = readMeta(readPrefix(filePath));
+    if (!meta) {
+      continue;
+    }
+    const session: SessionInfo = {
+      created: meta.started || stat.birthtime.toISOString(),
+      gitBranch: meta.gitBranch,
+      id: meta.id,
+      messageCount: 0,
+      modified: stat.mtime.toISOString(),
+      projectPath: meta.cwd,
+      source: 'qwen' as const,
+      summary: '',
+      title: meta.title || 'Untitled Session',
+    };
+    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()
+  );
+}
+
+/** All chats/*.jsonl files under ~/.qwen/projects/<encoded-cwd>/chats/. */
+function collectQwenFiles(): string[] {
+  const out: string[] = [];
+  let projectDirs: fs.Dirent[];
+  try {
+    projectDirs = fs.readdirSync(QWEN_PROJECTS, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const dir of projectDirs) {
+    if (!dir.isDirectory()) {
+      continue;
+    }
+    const chatsDir = path.join(QWEN_PROJECTS, dir.name, 'chats');
+    try {
+      for (const f of fs.readdirSync(chatsDir)) {
+        if (f.endsWith('.jsonl')) {
+          out.push(path.join(chatsDir, f));
+        }
+      }
+    } catch {
+      // no chats dir
+    }
+  }
+  return out;
+}
+
+/** Map a Qwen JSONL line (Claude envelope + Gemini message.parts) to a ConversationMessage. */
+function qwenLineToMessage(entry: Record<string, unknown>): ConversationMessage | null {
+  const type = entry.type;
+  if (type !== 'user' && type !== 'assistant') {
+    return null; // skip system/control records
+  }
+  const message = (entry.message ?? {}) as { content?: unknown; parts?: unknown };
+  const rawParts = Array.isArray(message.parts) ? message.parts : [];
+  const parts: MessagePart[] = [];
+  for (const raw of rawParts) {
+    if (typeof raw !== 'object' || raw === null) {
+      continue;
+    }
+    const p = raw as Record<string, unknown>;
+    if (p.functionCall && typeof p.functionCall === 'object') {
+      const fc = p.functionCall as Record<string, unknown>;
+      const toolName = typeof fc.name === 'string' ? fc.name : 'tool';
+      parts.push({
+        id: typeof fc.id === 'string' ? fc.id : toolName,
+        input: (fc.args as Record<string, unknown>) ?? {},
+        toolName,
+        type: 'tool_use',
+      });
+    } else if (p.thought === true && typeof p.text === 'string') {
+      parts.push({ content: p.text, type: 'thinking' });
+    } else if (typeof p.text === 'string') {
+      parts.push({ content: p.text, type: 'text' });
+    }
+  }
+  // Fallback for any Claude-style string content.
+  if (parts.length === 0 && typeof message.content === 'string' && message.content) {
+    parts.push({ content: message.content, type: 'text' });
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return {
+    id: typeof entry.uuid === 'string' ? entry.uuid : `qwen-${type}`,
+    parts,
+    role: type === 'user' ? 'user' : 'assistant',
+    timestamp: typeof entry.timestamp === 'string' ? entry.timestamp : '',
+  };
+}
+
+/** Extract {cwd, sessionId, gitBranch, started} + first real user prompt from a Qwen session prefix. */
+function readMeta(
+  prefix: string
+): null | { cwd: string; gitBranch: string; id: string; started: string; title: string } {
+  let cwd = '';
+  let id = '';
+  let gitBranch = '';
+  let started = '';
+  let title = '';
+  for (const line of prefix.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let entry: Record<string, unknown>;
+    try {
+      entry = JSON.parse(trimmed) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    if (!cwd && typeof entry.cwd === 'string') {
+      cwd = entry.cwd;
+    }
+    if (!id && typeof entry.sessionId === 'string') {
+      id = entry.sessionId;
+    }
+    if (!gitBranch && typeof entry.gitBranch === 'string') {
+      gitBranch = entry.gitBranch;
+    }
+    if (!started && typeof entry.timestamp === 'string') {
+      started = entry.timestamp;
+    }
+    if (!title && entry.type === 'user') {
+      const msg = entry.message as undefined | { content?: unknown; parts?: unknown };
+      let text = typeof msg?.content === 'string' ? msg.content : '';
+      if (!text && Array.isArray(msg?.parts)) {
+        text = msg.parts
+          .map((p) =>
+            p && typeof p === 'object' && typeof (p as { text?: unknown }).text === 'string'
+              ? (p as { text: string }).text
+              : ''
+          )
+          .join(' ')
+          .trim();
+      }
+      if (text && !SYSTEM_TAG_PREFIXES.some((p) => text.startsWith(p))) {
+        title = text.split('\n')[0]?.slice(0, 80) ?? '';
+      }
+    }
+  }
+  return id && cwd ? { cwd, gitBranch, id, started, title } : null;
+}
+
+/** Read the head of a file (complete lines only). */
+function readPrefix(filePath: string): string {
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const buf = Buffer.alloc(PREFIX_BYTES);
+    const n = fs.readSync(fd, buf, 0, PREFIX_BYTES, 0);
+    const text = buf.toString('utf-8', 0, n);
+    const lastNl = text.lastIndexOf('\n');
+    return lastNl === -1 ? text : text.slice(0, lastNl);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/** Read a Qwen session file, bounded to the tail for oversized files to cap memory. */
+function readQwenTextBounded(filePath: string): string {
+  const size = fs.statSync(filePath).size;
+  if (size <= MAX_QWEN_FILE_BYTES) {
+    return fs.readFileSync(filePath, 'utf-8');
+  }
+  // Oversized: read only the trailing window (most recent messages), dropping the
+  // first (likely partial) line so JSON.parse never sees a fragment.
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const buf = Buffer.alloc(MAX_QWEN_FILE_BYTES);
+    const n = fs.readSync(fd, buf, 0, MAX_QWEN_FILE_BYTES, size - MAX_QWEN_FILE_BYTES);
+    const tail = buf.toString('utf-8', 0, n);
+    return 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/registry.ts

@@ -0,0 +1,137 @@
+/**
+ * Provider registry — the single place that knows every AI-agent provider.
+ *
+ * Inspired by wesm/agentsview's AgentDef registry: instead of branching on
+ * `command === 'claude'` across ~14 call sites, the session API, the connect
+ * route, and the terminal allowlist all derive from this list. Adding a
+ * provider is one entry here (+ its reader) rather than edits everywhere.
+ *
+ * Detection (process-detector) and live watching (server.ts adapter) stay
+ * provider-specific because their mechanisms differ too much to unify cheaply.
+ */
+
+import type { ConversationMessage, ProjectGroup, ProviderDef } from '$lib/types';
+
+import { getCodexConversation, listCodexProjects } from './codex-reader';
+import { getGeminiConversation, listGeminiProjects } from './gemini-reader';
+import { getSessionConversation, listProjectsWithSessions } from './jsonl-reader';
+import { getOpenCodeConversation, listOpenCodeProjects } from './opencode-reader';
+import { getQwenConversation, listQwenProjects } from './qwen-reader';
+
+/**
+ * Every AI-agent provider, in merge order. `claude-code` MUST stay first: its
+ * projects seed the merge map so the canonical (decoded) project path/name wins
+ * over other providers' guesses.
+ */
+export const PROVIDERS: ProviderDef[] = [
+  {
+    command: 'claude',
+    getConversation: (id, offset, limit) => getSessionConversation(id, offset, limit),
+    isAI: true,
+    label: 'Claude Code',
+    listProjects: listProjectsWithSessions,
+    resumeArgs: (id) => ['--resume', id],
+    source: 'claude-code',
+  },
+  {
+    command: 'opencode',
+    getConversation: getOpenCodeConversation,
+    isAI: true,
+    label: 'OpenCode',
+    listProjects: listOpenCodeProjects,
+    nameSuffix: ' (OpenCode)',
+    resumeArgs: (id) => ['--session', id],
+    source: 'opencode',
+  },
+  {
+    command: 'codex',
+    getConversation: getCodexConversation,
+    isAI: true,
+    label: 'Codex',
+    listProjects: listCodexProjects,
+    resumeArgs: (id) => ['resume', id],
+    source: 'codex',
+  },
+  {
+    command: 'gemini',
+    getConversation: getGeminiConversation,
+    isAI: true,
+    label: 'Gemini',
+    listProjects: listGeminiProjects,
+    resumeArgs: () => [], // Gemini CLI has no session-resume flag
+    source: 'gemini',
+  },
+  {
+    command: 'qwen',
+    getConversation: getQwenConversation,
+    isAI: true,
+    label: 'Qwen',
+    listProjects: listQwenProjects,
+    resumeArgs: () => [],
+    source: 'qwen',
+  },
+];
+
+/** AI-agent binary names (for AI_COMMANDS-style checks). */
+export const AI_COMMANDS: string[] = PROVIDERS.filter((p) => p.isAI).map((p) => p.command);
+
+/** All provider binary names (for the terminal allowlist + connect validation). */
+export const PROVIDER_COMMANDS: string[] = PROVIDERS.map((p) => p.command);
+
+/** Resolve a session's conversation across providers (Claude first, with its project dir). */
+export function getProviderConversation(
+  sessionId: string,
+  offset: number,
+  limit: number,
+  claudeProjectDir?: string
+): ConversationMessage[] {
+  const claude = getSessionConversation(sessionId, offset, limit, claudeProjectDir);
+  if (claude.length > 0) {
+    return claude;
+  }
+  for (const provider of PROVIDERS) {
+    if (provider.source === 'claude-code') {
+      continue;
+    }
+    const messages = provider.getConversation(sessionId, offset, limit);
+    if (messages.length > 0) {
+      return messages;
+    }
+  }
+  return [];
+}
+
+/** Merge every provider's projects, deduplicating by absolute path. */
+export function listAllProviderProjects(): ProjectGroup[] {
+  const byPath = new Map<string, ProjectGroup>();
+  for (const provider of PROVIDERS) {
+    let groups: ProjectGroup[];
+    try {
+      groups = provider.listProjects();
+    } catch {
+      continue; // a broken provider must not take down the whole listing
+    }
+    for (const group of groups) {
+      const name = provider.nameSuffix ? group.name.replace(provider.nameSuffix, '') : group.name;
+      const existing = byPath.get(group.fullPath);
+      if (existing) {
+        existing.sessions.push(...group.sessions);
+        existing.sessions.sort(
+          (a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime()
+        );
+        existing.sessionCount = existing.sessions.length;
+        existing.lastModified = existing.sessions[0]?.modified || existing.lastModified;
+      } else {
+        byPath.set(group.fullPath, { ...group, name });
+      }
+    }
+  }
+  return [...byPath.values()].sort(
+    (a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+  );
+}
+
+/** Resume args for a launched command (e.g. `codex resume <id>`). */
+export function resumeArgsForCommand(command: string, sessionId: string): string[] {
+  return PROVIDERS.find((p) => p.command === command)?.resumeArgs(sessionId) ?? [];
+}

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

@@ -0,0 +1,182 @@
+/**
+ * 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';
+import { readBoundedRolloutText } from '../sessions/codex-reader';
+
+/** 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 {
+      // Bounded read — rollout files can be hundreds of MB; this is called on
+      // every WS session connection (mirrors getCodexConversation).
+      return parseCodexRollout(readBoundedRolloutText(filePath)).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). */