forkoff 1.0.17 → 1.0.19

package/dist/tools/claude-process.d.ts

@@ -52,6 +52,8 @@ interface ClaudeApprovalRequest {
     context: string[];
     options: string[];
     promptText: string;
+    toolName?: string;
+    toolInput?: any;
 }
 /** SDK message structure received from Claude CLI JSONL output */
 interface SdkMessage {
@@ -122,12 +124,15 @@ interface ToolActivityEvent {
     inputSummary: string;
 }
 declare class ClaudeProcessManager extends EventEmitter {
+    private static readonly MAX_ACTIVE_PROCESSES;
+    private static readonly MAX_PENDING_APPROVALS;
     private processes;
     private pendingApprovals;
     private readonly APPROVAL_TIMEOUT_MS;
     private readonly MAX_OUTPUT_BUFFER_LINES;
     /** Track closed sessions for auto-restart */
     private closedSessions;
+    private static readonly MAX_CLOSED_SESSIONS;
     /** Maximum number of auto-restarts per session to prevent chaos */
     private readonly MAX_AUTO_RESTARTS;
     /** Permission IPC managers per session */
@@ -138,6 +143,7 @@ declare class ClaudeProcessManager extends EventEmitter {
     private hookConfiguredDirs;
     /** Track sessions that mobile has explicitly taken over (via claude_resume_session) */
     private takenOverSessions;
+    private static readonly MAX_TAKEN_OVER_SESSIONS;
     /** Type-safe emit for known events */
     emit<K extends keyof ClaudeProcessManagerEvents>(event: K, ...args: ClaudeProcessManagerEvents[K]): boolean;
     /** Type-safe on for known events */
@@ -207,6 +213,8 @@ declare class ClaudeProcessManager extends EventEmitter {
         sessionKey?: string;
         directory: string;
     }>;
+    /** Enforce cap on active processes to prevent resource exhaustion */
+    private enforceProcessCap;
     /**
      * Clean up old closed session entries to prevent memory leaks.
      * Sessions older than 1 hour are removed.

package/dist/tools/claude-process.js

@@ -47,6 +47,94 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const permission_ipc_1 = require("./permission-ipc");
+/**
+ * Returns a filtered copy of process.env with sensitive variables removed.
+ * Prevents accidental leakage of credentials to Claude child processes.
+ */
+function getSafeEnv() {
+    const sensitivePatterns = [
+        /^AWS_/i,
+        /^AZURE_/i,
+        /^GCP_/i,
+        /^GOOGLE_/i,
+        /SECRET/i,
+        /PASSWORD/i,
+        /PRIVATE_KEY/i,
+        /^SUPABASE_SERVICE/i,
+        /^DATABASE_URL$/i,
+        /^ADMIN_API_KEY$/i,
+        // Prevent code injection via environment variables
+        /^NODE_OPTIONS$/i,
+        /^NODE_EXTRA_CA_CERTS$/i,
+        /^LD_PRELOAD$/i,
+        /^LD_LIBRARY_PATH$/i,
+        /^DYLD_INSERT_LIBRARIES$/i,
+        /^DYLD_LIBRARY_PATH$/i,
+        /^ELECTRON_RUN_AS_NODE$/i,
+        // Language-specific code injection vectors
+        /^PYTHONPATH$/i,
+        /^PYTHONSTARTUP$/i,
+        /^RUBYLIB$/i,
+        /^PERL5LIB$/i,
+        /^PERL5OPT$/i,
+        /^JAVA_TOOL_OPTIONS$/i,
+        /^_JAVA_OPTIONS$/i,
+        // Git/SSH injection
+        /^GIT_SSH_COMMAND$/i,
+        /^GIT_EXEC_PATH$/i,
+        // Pager/editor injection
+        /^LESSOPEN$/i,
+        /^LESSCLOSE$/i,
+        // Shell startup injection
+        /^BASH_ENV$/i,
+        /^ENV$/i,
+        /^PROMPT_COMMAND$/i,
+        /^SHELLOPTS$/i,
+        // Field separator injection
+        /^IFS$/i,
+        // Editor/browser auto-launch injection
+        /^EDITOR$/i,
+        /^VISUAL$/i,
+        /^BROWSER$/i,
+        // Proxy injection (MITM child process HTTP traffic)
+        /^HTTPS?_PROXY$/i,
+        /^ALL_PROXY$/i,
+        /^NO_PROXY$/i,
+        // TLS verification bypass
+        /^SSL_CERT_FILE$/i,
+        /^SSL_CERT_DIR$/i,
+        /^NODE_TLS_REJECT_UNAUTHORIZED$/i,
+        // npm config injection
+        /^npm_config_/i,
+        // Pager injection (git, man, etc.)
+        /^PAGER$/i,
+        // Zsh startup injection
+        /^ZDOTDIR$/i,
+        // Curl config injection
+        /^CURL_HOME$/i,
+        // Third-party API keys (defense-in-depth for child processes)
+        /^OPENAI_/i,
+        /^ANTHROPIC_/i,
+        /^GITHUB_TOKEN$/i,
+        /^GITLAB_TOKEN$/i,
+        /^NPM_TOKEN$/i,
+        /^DOCKER_PASSWORD$/i,
+        /^SLACK_TOKEN$/i,
+        /^SLACK_BOT_TOKEN$/i,
+        /^SENDGRID_/i,
+        /^TWILIO_/i,
+        /^DATADOG_/i,
+        /TOKEN$/i,
+        /API_KEY$/i,
+    ];
+    const filtered = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!sensitivePatterns.some(pattern => pattern.test(key))) {
+            filtered[key] = value;
+        }
+    }
+    return filtered;
+}
 /**
  * Regular expression patterns used to detect approval prompts in Claude CLI output.
  * When any of these patterns match the output, an approval request is triggered
@@ -161,10 +249,11 @@ class ClaudeProcessManager extends events_1.EventEmitter {
         // SECURITY: Using cross-spawn instead of shell: true to prevent command injection
         const proc = (0, cross_spawn_1.default)('claude', args, {
             cwd: resolvedDir,
-            env: { ...process.env, TERM: 'xterm-256color' },
+            env: { ...getSafeEnv(), TERM: 'xterm-256color' },
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         this.setupProcessHandlers(terminalSessionId, proc, resolvedDir);
+        this.enforceProcessCap();
         this.processes.set(terminalSessionId, { terminalSessionId, process: proc, directory: resolvedDir, outputBuffer: [], wasAutoRestarted: false, dangerouslySkipPermissions: !!dangerouslySkipPermissions, interactivePermissions: !!interactivePermissions });
         return { cwd: resolvedDir };
     }
@@ -193,14 +282,15 @@ class ClaudeProcessManager extends events_1.EventEmitter {
             // Start IPC manager to bridge hook ↔ WebSocket
             this.startPermissionIpc(terminalSessionId, sessionKey);
         }
-        console.log(`[Claude Process] Spawning: claude ${args.join(' ')}`);
+        console.log(`[Claude Process] Spawning: claude (${args.length} args)`);
         // SECURITY: Using cross-spawn instead of shell: true to prevent command injection
         const proc = (0, cross_spawn_1.default)('claude', args, {
             cwd: resolvedDir,
-            env: { ...process.env, TERM: 'xterm-256color' },
+            env: { ...getSafeEnv(), TERM: 'xterm-256color' },
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         this.setupProcessHandlers(terminalSessionId, proc, resolvedDir, sessionKey);
+        this.enforceProcessCap();
         this.processes.set(terminalSessionId, { terminalSessionId, process: proc, directory: resolvedDir, sessionKey, outputBuffer: [], wasAutoRestarted: false, dangerouslySkipPermissions: !!dangerouslySkipPermissions, interactivePermissions: !!interactivePermissions });
         // Store session info for future message sends (needed since we spawn fresh process per message)
         this.closedSessions.set(terminalSessionId, {
@@ -278,7 +368,7 @@ class ClaudeProcessManager extends events_1.EventEmitter {
             return false;
         }
         // Write message to stdin IMMEDIATELY - no waiting
-        console.log(`[Claude Process] Sending JSONL immediately: ${jsonLine.substring(0, 100)}...`);
+        console.log(`[Claude Process] Sending JSONL immediately (${jsonLine.length} chars)`);
         return new Promise((resolve) => {
             try {
                 info.process.stdin.write(jsonLine, (err) => {
@@ -320,10 +410,11 @@ class ClaudeProcessManager extends events_1.EventEmitter {
         }
         const proc = (0, cross_spawn_1.default)('claude', args, {
             cwd: resolvedDir,
-            env: { ...process.env, TERM: 'xterm-256color' },
+            env: { ...getSafeEnv(), TERM: 'xterm-256color' },
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         this.setupProcessHandlers(terminalSessionId, proc, resolvedDir);
+        this.enforceProcessCap();
         this.processes.set(terminalSessionId, {
             terminalSessionId,
             process: proc,
@@ -364,7 +455,7 @@ class ClaudeProcessManager extends events_1.EventEmitter {
                         resolve(false);
                     }
                     else {
-                        console.log(`[Claude Process] Initial message written to new session in ${resolvedDir}`);
+                        console.log(`[Claude Process] Initial message written to new session`);
                         resolve(true);
                     }
                 });
@@ -393,13 +484,14 @@ class ClaudeProcessManager extends events_1.EventEmitter {
      * Used when mobile opens a session view - we store the info so we can spawn later on first message.
      */
     registerSession(sessionKey, directory, terminalSessionId, dangerouslySkipPermissions, interactivePermissions, isRealSession) {
+        this.cleanupOldClosedSessions();
         // If we already captured a real Claude session key (from SDK output) for this
         // terminalSessionId, preserve it. This prevents reconnects from overwriting
         // the real key with the mobile-generated one (e.g. brainstorm-*).
         const existing = this.closedSessions.get(terminalSessionId);
         const effectiveSessionKey = (existing?.isRealSession && existing.sessionKey) ? existing.sessionKey : sessionKey;
         const effectiveIsReal = (existing?.isRealSession) ? true : isRealSession;
-        console.log(`[Claude Process] Registering session: ${effectiveSessionKey} in ${directory}${dangerouslySkipPermissions ? ' (unrestricted)' : ''}${interactivePermissions ? ' (interactive)' : ''}${effectiveIsReal === false ? ' (fresh — no real Claude session)' : ''}`);
+        console.log(`[Claude Process] Registering session: ${effectiveSessionKey}${dangerouslySkipPermissions ? ' (unrestricted)' : ''}${interactivePermissions ? ' (interactive)' : ''}${effectiveIsReal === false ? ' (fresh — no real Claude session)' : ''}`);
         this.closedSessions.set(terminalSessionId, {
             sessionKey: effectiveSessionKey,
             directory,
@@ -416,10 +508,16 @@ class ClaudeProcessManager extends events_1.EventEmitter {
      */
     setupProcessHandlers(terminalSessionId, proc, directory, sessionKey) {
         // Buffer for incomplete JSONL lines
+        const MAX_LINE_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB
         let jsonLineBuffer = '';
         proc.stdout?.on('data', (data) => {
             const rawOutput = data.toString();
             jsonLineBuffer += rawOutput;
+            // Prevent unbounded buffer growth from missing newlines
+            if (jsonLineBuffer.length > MAX_LINE_BUFFER_SIZE) {
+                console.warn(`[Claude] JSONL line buffer exceeded ${MAX_LINE_BUFFER_SIZE} bytes, resetting`);
+                jsonLineBuffer = '';
+            }
             // Update output buffer for approval context
             const processInfo = this.processes.get(terminalSessionId);
             if (processInfo) {
@@ -448,7 +546,7 @@ class ClaudeProcessManager extends events_1.EventEmitter {
                             if (message.type === 'result') {
                                 console.log(`[Claude Process] Received result message - turn complete. Subtype: ${message.subtype}, Cost: $${message.cost_usd || 'unknown'}`);
                                 if (message.is_error) {
-                                    console.log(`[Claude Process] Result indicates error: ${JSON.stringify(message.error || 'unknown')}`);
+                                    console.log(`[Claude Process] Result indicates error`);
                                 }
                                 // Capture session_id from result so future sendInput() can --resume
                                 if (message.session_id && processInfo && !processInfo.sessionKey) {
@@ -482,7 +580,7 @@ class ClaudeProcessManager extends events_1.EventEmitter {
                     }
                     catch (e) {
                         // Non-JSON output (shouldn't happen with SDK flags, but log it)
-                        console.log(`[Claude Process] Non-JSON stdout: ${line.substring(0, 50)}...`);
+                        console.log(`[Claude Process] Non-JSON stdout (${line.length} chars)`);
                     }
                 }
             }
@@ -584,14 +682,28 @@ class ClaudeProcessManager extends events_1.EventEmitter {
      * SECURITY: Validates path doesn't contain dangerous characters
      */
     resolvePath(dir) {
-        // SECURITY: Reject paths with shell metacharacters that could be dangerous
-        if (/[;&|`$()<>]/.test(dir)) {
+        // SECURITY: Reject paths with shell metacharacters or control characters
+        if (/[;&|`$()<>\n\r\0]/.test(dir)) {
             throw new Error('Invalid directory path: contains disallowed characters');
         }
+        let resolved;
         if (dir === '~' || dir.startsWith('~/')) {
-            return dir === '~' ? os.homedir() : dir.replace('~', os.homedir());
+            resolved = dir === '~' ? os.homedir() : dir.replace('~', os.homedir());
+        }
+        else {
+            resolved = path.resolve(dir);
         }
-        return path.resolve(dir);
+        // SECURITY: Prevent path traversal — resolved path must be under home directory
+        const homeDir = os.homedir();
+        const normalized = path.normalize(resolved);
+        // On Windows, paths are case-insensitive — use lowercase comparison
+        const isUnderHome = os.platform() === 'win32'
+            ? normalized.toLowerCase().startsWith(homeDir.toLowerCase())
+            : normalized.startsWith(homeDir);
+        if (!isUnderHome) {
+            throw new Error('Invalid directory path: path traversal detected (must be under home directory)');
+        }
+        return normalized;
     }
     /**
      * Kill a Claude process
@@ -618,6 +730,25 @@ class ClaudeProcessManager extends events_1.EventEmitter {
             directory: info.directory,
         }));
     }
+    /** Enforce cap on active processes to prevent resource exhaustion */
+    enforceProcessCap() {
+        while (this.processes.size >= ClaudeProcessManager.MAX_ACTIVE_PROCESSES) {
+            const oldestKey = this.processes.keys().next().value;
+            if (oldestKey) {
+                const oldProcess = this.processes.get(oldestKey);
+                if (oldProcess?.process) {
+                    try {
+                        oldProcess.process.kill();
+                    }
+                    catch { /* best effort */ }
+                }
+                this.processes.delete(oldestKey);
+                console.warn(`[Claude Process] MAX_ACTIVE_PROCESSES (${ClaudeProcessManager.MAX_ACTIVE_PROCESSES}) reached, killed: ${oldestKey}`);
+            }
+            else
+                break;
+        }
+    }
     /**
      * Clean up old closed session entries to prevent memory leaks.
      * Sessions older than 1 hour are removed.
@@ -632,6 +763,16 @@ class ClaudeProcessManager extends events_1.EventEmitter {
                 cleanedCount++;
             }
         }
+        // Also enforce hard cap with FIFO eviction
+        while (this.closedSessions.size > ClaudeProcessManager.MAX_CLOSED_SESSIONS) {
+            const oldestKey = this.closedSessions.keys().next().value;
+            if (oldestKey) {
+                this.closedSessions.delete(oldestKey);
+                cleanedCount++;
+            }
+            else
+                break;
+        }
         if (cleanedCount > 0) {
             console.log(`[Claude Process] Cleaned up ${cleanedCount} old closed session(s)`);
         }
@@ -651,6 +792,14 @@ class ClaudeProcessManager extends events_1.EventEmitter {
      * Mark a session as taken over by the mobile user.
      */
     markTakenOver(terminalSessionId) {
+        // Evict oldest if at cap (FIFO — Set iteration order is insertion order)
+        if (this.takenOverSessions.size >= ClaudeProcessManager.MAX_TAKEN_OVER_SESSIONS) {
+            const oldest = this.takenOverSessions.values().next().value;
+            if (oldest) {
+                this.takenOverSessions.delete(oldest);
+                console.warn(`[Claude Process] MAX_TAKEN_OVER_SESSIONS (${ClaudeProcessManager.MAX_TAKEN_OVER_SESSIONS}) reached, evicted: ${oldest}`);
+            }
+        }
         this.takenOverSessions.add(terminalSessionId);
         console.log(`[Claude Process] Session marked as taken over: ${terminalSessionId}`);
     }
@@ -726,10 +875,25 @@ class ClaudeProcessManager extends events_1.EventEmitter {
         const rulesFile = path.join(rulesDir, 'rules.json');
         try {
             if (!fs.existsSync(rulesDir)) {
-                fs.mkdirSync(rulesDir, { recursive: true });
+                fs.mkdirSync(rulesDir, { recursive: true, mode: 0o700 });
             }
-            fs.writeFileSync(rulesFile, JSON.stringify(rules, null, 2), 'utf-8');
-            console.log(`[Claude Process] Permission rules written to ${rulesFile}`);
+            else {
+                // SECURITY: Validate temp dir permissions aren't world-writable
+                // Skip on Windows — Unix permission bits aren't enforced and produce false positives
+                if (process.platform !== 'win32') {
+                    const dirStat = fs.statSync(rulesDir);
+                    const dirMode = dirStat.mode & 0o777;
+                    if (dirMode & 0o022) { // group or other writable
+                        console.error(`[Security] Temp dir has unsafe permissions (${dirMode.toString(8)}), refusing to write`);
+                        return;
+                    }
+                }
+            }
+            // SECURITY: Atomic write via temp file + rename to prevent TOCTOU
+            const tmpFile = rulesFile + '.tmp.' + process.pid;
+            fs.writeFileSync(tmpFile, JSON.stringify(rules, null, 2), { encoding: 'utf-8', mode: 0o600 });
+            fs.renameSync(tmpFile, rulesFile);
+            console.log(`[Claude Process] Permission rules written`);
         }
         catch (err) {
             console.error(`[Claude Process] Failed to write permission rules:`, err.message);
@@ -743,14 +907,14 @@ class ClaudeProcessManager extends events_1.EventEmitter {
         const hookScriptPath = path.resolve(__dirname, 'permission-hook.js');
         // Verify hook script exists (it should be compiled alongside this file)
         if (!fs.existsSync(hookScriptPath)) {
-            console.log(`[Claude Process] Hook script not found at ${hookScriptPath}, skipping hook configuration`);
+            console.log(`[Claude Process] Hook script not found, skipping hook configuration`);
             return;
         }
         const claudeDir = path.join(cwd, '.claude');
         const settingsFile = path.join(claudeDir, 'settings.local.json');
         try {
             // Create .claude dir if needed
-            fs.mkdirSync(claudeDir, { recursive: true });
+            fs.mkdirSync(claudeDir, { recursive: true, mode: 0o700 });
             // Read existing settings or start fresh
             let settings = {};
             if (fs.existsSync(settingsFile)) {
@@ -778,9 +942,9 @@ class ClaudeProcessManager extends events_1.EventEmitter {
                         }],
                 });
             }
-            fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2), 'utf-8');
+            fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2), { encoding: 'utf-8', mode: 0o600 });
             this.hookConfiguredDirs.add(cwd);
-            console.log(`[Claude Process] Hook configured in ${settingsFile}`);
+            console.log(`[Claude Process] Hook configured`);
         }
         catch (err) {
             console.log(`[Claude Process] Failed to configure hook: ${err.message}`);
@@ -811,10 +975,10 @@ class ClaudeProcessManager extends events_1.EventEmitter {
                 fs.unlinkSync(settingsFile);
             }
             else {
-                fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2), 'utf-8');
+                fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2), { encoding: 'utf-8', mode: 0o600 });
             }
             this.hookConfiguredDirs.delete(cwd);
-            console.log(`[Claude Process] Hook removed from ${settingsFile}`);
+            console.log(`[Claude Process] Hook removed`);
         }
         catch (err) {
             console.log(`[Claude Process] Failed to remove hook: ${err.message}`);
@@ -921,10 +1085,15 @@ class ClaudeProcessManager extends events_1.EventEmitter {
                         inputSummary = `Pattern: ${toolInput.pattern}`;
                     }
                     else {
-                        inputSummary = JSON.stringify(toolInput).substring(0, 200);
+                        try {
+                            inputSummary = JSON.stringify(toolInput).substring(0, 200);
+                        }
+                        catch {
+                            inputSummary = '[unserializable input]';
+                        }
                     }
                 }
-                console.log(`[Claude Process] Tool activity: ${toolName} (${toolId}) - ${inputSummary.substring(0, 80)}`);
+                console.log(`[Claude Process] Tool activity: ${toolName} (${toolId})`);
                 // Emit non-blocking tool_activity event (not an approval request)
                 const toolActivity = {
                     terminalSessionId,
@@ -984,7 +1153,7 @@ class ClaudeProcessManager extends events_1.EventEmitter {
         // SDK mode (stream-json) does not accept raw character input — writing 'y' or 'n'
         // to stdin would be interpreted as a malformed JSONL message, not an approval response.
         // The tool has already executed by the time the user sees the notification.
-        console.log(`[Claude Process] Approval response '${response}' for ${approvalId} ignored — SDK mode processes don't accept raw stdin approval characters`);
+        console.log(`[Claude Process] Approval response for ${approvalId} ignored — SDK mode processes don't accept raw stdin approval characters`);
     }
     /**
      * Retrieves a pending approval request for a specific terminal session.
@@ -1117,7 +1286,7 @@ class ClaudeProcessManager extends events_1.EventEmitter {
                     status: 'pending',
                     activeForm: input.activeForm,
                 };
-                console.log(`[Claude Process] Task created: ${task.subject}`);
+                console.log(`[Claude Process] Task created: ${task.id || 'unknown'}`);
                 this.emit('task_progress', {
                     terminalSessionId,
                     sessionKey,
@@ -1181,6 +1350,10 @@ class ClaudeProcessManager extends events_1.EventEmitter {
     }
 }
 exports.ClaudeProcessManager = ClaudeProcessManager;
+ClaudeProcessManager.MAX_ACTIVE_PROCESSES = 20;
+ClaudeProcessManager.MAX_PENDING_APPROVALS = 50;
+ClaudeProcessManager.MAX_CLOSED_SESSIONS = 200;
+ClaudeProcessManager.MAX_TAKEN_OVER_SESSIONS = 100;
 exports.claudeProcessManager = new ClaudeProcessManager();
 exports.default = exports.claudeProcessManager;
 //# sourceMappingURL=claude-process.js.map

package/dist/tools/claude-sessions.d.ts

@@ -10,6 +10,7 @@ import { EventEmitter } from 'events';
 export interface ClaudeSessionInfo {
     sessionKey: string;
     directory: string;
+    name?: string;
     state: 'active' | 'inactive';
     lastUsedAt: string;
     transcriptPath?: string;

package/dist/tools/claude-sessions.js

@@ -146,7 +146,7 @@ class ClaudeSessionDetector extends events_1.EventEmitter {
             }
         }
         catch (error) {
-            console.error('[ClaudeSessionDetector] Error scanning sessions:', error);
+            console.error('[ClaudeSessionDetector] Error scanning sessions:', error.message);
         }
         // Sort by lastUsedAt descending
         sessions.sort((a, b) => new Date(b.lastUsedAt).getTime() - new Date(a.lastUsedAt).getTime());
@@ -164,22 +164,48 @@ class ClaudeSessionDetector extends events_1.EventEmitter {
             // We must validate against the filesystem to preserve literal hyphens
             // in directory names (e.g. Dev-SharbelAS should NOT become Dev\SharbelAS)
             let directory = this.decodeProjectDir(projectDir);
-            // Try to read the first line to get session ID
+            // Read transcript lines to get session ID and name
             const content = fs.readFileSync(filePath, 'utf8');
-            const firstLine = content.split('\n')[0];
+            const lines = content.split('\n');
             let sessionId = fileName;
-            try {
-                const firstMessage = JSON.parse(firstLine);
-                if (firstMessage.sessionId) {
-                    sessionId = firstMessage.sessionId;
+            let name;
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const entry = JSON.parse(line);
+                    // Extract session ID from first entry
+                    if (entry.sessionId && sessionId === fileName) {
+                        sessionId = entry.sessionId;
+                    }
+                    // Extract name from first human/user message
+                    if (!name && entry.type === 'human' || !name && entry.role === 'user') {
+                        const text = typeof entry.message === 'string'
+                            ? entry.message
+                            : typeof entry.content === 'string'
+                                ? entry.content
+                                : Array.isArray(entry.message?.content)
+                                    ? entry.message.content.find((b) => b.type === 'text')?.text
+                                    : typeof entry.message?.content === 'string'
+                                        ? entry.message.content
+                                        : null;
+                        if (text) {
+                            // Truncate to 120 chars for display
+                            name = text.length > 120 ? text.substring(0, 120) + '...' : text;
+                        }
+                    }
+                    // Stop after finding both
+                    if (sessionId !== fileName && name)
+                        break;
+                }
+                catch {
+                    continue;
                 }
-            }
-            catch {
-                // Use filename as session ID
             }
             return {
                 sessionKey: sessionId,
                 directory,
+                name,
                 state: 'inactive', // Will be updated if Claude is running
                 lastUsedAt: stat.mtime.toISOString(),
                 transcriptPath: filePath,

package/dist/tools/detector.js

@@ -323,12 +323,15 @@ class ToolDetector {
     findCommand(command) {
         try {
             const cmd = this.platform === 'windows' ? 'where' : 'which';
-            const result = (0, child_process_1.execSync)(`${cmd} ${command}`, {
+            const result = (0, child_process_1.spawnSync)(cmd, [command], {
                 encoding: 'utf8',
                 timeout: 5000,
                 stdio: ['pipe', 'pipe', 'pipe'],
-            }).trim();
-            return result.split('\n')[0] || null;
+            });
+            if (result.status === 0 && result.stdout) {
+                return result.stdout.trim().split('\n')[0] || null;
+            }
+            return null;
         }
         catch {
             return null;
@@ -338,6 +341,11 @@ class ToolDetector {
      * Check if a process is running
      */
     isProcessRunning(processName) {
+        // Validate processName to prevent command injection
+        const SAFE_PROCESS_NAME = /^[a-zA-Z0-9_-]+$/;
+        if (!SAFE_PROCESS_NAME.test(processName)) {
+            return false;
+        }
         try {
             let cmd;
             if (this.platform === 'windows') {