@juspay/shooter 1.4.0 → 1.6.0

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);
@@ -235,67 +294,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

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.

package/src/lib/modules/server/terminal/holder-client.ts

@@ -7,33 +7,14 @@
  * so PtyManager can slot it in as `ManagedTerminal.pty`.
  */
 
-import type { ConnectResult } from '$generated/types';
+import type {
+  ConnectResult,
+  HolderIncomingMessage as IncomingMessage,
+  HolderOutgoingMessage as OutgoingMessage,
+} from '$lib/types';
 
 import * as net from 'net';
 
-// ── Local Protocol Types ──────────────────────────────────────────────
-// The generated union types (IncomingMessage, OutgoingMessage) use
-// class wrappers and non-literal discriminants, making them hard to
-// narrow with switch/case. We keep simple local types matching the
-// ndjson protocol from the design spec for runtime dispatch.
-
-/** Messages received from the holder process. */
-type IncomingMessage =
-  | { active: boolean; type: 'activity' }
-  | { code: null | number; signal: null | string; type: 'exit' }
-  | { data: string; type: 'output' }
-  | { data: string; type: 'scrollback' }
-  | { exitCode: null | number; exited: boolean; pid: number; type: 'info' }
-  | { path: string; type: 'cwd' };
-
-// ── Connect Result ────────────────────────────────────────────────────
-
-/** Messages sent to the holder process. */
-type OutgoingMessage =
-  | { cols: number; rows: number; type: 'resize' }
-  | { data: string; type: 'input' }
-  | { signal?: string; type: 'kill' };
-
 // ── HolderClient ──────────────────────────────────────────────────────
 
 export class HolderClient {
@@ -92,7 +73,7 @@ export class HolderClient {
         const lines = this.lineBuf.split('\n');
         // Keep the last element — it is either empty (complete line)
         // or a partial line still being received.
-        this.lineBuf = lines.pop()!;
+        this.lineBuf = lines.pop() ?? '';
 
         for (const line of lines) {
           if (line.length === 0) {
@@ -101,11 +82,6 @@ export class HolderClient {
 
           let msg: IncomingMessage;
           try {
-            // TODO: Apply generated holder decoders (decodeHolderClientMessage)
-            // at this socket boundary once the generated union discriminant
-            // types support literal narrowing with switch/case. Currently the
-            // generated wrappers use non-literal discriminants, so we keep
-            // local IncomingMessage types for runtime dispatch.
             msg = JSON.parse(line) as IncomingMessage;
           } catch {
             continue;
@@ -126,16 +102,16 @@ export class HolderClient {
 
             // Handshake complete once we have info.
             if (info !== null) {
-              const settle = () => {
-                if (settled) {
+              const settle = (): void => {
+                if (settled || !info) {
                   return;
                 }
                 settled = true;
                 clearTimeout(handshakeTimer);
                 resolve({
-                  exitCode: info!.exitCode,
-                  exited: info!.exited,
-                  pid: info!.pid,
+                  exitCode: info.exitCode,
+                  exited: info.exited,
+                  pid: info.pid,
                   scrollback,
                 });
                 // Replay queued messages in the next macrotask so that