@juspay/shooter 1.1.0 → 1.2.0

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

@@ -1,7 +1,6 @@
 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);
@@ -9,18 +8,14 @@ function shortHash(input: string): string {
 
 import type { ConversationMessage, MessagePart, ProjectGroup, SessionInfo } from './types';
 
-const OPENCODE_DB_PATH = path.join(
-  process.env.HOME || '',
-  '.local',
-  'share',
-  'opencode',
-  'opencode.db'
-);
+import { resolveOpenCodeDbPath } from './opencode-db-path';
+
+const OPENCODE_DB_PATH = resolveOpenCodeDbPath();
 
 export function getOpenCodeConversation(
   sessionId: string,
   offset = 0,
-  limit = 100
+  limit = 200
 ): ConversationMessage[] {
   const db = getDb();
   if (!db) {
@@ -28,15 +23,18 @@ export function getOpenCodeConversation(
   }
 
   try {
-    // Get messages for this session
+    // Get the LAST `limit` messages (most recent conversation)
+    // by using a subquery to reverse the order
     const messages = db
       .prepare(
         `
-      SELECT id, session_id, time_created, data
-      FROM message
-      WHERE session_id = ?
-      ORDER BY time_created ASC
-      LIMIT ? OFFSET ?
+      SELECT id, session_id, time_created, data FROM (
+        SELECT id, session_id, time_created, data
+        FROM message
+        WHERE session_id = ?
+        ORDER BY time_created DESC
+        LIMIT ? OFFSET ?
+      ) ORDER BY time_created ASC
     `
       )
       .all(sessionId, limit, offset) as {

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

@@ -0,0 +1,103 @@
+import { 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
+// ---------------------------------------------------------------------------
+
+/** Encode a cwd path to the Claude Code project directory format. */
+function cwdToProjectPath(cwd: string): string {
+  return cwd.replace(/\//g, '-');
+}
+
+/** Check if a process with the given PID is alive. */
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main detector
+// ---------------------------------------------------------------------------
+
+const CLAUDE_SESSIONS_DIR = join(homedir(), '.claude', 'sessions');
+
+/**
+ * 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).
+ */
+export function detectRunningAISessions(): DetectedProcess[] {
+  const results: DetectedProcess[] = [];
+
+  // --- Claude Code sessions ---
+  try {
+    const files = readdirSync(CLAUDE_SESSIONS_DIR).filter((f) => f.endsWith('.json'));
+
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(CLAUDE_SESSIONS_DIR, file), 'utf-8');
+        const data = JSON.parse(raw) as ClaudeSessionFile;
+
+        if (!data.pid || !data.sessionId || !data.cwd) {
+          continue;
+        }
+
+        if (!isProcessAlive(data.pid)) {
+          continue;
+        }
+
+        results.push({
+          command: 'claude',
+          cwd: data.cwd,
+          kind: data.kind || 'interactive',
+          pid: data.pid,
+          projectPath: cwdToProjectPath(data.cwd),
+          sessionId: data.sessionId,
+          startedAt: data.startedAt || 0,
+        });
+      } catch {
+        // Skip malformed or unreadable files
+      }
+    }
+  } catch {
+    // ~/.claude/sessions/ may not exist — that's fine
+  }
+
+  // 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/terminal/opencode-watcher.ts

@@ -20,25 +20,14 @@ import type {
 
 import Database from 'better-sqlite3';
 import * as fs from 'fs';
-import * as path from 'path';
 
 import type { ConversationMessage, MessagePart } from '../sessions/types';
 
+import { resolveOpenCodeDbPath } from '../sessions/opencode-db-path';
+
 // ── Constants ────────────────────────────────────────────────────────
 
-const OPENCODE_DB_PATH = (() => {
-  if (process.platform === 'darwin') {
-    return path.join(
-      process.env.HOME || '',
-      'Library',
-      'Application Support',
-      'opencode',
-      'opencode.db'
-    );
-  }
-  const xdgData = process.env.XDG_DATA_HOME || path.join(process.env.HOME || '', '.local', 'share');
-  return path.join(xdgData, 'opencode', 'opencode.db');
-})();
+const OPENCODE_DB_PATH = resolveOpenCodeDbPath();
 
 /** Poll interval in milliseconds. */
 const POLL_INTERVAL_MS = 2000;

package/src/lib/modules/server/terminal/pty-manager.ts

@@ -856,6 +856,26 @@ class PtyManager {
         'projects',
         cwd.replace(/\//g, '-')
       );
+
+      // Fast path: `claude --resume <uuid>` resumes an existing session whose
+      // JSONL file was created before this terminal launched. The birthtime
+      // filter used in the polling loop would never find it, so check directly.
+      const resumeIdx = terminal.args.indexOf('--resume');
+      if (resumeIdx !== -1 && resumeIdx + 1 < terminal.args.length) {
+        const resumeId = terminal.args[resumeIdx + 1];
+        // Validate resumeId is a safe identifier (UUID or hex string, no path separators)
+        if (!/^[0-9a-f-]+$/i.test(resumeId)) {
+          console.warn(`[pty-manager] Invalid resume ID: ${resumeId}`);
+        } else {
+          const resumeFile = path.join(projectDir, `${resumeId}.jsonl`);
+          if (existsSync(resumeFile)) {
+            terminal.sessionFile = resumeFile;
+            terminalStore.update(id, { sessionFile: resumeFile });
+            return; // File found immediately — no polling needed
+          }
+        }
+      }
+
       const launchTime = terminal.createdAt.getTime();
 
       terminal.pollTimer = setInterval(() => {
@@ -864,11 +884,6 @@ class PtyManager {
             clearInterval(terminal.pollTimer);
             terminal.pollTimer = null;
           }
-          if (terminal.sessionFile) {
-            // No-op: session-handler.ts subscribes when a client connects.
-            // Previously called sessionWatcher.watch() with an empty callback,
-            // which blocked real subscribers due to the single-callback guard.
-          }
           return;
         }
         try {
@@ -898,9 +913,6 @@ class PtyManager {
               clearInterval(terminal.pollTimer);
               terminal.pollTimer = null;
             }
-            // No-op: session-handler.ts subscribes when a client connects.
-            // Previously called sessionWatcher.watch() with an empty callback,
-            // which blocked real subscribers due to the single-callback guard.
             // Persist session file to SQLite
             terminalStore.update(id, { sessionFile: terminal.sessionFile });
           }