@juspay/shooter 1.5.0 → 1.6.1

package/src/lib/modules/server/sessions/jsonl-parser.ts

@@ -7,7 +7,51 @@
  * eliminates drift between the two code paths.
  */
 
-import type { ConversationMessage, MessagePart } from './types';
+import type { ConversationMessage, MessagePart } from '$lib/types';
+
+/* ------------------------------------------------------------------ */
+/*  Type guards & helpers for untyped parsed JSON                     */
+/* ------------------------------------------------------------------ */
+
+/** Extract text from a tool-result content field (string or array of {type,text}). */
+function extractToolResultText(content: unknown): string {
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return (content as unknown[])
+      .filter((c): c is Record<string, unknown> => isRecord(c) && c.type === 'text')
+      .map((c) => {
+        const text = c.text;
+        return typeof text === 'string' ? text : '';
+      })
+      .join('\n');
+  }
+  return '';
+}
+
+/** Narrow an unknown value to a plain object with string keys. */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** Safely read a string property from a record (returns '' on miss). */
+function str(obj: Record<string, unknown>, key: string): string {
+  const v = obj[key];
+  return typeof v === 'string' ? v : '';
+}
+
+/** Coerce unknown array-ish content into Record<string, unknown>[]. */
+function toContentBlocks(raw: unknown): Record<string, unknown>[] {
+  if (Array.isArray(raw)) {
+    return (raw as unknown[]).filter((item): item is Record<string, unknown> => isRecord(item));
+  }
+  // Single value — wrap it
+  if (isRecord(raw)) {
+    return [raw];
+  }
+  return [];
+}
 
 /**
  * Internal event types that should be skipped during parsing.
@@ -62,53 +106,61 @@ export function parseJsonlLine(
   const messages: ConversationMessage[] = [];
   const assistantCompleted: ConversationMessage[] = [];
 
-  const entry = JSON.parse(line);
-  const entryType = entry.type;
+  const entry: unknown = JSON.parse(line);
+  if (!isRecord(entry)) {
+    return { assistantCompleted, messages };
+  }
+
+  const entryType = str(entry, 'type');
 
   // Skip known internal event types that don't represent conversation content
   if (SKIP_EVENT_TYPES.has(entryType)) {
     return { assistantCompleted, messages };
   }
 
+  const entryTimestamp = str(entry, 'timestamp');
+  const entryUuid = str(entry, 'uuid');
+
   if (entryType === 'user') {
-    const msg = entry.message;
+    const msg = isRecord(entry.message) ? entry.message : null;
     if (!msg?.content) {
       return { assistantCompleted, messages };
     }
 
     const parts: MessagePart[] = [];
-    const content = Array.isArray(msg.content) ? msg.content : [msg.content];
-
-    for (const block of content) {
-      if (typeof block === 'string') {
-        parts.push({ content: block, type: 'text' });
-      } else if (block.type === 'text') {
-        parts.push({ content: block.text || '', type: 'text' });
-      } else if (block.type === 'tool_result') {
-        let output = '';
-        if (typeof block.content === 'string') {
-          output = block.content;
-        } else if (Array.isArray(block.content)) {
-          output = block.content
-            .filter((c: { type: string }) => c.type === 'text')
-            .map((c: { text: string }) => c.text)
-            .join('\n');
+    const blocks = toContentBlocks(msg.content);
+
+    // Handle bare-string content items (not wrapped in a block)
+    if (Array.isArray(msg.content)) {
+      for (const item of msg.content as unknown[]) {
+        if (typeof item === 'string') {
+          parts.push({ content: item, type: 'text' });
         }
-        if (entry.toolUseResult?.content) {
-          const trc = entry.toolUseResult.content;
-          if (typeof trc === 'string') {
-            output = trc;
-          } else if (Array.isArray(trc)) {
-            output = trc
-              .filter((c: { type: string }) => c.type === 'text')
-              .map((c: { text: string }) => c.text)
-              .join('\n');
-          }
+      }
+    } else if (typeof msg.content === 'string') {
+      parts.push({ content: msg.content, type: 'text' });
+    }
+
+    for (const block of blocks) {
+      const blockType = str(block, 'type');
+      if (!blockType) {
+        continue;
+      }
+      if (blockType === 'text') {
+        parts.push({ content: str(block, 'text'), type: 'text' });
+      } else if (blockType === 'tool_result') {
+        let output = extractToolResultText(block.content);
+
+        // Check for toolUseResult override
+        const toolUseResult = isRecord(entry.toolUseResult) ? entry.toolUseResult : null;
+        if (toolUseResult?.content !== undefined) {
+          output = extractToolResultText(toolUseResult.content);
         }
+
         parts.push({
-          isError: block.is_error || false,
+          isError: typeof block.is_error === 'boolean' ? block.is_error : false,
           output: output.slice(0, 2000),
-          toolUseId: block.tool_use_id || '',
+          toolUseId: str(block, 'tool_use_id'),
           type: 'tool_result',
         });
       }
@@ -116,41 +168,44 @@ export function parseJsonlLine(
 
     if (parts.length > 0 && parts.some((p) => p.type === 'text')) {
       messages.push({
-        id: entry.uuid || `user-${messageIndex}`,
+        id: entryUuid || `user-${messageIndex}`,
         parts: parts.filter((p) => p.type === 'text'),
         role: 'user',
-        timestamp: entry.timestamp || '',
+        timestamp: entryTimestamp,
       });
     }
 
     const toolResults = parts.filter((p) => p.type === 'tool_result');
     if (toolResults.length > 0) {
       messages.push({
-        id: `tool-result-${entry.uuid || messageIndex}`,
+        id: `tool-result-${entryUuid || messageIndex}`,
         parts: toolResults,
         role: 'system',
-        timestamp: entry.timestamp || '',
+        timestamp: entryTimestamp,
       });
     }
   } else if (entryType === 'assistant') {
-    const msg = entry.message;
+    const msg = isRecord(entry.message) ? entry.message : null;
     if (!msg?.content) {
       return { assistantCompleted, messages };
     }
 
-    const content = Array.isArray(msg.content) ? msg.content : [msg.content];
-    const msgId = msg.id || entry.uuid;
+    const blocks = toContentBlocks(msg.content);
+    const msgId = str(msg, 'id') || entryUuid;
 
-    for (const block of content) {
+    for (const block of blocks) {
       const part = parseAssistantBlock(block);
       if (!part) {
         continue;
       }
 
       if (!assistantTurns.has(msgId)) {
-        assistantTurns.set(msgId, { parts: [], timestamp: entry.timestamp || '' });
+        assistantTurns.set(msgId, { parts: [], timestamp: entryTimestamp });
+      }
+      const turn = assistantTurns.get(msgId);
+      if (turn) {
+        turn.parts.push(part);
       }
-      assistantTurns.get(msgId)!.parts.push(part);
     }
 
     if (msg.stop_reason) {

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

@@ -1,11 +1,70 @@
+import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from '$lib/types';
+
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 
-import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from './types';
-
 import { parseJsonlText } from './jsonl-parser';
 
+const SYSTEM_TAG_PREFIXES = [
+  '<local-command',
+  '<command-name>',
+  '<command-message>',
+  '<command-args>',
+  '<local-command-stdout>',
+  '<local-command-caveat>',
+  '<system-reminder>',
+  '<task-notification>',
+];
+
+/** Extract plain text from message content (string or array of content blocks). */
+function extractContentText(content: unknown): string {
+  if (typeof content === 'string') {
+    return content.trim();
+  }
+  if (Array.isArray(content)) {
+    for (const b of content) {
+      if (typeof b === 'string' && b.trim()) {
+        return b.trim();
+      }
+      if (typeof b === 'object' && b !== null) {
+        const block = b as Record<string, unknown>;
+        if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
+          return block.text.trim();
+        }
+      }
+    }
+  }
+  return '';
+}
+
+/** Find the first real user prompt from raw JSONL content. */
+function findFirstUserPrompt(content: string): string {
+  for (const line of content.split('\n')) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(line) as Record<string, unknown>;
+      if (entry.type !== 'user') {
+        continue;
+      }
+      const msg = entry.message as Record<string, unknown> | undefined;
+      if (!msg?.content) {
+        continue;
+      }
+      const text = extractContentText(msg.content as unknown);
+      if (!text || SYSTEM_TAG_PREFIXES.some((p) => text.startsWith(p))) {
+        continue;
+      }
+      return text;
+    } catch {
+      continue;
+    }
+  }
+  return '';
+}
+
 // Short hash for project IDs (8 chars from SHA-256)
 function shortHash(input: string): string {
   return crypto.createHash('sha256').update(input).digest('hex').slice(0, 8);
@@ -93,11 +152,13 @@ export function listProjectsWithSessions(): ProjectGroup[] {
     // Sort sessions by modified desc
     sessions.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
 
-    // Prefer projectPath from session index, then cwd from JSONL, then decoded dir name
+    // Prefer projectPath from session index, then cwd from JSONL, then
+    // filesystem-validated decoder, then last-resort naive decoding.
     const realPath =
       sessions.find((s) => s.projectPath && !s.projectPath.includes('.claude/projects'))
         ?.projectPath ||
       readCwdFromProjectDir(projectDir, sessions) ||
+      decodeClaudeProjectDir(dir) ||
       (dir.startsWith('-') ? dir.replace(/-/g, '/') : `/${dir.replace(/-/g, '/')}`);
     const pathSegments = realPath.split('/').filter(Boolean);
     const projectName = pathSegments.slice(-2).join('/');
@@ -122,6 +183,10 @@ export function listSessions(): SessionInfo[] {
   return listSessionsForProject(projectDir);
 }
 
+function bytesReadEnded(chunk: string): boolean {
+  return chunk.length > 0 && chunk.charCodeAt(chunk.length - 1) === 10;
+}
+
 function cleanTitle(prompt: string): string {
   // Strip internal Claude Code XML markup tags, then remove ALL angle-bracket content.
   // Use a loop to handle nested/reconstructed tags (satisfies CodeQL multi-char sanitization).
@@ -157,6 +222,52 @@ function cleanTitle(prompt: string): string {
   return firstLine;
 }
 
+/**
+ * Decode a Claude Code project directory name like "-home-parth-dogra-Desktop-Repo-pr-guardian"
+ * into the real filesystem path "/home/parth-dogra/Desktop/Repo/pr-guardian".
+ *
+ * Claude Code encodes paths by replacing "/" with "-", which is ambiguous when
+ * the original path contains hyphens (e.g. "parth-dogra", "pr-guardian"). This
+ * walks the filesystem from / and greedily matches the longest hyphen-joined
+ * segment that exists as a directory at each step.
+ *
+ * Returns null if no valid decoding exists on this filesystem.
+ */
+function decodeClaudeProjectDir(encoded: string): null | string {
+  if (!encoded.startsWith('-')) {
+    return null;
+  }
+  const parts = encoded.slice(1).split('-');
+  if (parts.length === 0) {
+    return null;
+  }
+
+  let currentPath = '/';
+  let i = 0;
+  while (i < parts.length) {
+    let matchedTo = -1;
+    // Try the longest possible segment first (greedy longest match)
+    for (let j = parts.length; j > i; j--) {
+      const segment = parts.slice(i, j).join('-');
+      const candidate = path.join(currentPath, segment);
+      try {
+        if (fs.statSync(candidate).isDirectory()) {
+          matchedTo = j;
+          break;
+        }
+      } catch {
+        // not a directory / doesn't exist — try a shorter segment
+      }
+    }
+    if (matchedTo === -1) {
+      return null;
+    }
+    currentPath = path.join(currentPath, parts.slice(i, matchedTo).join('-'));
+    i = matchedTo;
+  }
+  return currentPath;
+}
+
 function getProjectDir(): string {
   // Encode project path: /Users/sachinsharma/Developer/Personal/shooter -> -Users-sachinsharma-Developer-Personal-shooter
   const projectPath = process.cwd();
@@ -235,67 +346,17 @@ function listSessionsForProject(projectDir: string): SessionInfo[] {
             const nl = content.indexOf('\n', countPos);
             const lineEnd = nl === -1 ? content.length : nl;
             const line = content.substring(countPos, lineEnd);
-            if (line.includes('"type":"user"') || line.includes('"type":"assistant"')) {messageCount++;}
-            if (nl === -1) {break;}
-            countPos = nl + 1;
-          }
-          // Find the first real user message (skip system caveats, commands, tool results)
-          const lines = content.split('\n');
-          for (const line of lines) {
-            if (!line.trim()) {
-              continue;
+            if (line.includes('"type":"user"') || line.includes('"type":"assistant"')) {
+              messageCount++;
             }
-            try {
-              const entry = JSON.parse(line);
-              if (entry.type !== 'user') {
-                continue;
-              }
-              const msg = entry.message;
-              if (!msg?.content) {
-                continue;
-              }
-
-              // Extract text from content (can be string or array of blocks)
-              let text = '';
-              if (typeof msg.content === 'string') {
-                text = msg.content.trim();
-              } else if (Array.isArray(msg.content)) {
-                for (const b of msg.content) {
-                  if (typeof b === 'string' && b.trim()) {
-                    text = b.trim();
-                    break;
-                  }
-                  if (typeof b === 'object' && b !== null && b.type === 'text' && b.text?.trim()) {
-                    text = b.text.trim();
-                    break;
-                  }
-                }
-              }
-
-              if (!text) {
-                continue;
-              }
-
-              // Skip system-injected caveats and command outputs
-              // Keep aligned with cleanTitle() tag stripping
-              if (
-                text.startsWith('<local-command') ||
-                text.startsWith('<command-name>') ||
-                text.startsWith('<command-message>') ||
-                text.startsWith('<command-args>') ||
-                text.startsWith('<local-command-stdout>') ||
-                text.startsWith('<local-command-caveat>') ||
-                text.startsWith('<system-reminder>') ||
-                text.startsWith('<task-notification>')
-              ) {
-                continue;
-              }
-
-              firstPrompt = text;
+            if (nl === -1) {
               break;
-            } catch {
-              continue;
             }
+            countPos = nl + 1;
+          }
+          const prompt = findFirstUserPrompt(content);
+          if (prompt) {
+            firstPrompt = prompt;
           }
         } catch {
           // ignore read errors
@@ -325,33 +386,40 @@ function listSessionsForProject(projectDir: string): SessionInfo[] {
 }
 
 function readCwdFromProjectDir(projectDir: string, sessions: SessionInfo[]): string {
+  // Scan complete JSONL lines until we find one with cwd. Newer Claude Code
+  // versions write metadata lines (permission-mode, file-history-snapshot)
+  // first, so cwd only appears on line 2+.
+  const READ_BYTES = 65536;
   for (const session of sessions) {
     try {
       const filePath = path.join(projectDir, `${session.id}.jsonl`);
       if (!fs.existsSync(filePath)) {
         continue;
       }
-      // Only read the first 4KB — cwd appears on line 1
       const fd = fs.openSync(filePath, 'r');
-      let firstChunk: string;
+      let chunk: string;
       try {
-        const buf = Buffer.alloc(4096);
-        const bytesRead = fs.readSync(fd, buf, 0, 4096, 0);
-        firstChunk = buf.toString('utf-8', 0, bytesRead);
+        const buf = Buffer.alloc(READ_BYTES);
+        const bytesRead = fs.readSync(fd, buf, 0, READ_BYTES, 0);
+        chunk = buf.toString('utf-8', 0, bytesRead);
       } finally {
         fs.closeSync(fd);
       }
-      const firstLine = firstChunk.split('\n')[0];
-      if (!firstLine.trim()) {
-        continue;
-      }
-      try {
-        const entry = JSON.parse(firstLine) as Record<string, unknown>;
-        if (typeof entry.cwd === 'string' && entry.cwd) {
-          return entry.cwd;
+      const lines = chunk.split('\n');
+      // Drop the last line if the chunk was truncated mid-line
+      const completeLines = bytesReadEnded(chunk) ? lines : lines.slice(0, -1);
+      for (const line of completeLines) {
+        if (!line.trim()) {
+          continue;
+        }
+        try {
+          const entry = JSON.parse(line) as Record<string, unknown>;
+          if (typeof entry.cwd === 'string' && entry.cwd) {
+            return entry.cwd;
+          }
+        } catch {
+          // skip malformed line and try the next one
         }
-      } catch {
-        // skip malformed first line
       }
     } catch {
       // skip unreadable files

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

@@ -6,7 +6,7 @@ function shortHash(input: string): string {
   return crypto.createHash('sha256').update(input).digest('hex').slice(0, 8);
 }
 
-import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from './types';
+import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from '$lib/types';
 
 import { resolveOpenCodeDbPath } from './opencode-db-path';
 

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

@@ -1,30 +1,12 @@
-import { readdirSync, readFileSync } from 'fs';
+import type { ClaudeSessionFile, DetectedProcess } from '$lib/types';
+
+import { resolveOpenCodeDbPath } from '$lib/modules/server/sessions/opencode-db-path';
+import Database from 'better-sqlite3';
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface DetectedProcess {
-  command: 'claude' | 'opencode';
-  cwd: string;
-  kind: string;
-  pid: number;
-  projectPath: string;
-  sessionId: string;
-  startedAt: number;
-}
-
-interface ClaudeSessionFile {
-  cwd: string;
-  entrypoint: string;
-  kind: string;
-  pid: number;
-  sessionId: string;
-  startedAt: number;
-}
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -34,6 +16,16 @@ function cwdToProjectPath(cwd: string): string {
   return cwd.replace(/\//g, '-');
 }
 
+/** Check if any `opencode` process is currently running. */
+function isOpenCodeRunning(): boolean {
+  try {
+    execSync('pgrep -x opencode', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /** Check if a process with the given PID is alive. */
 function isProcessAlive(pid: number): boolean {
   try {
@@ -50,12 +42,12 @@ function isProcessAlive(pid: number): boolean {
 
 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
+
 /**
- * Scan ~/.claude/sessions/*.json to find running Claude Code processes.
- * Each file is named <PID>.json and contains:
- *   { pid, sessionId, cwd, startedAt, kind, entrypoint }
- *
- * For each file we verify the PID is still alive via process.kill(pid, 0).
+ * Scan ~/.claude/sessions/*.json to find running Claude Code processes,
+ * and query the OpenCode SQLite DB for recently active sessions.
  */
 export function detectRunningAISessions(): DetectedProcess[] {
   const results: DetectedProcess[] = [];
@@ -94,10 +86,59 @@ export function detectRunningAISessions(): DetectedProcess[] {
     // ~/.claude/sessions/ may not exist — that's fine
   }
 
+  // --- OpenCode sessions ---
+  // Only query the DB if an opencode process is actually running.
+  if (isOpenCodeRunning()) {
+    try {
+      const dbPath = resolveOpenCodeDbPath();
+      if (existsSync(dbPath)) {
+        const db = new Database(dbPath, { readonly: true });
+        try {
+          const cutoff = Date.now() - OPENCODE_ACTIVE_THRESHOLD_MS;
+          const cutoffSec = Math.floor(cutoff / 1000);
+
+          const rows = db
+            .prepare(
+              `SELECT id, directory, time_created, time_updated
+               FROM session
+               WHERE (time_archived IS NULL OR time_archived = 0)
+                 AND (
+                   (time_updated >= 1e12 AND time_updated > ?)
+                   OR (time_updated < 1e12 AND time_updated > ?)
+                 )
+               ORDER BY time_updated DESC
+               LIMIT 20`
+            )
+            .all(cutoff, cutoffSec) as {
+            directory: string;
+            id: string;
+            time_created: number;
+            time_updated: number;
+          }[];
+
+          for (const row of rows) {
+            const startMs = row.time_created >= 1e12 ? row.time_created : row.time_created * 1000;
+            results.push({
+              command: 'opencode',
+              cwd: row.directory || '',
+              kind: 'interactive',
+              pid: 0, // OpenCode doesn't expose per-session PIDs
+              projectPath: cwdToProjectPath(row.directory || ''),
+              sessionId: row.id,
+              startedAt: startMs,
+            });
+          }
+        } finally {
+          db.close();
+        }
+      }
+    } catch {
+      // OpenCode DB missing or unreadable — skip silently
+    }
+  }
+
   // Sort by startedAt descending (most recent first)
   results.sort((a, b) => b.startedAt - a.startedAt);
 
-  // TODO: Add OpenCode process detection (check running opencode processes or query SQLite DB)
-
   return results;
 }

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

@@ -1,42 +1,2 @@
-// Re-export generated types that match 1:1
-export type { MessageRole, ProjectGroup, SessionInfo } from '$generated/types';
-import type { MessageRole } from '$generated/types';
-
-// ── Local interfaces ─────────────────────────────────────────────────
-// These remain local because the generated versions differ structurally:
-// generated MessagePart uses wrapper classes (CMessagePartTextPart, etc.)
-// and part types use `type: string` instead of string literals needed
-// for discriminated unions. Declared as interfaces per ESLint rules.
-
-export interface ConversationMessage {
-  id: string;
-  parts: MessagePart[];
-  role: MessageRole;
-  timestamp: string;
-}
-
-export type MessagePart = TextPart | ThinkingPart | ToolResultPart | ToolUsePart;
-
-export interface TextPart {
-  content: string;
-  type: 'text';
-}
-
-export interface ThinkingPart {
-  content: string;
-  type: 'thinking';
-}
-
-export interface ToolResultPart {
-  isError: boolean;
-  output: string;
-  toolUseId: string;
-  type: 'tool_result';
-}
-
-export interface ToolUsePart {
-  id: string;
-  input: Record<string, unknown>;
-  toolName: string;
-  type: 'tool_use';
-}
+// All session types have been moved to $lib/types/sessions.ts.
+// Import from '$lib/types' instead of this file.