@juspay/shooter 1.0.0

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

@@ -0,0 +1,301 @@
+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';
+
+// 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);
+}
+
+// Path to Claude Code's project session data
+const CLAUDE_PROJECTS_DIR = path.join(process.env.HOME || '', '.claude', 'projects');
+
+export function getSessionConversation(
+  sessionId: string,
+  offset = 0,
+  limit = 100,
+  projectId?: string
+): ConversationMessage[] {
+  const projectDir = projectId ? path.join(CLAUDE_PROJECTS_DIR, projectId) : getProjectDir();
+  const jsonlPath = path.join(projectDir, `${sessionId}.jsonl`);
+
+  if (!fs.existsSync(jsonlPath)) {
+    return [];
+  }
+
+  try {
+    const raw = fs.readFileSync(jsonlPath, 'utf-8');
+    const assistantTurns = new Map<string, { parts: MessagePart[]; timestamp: string }>();
+    const messages = parseJsonlText(raw, assistantTurns, 0);
+
+    // Flush any remaining assistant turns
+    for (const [msgId, turn] of assistantTurns) {
+      if (turn.parts.length > 0) {
+        messages.push({
+          id: msgId,
+          parts: turn.parts,
+          role: 'assistant',
+          timestamp: turn.timestamp,
+        });
+      }
+    }
+
+    return messages.slice(offset, offset + limit);
+  } catch (error) {
+    console.error('[sessions] Failed to parse session JSONL:', error);
+    return [];
+  }
+}
+
+export function listProjectsWithSessions(): ProjectGroup[] {
+  if (!fs.existsSync(CLAUDE_PROJECTS_DIR)) {
+    return [];
+  }
+
+  let projectDirs: string[];
+  try {
+    projectDirs = fs.readdirSync(CLAUDE_PROJECTS_DIR).filter((d) => {
+      const fullPath = path.join(CLAUDE_PROJECTS_DIR, d);
+      try {
+        return fs.statSync(fullPath).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+
+  const projects: ProjectGroup[] = [];
+
+  for (const dir of projectDirs) {
+    const projectDir = path.join(CLAUDE_PROJECTS_DIR, dir);
+    // Decode project path (fallback, prefer session's projectPath)
+    const decodedPath = dir.startsWith('-') ? dir.replace(/-/g, '/') : `/${dir.replace(/-/g, '/')}`;
+
+    // Get sessions for this project
+    const sessions = listSessionsForProject(projectDir);
+    if (sessions.length === 0) {
+      continue;
+    }
+
+    // Sort sessions by modified desc
+    sessions.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+
+    // Get real project path from session data instead of decoding directory name
+    const realPath =
+      sessions.find((s) => s.projectPath && !s.projectPath.includes('.claude/projects'))
+        ?.projectPath || decodedPath;
+    const pathSegments = realPath.split('/').filter(Boolean);
+    const projectName = pathSegments.slice(-2).join('/');
+
+    projects.push({
+      fullPath: realPath,
+      id: shortHash(realPath),
+      lastModified: sessions[0]?.modified || '',
+      name: projectName,
+      sessionCount: sessions.length,
+      sessions,
+    });
+  }
+
+  return projects.sort(
+    (a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+  );
+}
+
+export function listSessions(): SessionInfo[] {
+  const projectDir = getProjectDir();
+  return listSessionsForProject(projectDir);
+}
+
+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).
+  let cleaned = prompt
+    .replace(/<command-message>.*?<\/command-message>/gs, '')
+    .replace(/<command-name>.*?<\/command-name>/gs, '')
+    .replace(/<command-args>.*?<\/command-args>/gs, '')
+    .replace(/<local-command-caveat>.*?<\/local-command-caveat>/gs, '')
+    .replace(/<local-command-stdout>.*?<\/local-command-stdout>/gs, '')
+    .replace(/<system-reminder>.*?<\/system-reminder>/gs, '');
+
+  // Iteratively strip tags until none remain (prevents reconstructed tags like "<scr" + "ipt>")
+  let prev = '';
+  while (prev !== cleaned) {
+    prev = cleaned;
+    cleaned = cleaned.replace(/<[^>]*>/g, '').replace(/</g, '');
+  }
+  cleaned = cleaned.trim();
+
+  if (!cleaned) {
+    return 'Untitled Session';
+  }
+
+  // Take first line, trim, cap at 80 chars
+  const firstLine = cleaned.split('\n')[0].trim();
+  if (!firstLine) {
+    return 'Untitled Session';
+  }
+  if (firstLine.length > 80) {
+    return `${firstLine.slice(0, 77)}...`;
+  }
+  return firstLine;
+}
+
+function getProjectDir(): string {
+  // Encode project path: /Users/sachinsharma/Developer/Personal/shooter -> -Users-sachinsharma-Developer-Personal-shooter
+  const projectPath = process.cwd();
+  const encoded = projectPath.replace(/\//g, '-');
+  return path.join(CLAUDE_PROJECTS_DIR, encoded);
+}
+
+function listSessionsForProject(projectDir: string): SessionInfo[] {
+  const indexPath = path.join(projectDir, 'sessions-index.json');
+
+  if (!fs.existsSync(indexPath)) {
+    return [];
+  }
+
+  try {
+    const raw = fs.readFileSync(indexPath, 'utf-8');
+    const index = JSON.parse(raw) as {
+      entries: {
+        created?: string;
+        firstPrompt?: string;
+        gitBranch?: string;
+        isSidechain?: boolean;
+        messageCount?: number;
+        modified?: string;
+        projectPath?: string;
+        sessionId: string;
+        summary?: string;
+      }[];
+    };
+
+    const indexedIds = new Set<string>();
+    const sessions: SessionInfo[] = index.entries
+      .filter((e) => !e.isSidechain)
+      .filter((e) => {
+        const jsonlFile = path.join(projectDir, `${e.sessionId}.jsonl`);
+        return fs.existsSync(jsonlFile);
+      })
+      .map((entry) => {
+        indexedIds.add(entry.sessionId);
+        return {
+          created: entry.created || '',
+          gitBranch: entry.gitBranch || '',
+          id: entry.sessionId,
+          messageCount: entry.messageCount || 0,
+          modified: entry.modified || '',
+          projectPath: entry.projectPath || '',
+          source: 'claude-code' as const,
+          summary: entry.summary || '',
+          title: cleanTitle(entry.firstPrompt || entry.summary || 'Untitled Session'),
+        };
+      });
+
+    // Also scan for JSONL files not in the index (e.g., active sessions)
+    try {
+      const files = fs.readdirSync(projectDir);
+      for (const file of files) {
+        if (!file.endsWith('.jsonl')) {
+          continue;
+        }
+        const sessionId = file.replace('.jsonl', '');
+        if (indexedIds.has(sessionId)) {
+          continue;
+        }
+        // Read first user message as title
+        const filePath = path.join(projectDir, file);
+        const stat = fs.statSync(filePath);
+        let firstPrompt = 'Active Session';
+        let messageCount = 0;
+        try {
+          const content = fs.readFileSync(filePath, 'utf-8');
+          // Count user + assistant messages for the message count
+          const lines = content.split('\n');
+          for (const line of lines) {
+            if (!line.trim()) { continue; }
+            try {
+              const entry = JSON.parse(line);
+              if (entry.type === 'user' || entry.type === 'assistant') {
+                messageCount++;
+              }
+            } catch {
+              // skip malformed lines
+            }
+          }
+          // Find the first real user message (skip system caveats, commands, tool results)
+          for (const line of lines) {
+            if (!line.trim()) { continue; }
+            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
+              if (text.startsWith('<local-command') ||
+                  text.startsWith('<command-name>') ||
+                  text.startsWith('<local-command-stdout>') ||
+                  text.startsWith('<system-reminder>') ||
+                  text.startsWith('<task-notification>')) {
+                continue;
+              }
+
+              firstPrompt = text;
+              break;
+            } catch {
+              continue;
+            }
+          }
+        } catch {
+          // ignore read errors
+        }
+
+        sessions.push({
+          created: stat.birthtime.toISOString(),
+          gitBranch: '',
+          id: sessionId,
+          messageCount,
+          modified: stat.mtime.toISOString(),
+          projectPath: '',
+          source: 'claude-code' as const,
+          summary: '',
+          title: cleanTitle(firstPrompt),
+        });
+      }
+    } catch {
+      // ignore scan errors
+    }
+
+    return sessions.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+  } catch (error) {
+    console.error('[sessions] Failed to read sessions index:', error);
+    return [];
+  }
+}

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

@@ -0,0 +1,264 @@
+import Database from 'better-sqlite3';
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+
+function shortHash(input: string): string {
+  return crypto.createHash('sha256').update(input).digest('hex').slice(0, 8);
+}
+
+import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from './types';
+
+const OPENCODE_DB_PATH = path.join(
+  process.env.HOME || '',
+  '.local',
+  'share',
+  'opencode',
+  'opencode.db'
+);
+
+export function getOpenCodeConversation(
+  sessionId: string,
+  offset = 0,
+  limit = 100
+): ConversationMessage[] {
+  const db = getDb();
+  if (!db) {
+    return [];
+  }
+
+  try {
+    // Get messages for this session
+    const messages = db
+      .prepare(
+        `
+      SELECT id, session_id, time_created, data
+      FROM message
+      WHERE session_id = ?
+      ORDER BY time_created ASC
+      LIMIT ? OFFSET ?
+    `
+      )
+      .all(sessionId, limit, offset) as {
+      data: string;
+      id: string;
+      session_id: string;
+      time_created: number;
+    }[];
+
+    // Get parts for these messages
+    const messageIds = messages.map((m) => m.id);
+    if (messageIds.length === 0) {
+      return [];
+    }
+
+    const placeholders = messageIds.map(() => '?').join(',');
+    const parts = db
+      .prepare(
+        `
+      SELECT id, message_id, time_created, data
+      FROM part
+      WHERE message_id IN (${placeholders})
+      ORDER BY time_created ASC
+    `
+      )
+      .all(...messageIds) as {
+      data: string;
+      id: string;
+      message_id: string;
+      time_created: number;
+    }[];
+
+    // Group parts by message
+    const partsByMessage = new Map<string, typeof parts>();
+    for (const part of parts) {
+      if (!partsByMessage.has(part.message_id)) {
+        partsByMessage.set(part.message_id, []);
+      }
+      const bucket = partsByMessage.get(part.message_id);
+      if (bucket) {
+        bucket.push(part);
+      }
+    }
+
+    // Build ConversationMessage array
+    const result: ConversationMessage[] = [];
+
+    for (const msg of messages) {
+      let msgData: { agent?: string; role?: string } = {};
+      try {
+        msgData = JSON.parse(msg.data) as typeof msgData;
+      } catch {
+        // skip unparseable message data
+      }
+
+      const role = msgData.role === 'user' ? 'user' : 'assistant';
+      const msgParts = partsByMessage.get(msg.id) || [];
+      const convertedParts: MessagePart[] = [];
+
+      for (const part of msgParts) {
+        let partData: Record<string, unknown> = {};
+        try {
+          partData = JSON.parse(part.data) as Record<string, unknown>;
+        } catch {
+          continue;
+        }
+
+        const converted = convertOpenCodePart(partData);
+        if (converted) {
+          convertedParts.push(converted);
+        }
+      }
+
+      if (convertedParts.length > 0) {
+        result.push({
+          id: msg.id,
+          parts: convertedParts,
+          role: role as 'assistant' | 'system' | 'user',
+          timestamp: new Date(msg.time_created).toISOString(),
+        });
+      }
+    }
+
+    return result;
+  } catch (error) {
+    console.error('[opencode] Failed to read conversation:', error);
+    return [];
+  } finally {
+    db.close();
+  }
+}
+
+export function listOpenCodeProjects(): ProjectGroup[] {
+  const db = getDb();
+  if (!db) {
+    return [];
+  }
+
+  try {
+    // Get all sessions with their directories
+    const sessions = db
+      .prepare(
+        `
+      SELECT id, directory, title, slug, time_created, time_updated, parent_id
+      FROM session
+      WHERE time_archived IS NULL OR time_archived = 0
+      ORDER BY time_updated DESC
+    `
+      )
+      .all() as {
+      directory: string;
+      id: string;
+      parent_id: null | string;
+      slug: null | string;
+      time_created: number;
+      time_updated: number;
+      title: null | string;
+    }[];
+
+    // Get message counts per session
+    const msgCounts = db
+      .prepare(`SELECT session_id, COUNT(*) as count FROM message GROUP BY session_id`)
+      .all() as { count: number; session_id: string }[];
+    const msgCountMap = new Map(msgCounts.map((r) => [r.session_id, r.count]));
+
+    // Group by directory (project)
+    const projectMap = new Map<string, SessionInfo[]>();
+
+    for (const row of sessions) {
+      const dir = row.directory || 'unknown';
+      if (!projectMap.has(dir)) {
+        projectMap.set(dir, []);
+      }
+
+      const sessionInfo: SessionInfo = {
+        created: new Date(row.time_created).toISOString(),
+        gitBranch: '',
+        id: row.id,
+        messageCount: msgCountMap.get(row.id) || 0,
+        modified: new Date(row.time_updated).toISOString(),
+        projectPath: dir,
+        source: 'opencode' as const,
+        summary: '',
+        title: row.title || row.slug || 'Untitled Session',
+      };
+
+      const bucket = projectMap.get(dir);
+      if (bucket) {
+        bucket.push(sessionInfo);
+      }
+    }
+
+    // Build ProjectGroup array
+    const projects: ProjectGroup[] = [];
+
+    for (const [dir, dirSessions] of projectMap) {
+      const pathSegments = dir.split('/').filter(Boolean);
+      const projectName = pathSegments.slice(-2).join('/');
+
+      // Sort sessions by modified desc
+      dirSessions.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+
+      projects.push({
+        fullPath: dir,
+        id: shortHash(dir),
+        lastModified: dirSessions[0]?.modified || '',
+        name: `${projectName} (OpenCode)`,
+        sessionCount: dirSessions.length,
+        sessions: dirSessions,
+      });
+    }
+
+    return projects.sort(
+      (a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+    );
+  } catch (error) {
+    console.error('[opencode] Failed to read sessions:', error);
+    return [];
+  } finally {
+    db.close();
+  }
+}
+
+function convertOpenCodePart(data: Record<string, unknown>): MessagePart | null {
+  const type = data.type as string;
+
+  switch (type) {
+    case 'reasoning':
+      return {
+        content: (data.text as string) || '',
+        type: 'thinking',
+      };
+
+    case 'text':
+      return {
+        content: (data.text as string) || '',
+        type: 'text',
+      };
+
+    case 'tool': {
+      const state = data.state as Record<string, unknown> | undefined;
+      return {
+        id: (data.callID as string) || (data.id as string) || '',
+        input: (state?.input as Record<string, unknown>) || {},
+        toolName: (data.tool as string) || 'Unknown',
+        type: 'tool_use',
+      };
+    }
+
+    default:
+      // Skip snapshot, patch, step-start, step-finish, subtask, retry, compaction
+      return null;
+  }
+}
+
+function getDb(): Database.Database | null {
+  if (!fs.existsSync(OPENCODE_DB_PATH)) {
+    return null;
+  }
+  try {
+    return new Database(OPENCODE_DB_PATH, { readonly: true });
+  } catch {
+    return null;
+  }
+}

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

@@ -0,0 +1,53 @@
+export interface ConversationMessage {
+  id: string;
+  parts: MessagePart[];
+  role: 'assistant' | 'system' | 'user';
+  timestamp: string;
+}
+
+export type MessagePart = TextPart | ThinkingPart | ToolResultPart | ToolUsePart;
+
+export interface ProjectGroup {
+  fullPath: string;
+  id: string;
+  lastModified: string;
+  name: string;
+  sessionCount: number;
+  sessions: SessionInfo[];
+}
+
+export interface SessionInfo {
+  created: string;
+  gitBranch: string;
+  id: string;
+  messageCount: number;
+  modified: string;
+  projectPath: string;
+  source: 'claude-code' | 'opencode';
+  summary: string;
+  title: string;
+}
+
+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';
+}