@juspay/shooter 1.17.0 → 1.18.0

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

@@ -209,6 +209,32 @@ export function listGeminiProjects(): ProjectGroup[] {
   );
 }
 
+/**
+ * Parse the full conversation from a single chats/session-*.json file.
+ * Returns all messages with no pagination — suitable for bulk processing.
+ */
+export function parseGeminiSessionFile(filePath: string): ConversationMessage[] {
+  try {
+    return conversationFromChatFile(filePath, 0, Number.MAX_SAFE_INTEGER);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Resolve the absolute path of the chats/session-*.json file backing the
+ * given sessionId, or null if no chat file exists (e.g. logs.json-only session).
+ */
+export function resolveGeminiSessionFile(sessionId: string): null | string {
+  for (const hashDir of collectProjectHashDirs()) {
+    const chatFile = findChatFileForSession(hashDir, sessionId);
+    if (chatFile !== null) {
+      return chatFile;
+    }
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Session building helpers
 // ---------------------------------------------------------------------------
@@ -390,36 +416,33 @@ function extractTextFromContent(
 }
 
 /**
- * Find the chats/session-*.json file for a specific sessionId.
- * The filename embeds the first 8 chars of the UUID; we fall back to reading
- * every file in the directory if necessary.
+ * Find the chats/session-*.json file for a specific sessionId. The filename
+ * embeds the first 8 chars of the UUID, so prefix matches are tried first, but
+ * the exact sessionId field is always verified before returning — a short/empty
+ * id or a prefix collision must never mis-resolve to the wrong session.
  */
 function findChatFileForSession(hashDir: string, sessionId: string): null | string {
-  const shortId = sessionId.slice(0, 8);
+  if (!sessionId) {
+    return null;
+  }
   const chatsDir = path.join(hashDir, 'chats');
+  let names: string[];
   try {
-    const entries = fs.readdirSync(chatsDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.startsWith('session-') || !entry.name.endsWith('.json')) {
-        continue;
-      }
-      // Fast path: filename contains shortId.
-      if (entry.name.includes(shortId)) {
-        return path.join(chatsDir, entry.name);
-      }
-    }
-    // Slow path: read each file and check the sessionId field.
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.startsWith('session-') || !entry.name.endsWith('.json')) {
-        continue;
-      }
-      const record = readChatFile(path.join(chatsDir, entry.name));
-      if (record?.sessionId === sessionId) {
-        return path.join(chatsDir, entry.name);
-      }
-    }
+    names = fs
+      .readdirSync(chatsDir, { withFileTypes: true })
+      .filter((e) => e.isFile() && e.name.startsWith('session-') && e.name.endsWith('.json'))
+      .map((e) => e.name);
   } catch {
-    // chats dir missing or unreadable
+    return null; // chats dir missing or unreadable
+  }
+  const shortId = sessionId.slice(0, 8);
+  // Order prefix-matching filenames first (cheap), then verify the exact id.
+  names.sort((a, b) => Number(b.includes(shortId)) - Number(a.includes(shortId)));
+  for (const name of names) {
+    const full = path.join(chatsDir, name);
+    if (readChatFile(full)?.sessionId === sessionId) {
+      return full;
+    }
   }
   return null;
 }

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

@@ -2,16 +2,6 @@ import Database from 'better-sqlite3';
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 
-function shortHash(input: string): string {
-  return crypto.createHash('sha256').update(input).digest('hex').slice(0, 8);
-}
-
-import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from '$lib/types';
-
-import { resolveOpenCodeDbPath } from './opencode-db-path';
-
-const OPENCODE_DB_PATH = resolveOpenCodeDbPath();
-
 export function getOpenCodeConversation(
   sessionId: string,
   offset = 0,
@@ -127,6 +117,10 @@ export function getOpenCodeConversation(
   }
 }
 
+import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from '$lib/types';
+
+import { resolveOpenCodeDbPath } from './opencode-db-path';
+
 export function listOpenCodeProjects(): ProjectGroup[] {
   const db = getDb();
   if (!db) {
@@ -251,12 +245,19 @@ function convertOpenCodePart(data: Record<string, unknown>): MessagePart | null
 }
 
 function getDb(): Database.Database | null {
-  if (!fs.existsSync(OPENCODE_DB_PATH)) {
+  // Resolve per call (not at module load) so a DB created after server start —
+  // or an XDG_DATA_HOME change — is still picked up.
+  const dbPath = resolveOpenCodeDbPath();
+  if (!fs.existsSync(dbPath)) {
     return null;
   }
   try {
-    return new Database(OPENCODE_DB_PATH, { readonly: true });
+    return new Database(dbPath, { readonly: true });
   } catch {
     return null;
   }
 }
+
+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,6 +1,9 @@
 import type { ClaudeSessionFile, DetectedProcess } from '$lib/types';
 
+import { detectActiveAmpSessions } from '$lib/modules/server/sessions/amp-reader';
 import { detectActiveCodexSessions } from '$lib/modules/server/sessions/codex-reader';
+import { detectActiveCopilotSessions } from '$lib/modules/server/sessions/copilot-reader';
+import { detectActiveCursorSessions } from '$lib/modules/server/sessions/cursor-reader';
 import { detectActiveGeminiSessions } from '$lib/modules/server/sessions/gemini-reader';
 import { resolveOpenCodeDbPath } from '$lib/modules/server/sessions/opencode-db-path';
 import { detectActiveQwenSessions } from '$lib/modules/server/sessions/qwen-reader';
@@ -48,14 +51,22 @@ 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
-
-// Gemini session files written within this window are considered "live"
-const GEMINI_ACTIVE_THRESHOLD_MS = 3 * 60_000; // 3 minutes
-
-// Qwen session files written within this window are considered "live"
-const QWEN_ACTIVE_THRESHOLD_MS = 3 * 60_000; // 3 minutes
+// File-based providers: a session file written within this window = "live".
+const FILE_PROVIDER_ACTIVE_THRESHOLD_MS = 3 * 60_000; // 3 minutes
+
+// File-based providers (no PID file) share one detection shape:
+// detectActive<P>Sessions(thresholdMs) -> { cwd, id, startedAt }[].
+const FILE_PROVIDER_DETECTORS: {
+  command: DetectedProcess['command'];
+  detect: (thresholdMs: number) => { cwd: string; id: string; startedAt: number }[];
+}[] = [
+  { command: 'codex', detect: detectActiveCodexSessions },
+  { command: 'gemini', detect: detectActiveGeminiSessions },
+  { command: 'qwen', detect: detectActiveQwenSessions },
+  { command: 'cursor-agent', detect: detectActiveCursorSessions },
+  { command: 'copilot', detect: detectActiveCopilotSessions },
+  { command: 'amp', detect: detectActiveAmpSessions },
+];
 
 /**
  * Scan ~/.claude/sessions/*.json to find running Claude Code processes,
@@ -149,59 +160,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
-  }
-
-  // --- Gemini sessions ---
-  // Gemini has no PID file; a logs.json / chat file written in the last few
-  // minutes indicates an active session. cwd is reverse-mapped where possible.
-  try {
-    for (const s of detectActiveGeminiSessions(GEMINI_ACTIVE_THRESHOLD_MS)) {
-      results.push({
-        command: 'gemini',
-        cwd: s.cwd,
-        kind: 'interactive',
-        pid: 0, // Gemini doesn't expose a per-session PID
-        projectPath: cwdToProjectPath(s.cwd),
-        sessionId: s.id,
-        startedAt: s.startedAt,
-      });
-    }
-  } catch {
-    // ~/.gemini/tmp missing or unreadable — skip silently
-  }
-
-  // --- Qwen sessions ---
-  try {
-    for (const s of detectActiveQwenSessions(QWEN_ACTIVE_THRESHOLD_MS)) {
-      results.push({
-        command: 'qwen',
-        cwd: s.cwd,
-        kind: 'interactive',
-        pid: 0,
-        projectPath: cwdToProjectPath(s.cwd),
-        sessionId: s.id,
-        startedAt: s.startedAt,
-      });
+  // --- File-based providers (Codex/Gemini/Qwen/Cursor/Copilot/Amp) ---
+  // None expose a PID; a recently-written session file means "live". cwd/id come
+  // from each provider's reader. One loop instead of a block per provider.
+  for (const { command, detect } of FILE_PROVIDER_DETECTORS) {
+    try {
+      for (const s of detect(FILE_PROVIDER_ACTIVE_THRESHOLD_MS)) {
+        results.push({
+          command,
+          cwd: s.cwd,
+          kind: 'interactive',
+          pid: 0,
+          projectPath: cwdToProjectPath(s.cwd),
+          sessionId: s.id,
+          startedAt: s.startedAt,
+        });
+      }
+    } catch {
+      // provider session dir missing/unreadable — skip silently
     }
-  } catch {
-    // ~/.qwen/projects missing or unreadable — skip silently
   }
 
   // Sort by startedAt descending (most recent first)

package/src/lib/modules/server/sessions/provider-paths.ts

@@ -0,0 +1,173 @@
+/**
+ * Path-based dispatch for the five read-only providers (cursor, copilot,
+ * qwen, gemini, amp). These have no incremental byte watcher of their own;
+ * the generic-session-watcher re-reads the whole file on change and parses it
+ * through here. Keeping all path↔provider knowledge in one module means the
+ * watcher, the WS session handler, and the SoS coordinator share one source of
+ * truth and never branch on provider directories themselves.
+ */
+
+import type { ConversationMessage, SessionSource } from '$lib/types';
+
+import { detectActiveAmpSessions, parseAmpSessionFile, resolveAmpSessionFile } from './amp-reader';
+import {
+  detectActiveCopilotSessions,
+  parseCopilotSessionFile,
+  resolveCopilotSessionFile,
+} from './copilot-reader';
+import {
+  detectActiveCursorSessions,
+  parseCursorSessionFile,
+  resolveCursorSessionFile,
+} from './cursor-reader';
+import {
+  detectActiveGeminiSessions,
+  parseGeminiSessionFile,
+  resolveGeminiSessionFile,
+} from './gemini-reader';
+import {
+  detectActiveQwenSessions,
+  parseQwenSessionFile,
+  resolveQwenSessionFile,
+} from './qwen-reader';
+
+/** True when the path belongs to one of the five read-only providers. */
+export function isReadOnlyProviderPath(filePath: string): boolean {
+  return readOnlyProviderForPath(filePath) !== null;
+}
+
+/**
+ * Parse a single read-only-provider session file (by path) into the full
+ * conversation. Returns [] for unknown paths or on any read/parse error.
+ */
+export function parseReadOnlyProviderFile(filePath: string): ConversationMessage[] {
+  switch (readOnlyProviderForPath(filePath)) {
+    case 'amp':
+      return parseAmpSessionFile(filePath);
+    case 'copilot':
+      return parseCopilotSessionFile(filePath);
+    case 'cursor':
+      return parseCursorSessionFile(filePath);
+    case 'gemini':
+      return parseGeminiSessionFile(filePath);
+    case 'qwen':
+      return parseQwenSessionFile(filePath);
+    default:
+      return [];
+  }
+}
+
+/**
+ * Identify which read-only provider backs a given session-file path, or null
+ * for claude/codex/opencode (which have their own watchers) and unknown paths.
+ * Detection is by the provider's root directory, which is unique per provider.
+ */
+export function readOnlyProviderForPath(filePath: string): null | SessionSource {
+  if (filePath.includes('/.cursor/')) {
+    return 'cursor';
+  }
+  if (filePath.includes('/.copilot/')) {
+    return 'copilot';
+  }
+  if (filePath.includes('/.qwen/')) {
+    return 'qwen';
+  }
+  if (filePath.includes('/.gemini/')) {
+    return 'gemini';
+  }
+  if (filePath.includes('/amp/threads/')) {
+    return 'amp';
+  }
+  return null;
+}
+
+/** Map a launchable CLI command to its read-only provider source, or null. */
+export function readOnlySourceForCommand(command: string): null | SessionSource {
+  switch (command) {
+    case 'amp':
+      return 'amp';
+    case 'copilot':
+      return 'copilot';
+    case 'cursor-agent':
+      return 'cursor';
+    case 'gemini':
+      return 'gemini';
+    case 'qwen':
+      return 'qwen';
+    default:
+      return null;
+  }
+}
+
+/**
+ * Resolve a read-only provider's session ID to its backing file path, or null
+ * if the provider has no single-file backing for that session (e.g. a Gemini
+ * session present only in logs.json) or the ID is not found.
+ */
+export function resolveReadOnlyProviderFile(
+  source: SessionSource,
+  sessionId: string
+): null | string {
+  switch (source) {
+    case 'amp':
+      return resolveAmpSessionFile(sessionId);
+    case 'copilot':
+      return resolveCopilotSessionFile(sessionId);
+    case 'cursor':
+      return resolveCursorSessionFile(sessionId);
+    case 'gemini':
+      return resolveGeminiSessionFile(sessionId);
+    case 'qwen':
+      return resolveQwenSessionFile(sessionId);
+    default:
+      return null;
+  }
+}
+
+const READ_ONLY_DETECTORS: Partial<
+  Record<SessionSource, (thresholdMs: number) => { cwd: string; id: string; startedAt: number }[]>
+> = {
+  amp: detectActiveAmpSessions,
+  copilot: detectActiveCopilotSessions,
+  cursor: detectActiveCursorSessions,
+  gemini: detectActiveGeminiSessions,
+  qwen: detectActiveQwenSessions,
+};
+
+/**
+ * After Shooter launches a read-only-provider CLI, find the session file it
+ * just created so the terminal can be live-tailed. Picks the most recent
+ * session started at/after launch, preferring an exact cwd match (cwd decoding
+ * is heuristic for some providers, so a same-provider, started-after-launch
+ * session is the fallback). Returns null until the CLI has written a session.
+ */
+export function discoverReadOnlyProviderSessionFile(
+  source: SessionSource,
+  cwd: string,
+  launchTimeMs: number,
+  nowMs: number
+): null | string {
+  const detect = READ_ONLY_DETECTORS[source];
+  if (!detect) {
+    return null;
+  }
+  // Detector scan window: reach back to ~60s before launch so the just-created
+  // session is still inside the mtime window however long ago we launched.
+  const thresholdMs = Math.max(nowMs - launchTimeMs + 60_000, 60_000);
+  let active: { cwd: string; id: string; startedAt: number }[];
+  try {
+    active = detect(thresholdMs);
+  } catch {
+    return null;
+  }
+  // Start-time tolerance (distinct from the scan window above): keep only
+  // sessions that started at/after launch, with 2s of clock-skew slack.
+  const afterLaunch = active
+    .filter((s) => s.startedAt >= launchTimeMs - 2000)
+    .sort((a, b) => b.startedAt - a.startedAt);
+  const match = afterLaunch.find((s) => s.cwd === cwd) ?? afterLaunch[0];
+  if (!match) {
+    return null;
+  }
+  return resolveReadOnlyProviderFile(source, match.id);
+}

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

@@ -68,21 +68,7 @@ export function getQwenConversation(
     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
-      }
-    }
+    const messages = readQwenMessages(filePath);
     if (offset === 0 && messages.length > limit) {
       let startIdx = messages.length - limit;
       while (startIdx > 0 && messages[startIdx].role !== 'user') {
@@ -148,6 +134,23 @@ export function listQwenProjects(): ProjectGroup[] {
   );
 }
 
+/** Parse a Qwen session file into messages (used by the generic read-only watcher); [] on error. */
+export function parseQwenSessionFile(filePath: string): ConversationMessage[] {
+  try {
+    return readQwenMessages(filePath);
+  } catch {
+    return [];
+  }
+}
+
+/** Resolve a Qwen session id to its `chats/*.jsonl` path, or null if not found. */
+export function resolveQwenSessionFile(sessionId: string): null | string {
+  if (!/^[A-Za-z0-9_-]+$/.test(sessionId)) {
+    return null;
+  }
+  return collectQwenFiles().find((p) => path.basename(p) === `${sessionId}.jsonl`) ?? null;
+}
+
 /** All chats/*.jsonl files under ~/.qwen/projects/<encoded-cwd>/chats/. */
 function collectQwenFiles(): string[] {
   const out: string[] = [];
@@ -286,6 +289,29 @@ function readPrefix(filePath: string): string {
   }
 }
 
+/**
+ * Read all ConversationMessages from a Qwen JSONL file without pagination.
+ * Oversized files are tail-bounded (see readQwenTextBounded) to cap memory.
+ */
+function readQwenMessages(filePath: string): ConversationMessage[] {
+  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
+    }
+  }
+  return messages;
+}
+
 /** 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;

package/src/lib/modules/server/sessions/registry.ts

@@ -12,7 +12,10 @@
 
 import type { ConversationMessage, ProjectGroup, ProviderDef } from '$lib/types';
 
+import { getAmpConversation, listAmpProjects } from './amp-reader';
 import { getCodexConversation, listCodexProjects } from './codex-reader';
+import { getCopilotConversation, listCopilotProjects } from './copilot-reader';
+import { getCursorConversation, listCursorProjects } from './cursor-reader';
 import { getGeminiConversation, listGeminiProjects } from './gemini-reader';
 import { getSessionConversation, listProjectsWithSessions } from './jsonl-reader';
 import { getOpenCodeConversation, listOpenCodeProjects } from './opencode-reader';
@@ -70,6 +73,33 @@ export const PROVIDERS: ProviderDef[] = [
     resumeArgs: () => [],
     source: 'qwen',
   },
+  {
+    command: 'cursor-agent',
+    getConversation: getCursorConversation,
+    isAI: true,
+    label: 'Cursor',
+    listProjects: listCursorProjects,
+    resumeArgs: () => [],
+    source: 'cursor',
+  },
+  {
+    command: 'copilot',
+    getConversation: getCopilotConversation,
+    isAI: true,
+    label: 'Copilot',
+    listProjects: listCopilotProjects,
+    resumeArgs: () => [],
+    source: 'copilot',
+  },
+  {
+    command: 'amp',
+    getConversation: getAmpConversation,
+    isAI: true,
+    label: 'Amp',
+    listProjects: listAmpProjects,
+    resumeArgs: () => [],
+    source: 'amp',
+  },
 ];
 
 /** AI-agent binary names (for AI_COMMANDS-style checks). */
@@ -93,9 +123,13 @@ export function getProviderConversation(
     if (provider.source === 'claude-code') {
       continue;
     }
-    const messages = provider.getConversation(sessionId, offset, limit);
-    if (messages.length > 0) {
-      return messages;
+    try {
+      const messages = provider.getConversation(sessionId, offset, limit);
+      if (messages.length > 0) {
+        return messages;
+      }
+    } catch {
+      // a failing provider reader must not break resolution — try the next
     }
   }
   return [];
@@ -112,17 +146,24 @@ export function listAllProviderProjects(): ProjectGroup[] {
       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 });
+      try {
+        const name =
+          provider.nameSuffix && typeof group.name === 'string'
+            ? 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 });
+        }
+      } catch {
+        // skip a malformed group rather than dropping the rest of the provider
       }
     }
   }