@juspay/shooter 1.16.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

@@ -15,6 +15,7 @@ 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;
@@ -28,7 +29,9 @@ class CodexWatcher {
       return [];
     }
     try {
-      return parseCodexRollout(fs.readFileSync(filePath, 'utf-8')).messages;
+      // 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 [];

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

@@ -22,6 +22,8 @@ import type { WebSocket } from 'ws';
 import * as fs from 'fs';
 import * as path from 'path';
 
+import { findCodexRolloutById } from '../sessions/codex-reader';
+
 // ── Module-level references ──────────────────────────────────────────
 
 let _ptyManager: null | PtyManagerLike = null;
@@ -171,34 +173,36 @@ function conversationToLive(msg: ConversationMessage): ServerMessage[] {
  * Returns the absolute path if found, or null.
  */
 function findJsonlFileForSession(sessionId: string): null | string {
-  const claudeProjectsDir = path.join(process.env.HOME || '', '.claude', 'projects');
-
-  if (!fs.existsSync(claudeProjectsDir)) {
+  // Reject anything that could traverse out of the session directories before
+  // it is interpolated into a filesystem path.
+  if (!/^[A-Za-z0-9_-]+$/.test(sessionId)) {
     return null;
   }
 
-  try {
-    const projectDirs = fs.readdirSync(claudeProjectsDir);
-    for (const dir of projectDirs) {
-      const fullDir = path.join(claudeProjectsDir, dir);
-      try {
-        if (!fs.statSync(fullDir).isDirectory()) {
+  const claudeProjectsDir = path.join(process.env.HOME || '', '.claude', 'projects');
+  if (fs.existsSync(claudeProjectsDir)) {
+    try {
+      for (const dir of fs.readdirSync(claudeProjectsDir)) {
+        const fullDir = path.join(claudeProjectsDir, dir);
+        try {
+          if (!fs.statSync(fullDir).isDirectory()) {
+            continue;
+          }
+        } catch {
           continue;
         }
-      } catch {
-        continue;
-      }
-
-      const jsonlPath = path.join(fullDir, `${sessionId}.jsonl`);
-      if (fs.existsSync(jsonlPath)) {
-        return jsonlPath;
+        const jsonlPath = path.join(fullDir, `${sessionId}.jsonl`);
+        if (fs.existsSync(jsonlPath)) {
+          return jsonlPath;
+        }
       }
+    } catch {
+      // Ignore filesystem errors
     }
-  } catch {
-    // Ignore filesystem errors
   }
 
-  return null;
+  // Fall back to an external Codex session: ~/.codex/sessions/**/rollout-*-<id>.jsonl
+  return findCodexRolloutById(sessionId);
 }
 
 // ── Helpers ──────────────────────────────────────────────────────────

package/src/lib/theme.css

@@ -526,6 +526,39 @@
   --pill-cursor: inherit;
 }
 
+/* Additional providers reuse the existing colour families (cosmetic only). */
+.pill-source-qwen,
+.pill-source-iflow {
+  --pill-background: var(--ds-red-100);
+  --pill-color: var(--ds-red-900);
+  --pill-font-size: 10px;
+  --pill-padding: 2px 8px;
+  --pill-hover-background: var(--ds-red-100);
+  --pill-hover-color: var(--ds-red-900);
+  --pill-cursor: inherit;
+}
+
+.pill-source-cursor {
+  --pill-background: var(--ds-blue-100);
+  --pill-color: var(--ds-blue-900);
+  --pill-font-size: 10px;
+  --pill-padding: 2px 8px;
+  --pill-hover-background: var(--ds-blue-100);
+  --pill-hover-color: var(--ds-blue-900);
+  --pill-cursor: inherit;
+}
+
+.pill-source-copilot,
+.pill-source-amp {
+  --pill-background: var(--ds-amber-100);
+  --pill-color: var(--ds-amber-900);
+  --pill-font-size: 10px;
+  --pill-padding: 2px 8px;
+  --pill-hover-background: var(--ds-amber-100);
+  --pill-hover-color: var(--ds-amber-900);
+  --pill-cursor: inherit;
+}
+
 /* ===== Icon Sizes ===== */
 .icon-14 {
   --icon-width: 14px;

package/src/lib/types/gemini.ts

@@ -0,0 +1,100 @@
+// Gemini CLI session types (hand-written: the on-disk formats are
+// provider-specific and not worth round-tripping through the YAML codegen).
+// Gemini CLI stores user messages in ~/.gemini/tmp/<projectHash>/logs.json
+// and full conversation records in
+// ~/.gemini/tmp/<projectHash>/chats/session-*.json (newer versions only).
+
+// ---------------------------------------------------------------------------
+// logs.json — user-messages-only format (all versions)
+// ---------------------------------------------------------------------------
+
+/** Union of all part shapes that appear in a ConversationRecord message. */
+export type GeminiContentPart = GeminiFunctionCallPart | GeminiTextPart | GeminiThoughtPart;
+
+// ---------------------------------------------------------------------------
+// chats/session-*.json — full ConversationRecord (newer versions)
+// ---------------------------------------------------------------------------
+
+/** Full conversation record stored in chats/session-*.json. */
+export interface GeminiConversationRecord {
+  directories?: string[];
+  kind?: 'main' | 'subagent';
+  lastUpdated: string;
+  messages: GeminiMessageRecord[];
+  projectHash: string;
+  sessionId: string;
+  startTime: string;
+  summary?: string;
+}
+
+/** Inline function-call part from the Google GenAI SDK. */
+export interface GeminiFunctionCallPart {
+  functionCall: {
+    args: Record<string, unknown>;
+    id?: string;
+    name: string;
+  };
+}
+
+/** A single entry in ~/.gemini/tmp/<projectHash>/logs.json. */
+export interface GeminiLogEntry {
+  message: string;
+  messageId: number;
+  sessionId: string;
+  timestamp: string;
+  type: 'user';
+}
+
+/** A single message record in a full ConversationRecord. */
+export type GeminiMessageRecord =
+  | {
+      content: GeminiContentPart[] | string;
+      id: string;
+      thoughts?: GeminiThoughtSummary[];
+      timestamp: string;
+      toolCalls?: GeminiToolCallRecord[];
+      type: 'gemini';
+    }
+  | {
+      content: GeminiContentPart[] | string;
+      id: string;
+      timestamp: string;
+      type: 'error' | 'info' | 'user' | 'warning';
+    };
+
+/** Contents of ~/.gemini/projects.json (present only in newer gemini-cli). */
+export type GeminiProjectsJson = Record<string, string>;
+
+/** Plain-text content part from the Google GenAI SDK. */
+export interface GeminiTextPart {
+  text: string;
+  thought?: false;
+}
+
+/** Inline thinking/reasoning part from the Google GenAI SDK. */
+export interface GeminiThoughtPart {
+  text: string;
+  thought: true;
+}
+
+/** A thought-summary entry attached to a 'gemini'-type message. */
+export interface GeminiThoughtSummary {
+  summary?: string;
+  timestamp: string;
+}
+
+// ---------------------------------------------------------------------------
+// projects.json — project slug → absolute path registry (newer versions)
+// ---------------------------------------------------------------------------
+
+/** A single tool-call record attached to a 'gemini'-type message. */
+export interface GeminiToolCallRecord {
+  args: Record<string, unknown>;
+  description?: string;
+  displayName?: string;
+  id: string;
+  name: string;
+  result?: unknown;
+  status: 'cancelled' | 'error' | 'pending' | 'success';
+  timestamp: string;
+}