@ai-devkit/agent-manager 0.9.0 → 0.11.0

package/src/utils/ClaudeSessionParser.ts

@@ -0,0 +1,437 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import type { ConversationMessage } from '../adapters/AgentAdapter';
+import { AgentStatus } from '../adapters/AgentAdapter';
+
+/**
+ * Content block within a Claude Code JSONL message entry.
+ * Handles text, tool_use, and tool_result block types.
+ */
+export interface ContentBlock {
+    type?: string;
+    text?: string;
+    content?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    tool_use_id?: string;
+    is_error?: boolean;
+}
+
+/**
+ * A single line entry in a Claude Code session JSONL file.
+ *
+ * Each line is an independent JSON object with a type discriminator:
+ * - "user" / "assistant" / "system" — conversation turns
+ * - "progress" / "thinking" — intermediate agent state
+ * - "last-prompt" / "file-history-snapshot" — metadata (not conversation state)
+ */
+export interface SessionEntry {
+    type?: string;
+    timestamp?: string;
+    cwd?: string;
+    message?: {
+        content?: string | ContentBlock[];
+    };
+}
+
+/**
+ * Parsed session state extracted from a JSONL file.
+ * Aggregates data from all entries into a single summary.
+ */
+export interface ClaudeSession {
+    sessionId: string;
+    projectPath: string;
+    lastCwd?: string;
+    sessionStart: Date;
+    lastActive: Date;
+    lastEntryType?: string;
+    isInterrupted: boolean;
+    lastUserMessage?: string;
+    /** First meaningful user prompt in the session (post noise filter) */
+    firstUserMessage?: string;
+}
+
+/** Entry types that are metadata, not conversation state. */
+const METADATA_ENTRY_TYPES = new Set(['last-prompt', 'file-history-snapshot']);
+
+/**
+ * Parses Claude Code session JSONL files into structured data.
+ *
+ * Session files live at ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl
+ * and contain one JSON object per line, each representing a conversation
+ * event (user turn, assistant response, tool call, etc.).
+ */
+export class ClaudeSessionParser {
+    /**
+     * Parse a session JSONL file into a ClaudeSession summary.
+     *
+     * Iterates all lines to extract: session start time (from first entry),
+     * last activity timestamp, last entry type (for status), whether the
+     * session was interrupted, and the last meaningful user message.
+     *
+     * Returns null if the file is unreadable or empty.
+     */
+    readSession(filePath: string, projectPath: string): ClaudeSession | null {
+        const sessionId = path.basename(filePath, '.jsonl');
+
+        let content: string;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        } catch {
+            return null;
+        }
+
+        const allLines = content.trim().split('\n');
+        if (allLines.length === 0) {
+            return null;
+        }
+
+        const sessionStart = this.parseSessionStart(allLines[0]);
+
+        let lastEntryType: string | undefined;
+        let lastActive: Date | undefined;
+        let lastCwd: string | undefined;
+        let isInterrupted = false;
+        let lastUserMessage: string | undefined;
+        let firstUserMessage: string | undefined;
+
+        for (const line of allLines) {
+            try {
+                const entry: SessionEntry = JSON.parse(line);
+
+                if (entry.timestamp) {
+                    const ts = new Date(entry.timestamp);
+                    if (!Number.isNaN(ts.getTime())) {
+                        lastActive = ts;
+                    }
+                }
+
+                if (typeof entry.cwd === 'string' && entry.cwd.trim().length > 0) {
+                    lastCwd = entry.cwd;
+                }
+
+                if (entry.type && !METADATA_ENTRY_TYPES.has(entry.type)) {
+                    lastEntryType = entry.type;
+
+                    if (entry.type === 'user') {
+                        const msgContent = entry.message?.content;
+                        isInterrupted =
+                            Array.isArray(msgContent) &&
+                            msgContent.some(
+                                (c) =>
+                                    (c.type === 'text' &&
+                                        c.text?.includes('[Request interrupted')) ||
+                                    (c.type === 'tool_result' &&
+                                        c.content?.includes('[Request interrupted')),
+                            );
+
+                        const text = this.extractUserMessageText(msgContent);
+                        if (text) {
+                            lastUserMessage = text;
+                            if (!firstUserMessage) {
+                                firstUserMessage = text;
+                            }
+                        }
+                    } else {
+                        isInterrupted = false;
+                    }
+                }
+            } catch {
+                continue;
+            }
+        }
+
+        return {
+            sessionId,
+            projectPath: projectPath || lastCwd || '',
+            lastCwd,
+            sessionStart: sessionStart || lastActive || new Date(),
+            lastActive: lastActive || new Date(),
+            lastEntryType,
+            isInterrupted,
+            lastUserMessage,
+            firstUserMessage,
+        };
+    }
+
+    /**
+     * Determine agent status from parsed session state.
+     *
+     * Status mapping:
+     * - "user" + interrupted → WAITING (agent finished, awaiting new input)
+     * - "user" + not interrupted → RUNNING (agent is processing)
+     * - "progress" / "thinking" → RUNNING
+     * - "assistant" → WAITING (agent responded, awaiting user)
+     * - "system" → IDLE
+     */
+    determineStatus(session: ClaudeSession): AgentStatus {
+        if (!session.lastEntryType) {
+            return AgentStatus.UNKNOWN;
+        }
+
+        if (session.lastEntryType === 'user') {
+            return session.isInterrupted
+                ? AgentStatus.WAITING
+                : AgentStatus.RUNNING;
+        }
+
+        if (
+            session.lastEntryType === 'progress' ||
+            session.lastEntryType === 'thinking'
+        ) {
+            return AgentStatus.RUNNING;
+        }
+
+        if (session.lastEntryType === 'assistant') {
+            return AgentStatus.WAITING;
+        }
+
+        if (session.lastEntryType === 'system') {
+            return AgentStatus.IDLE;
+        }
+
+        return AgentStatus.UNKNOWN;
+    }
+
+    /**
+     * Read the full conversation from a session JSONL file.
+     *
+     * Default mode returns only text content from user/assistant/system messages.
+     * Verbose mode also includes tool_use and tool_result blocks.
+     */
+    getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+        const verbose = options?.verbose ?? false;
+
+        let content: string;
+        try {
+            content = fs.readFileSync(sessionFilePath, 'utf-8');
+        } catch {
+            return [];
+        }
+
+        const lines = content.trim().split('\n');
+        const messages: ConversationMessage[] = [];
+
+        for (const line of lines) {
+            let entry: SessionEntry;
+            try {
+                entry = JSON.parse(line);
+            } catch {
+                continue;
+            }
+
+            const entryType = entry.type;
+            if (!entryType || METADATA_ENTRY_TYPES.has(entryType)) continue;
+            if (entryType === 'progress' || entryType === 'thinking') continue;
+
+            let role: ConversationMessage['role'];
+            if (entryType === 'user') {
+                role = 'user';
+            } else if (entryType === 'assistant') {
+                role = 'assistant';
+            } else if (entryType === 'system') {
+                role = 'system';
+            } else {
+                continue;
+            }
+
+            const text = this.extractConversationContent(entry.message?.content, role, verbose);
+            if (!text) continue;
+
+            messages.push({
+                role,
+                content: text,
+                timestamp: entry.timestamp,
+            });
+        }
+
+        return messages;
+    }
+
+    /**
+     * Parse session start time from the first JSONL line.
+     *
+     * Claude Code may emit a "file-history-snapshot" as the first entry,
+     * which stores its timestamp inside "snapshot.timestamp" rather than
+     * at the root level.
+     */
+    private parseSessionStart(firstLine: string): Date | null {
+        try {
+            const firstEntry = JSON.parse(firstLine);
+            const rawTs: string | undefined =
+                firstEntry.timestamp || firstEntry.snapshot?.timestamp;
+            if (rawTs) {
+                const ts = new Date(rawTs);
+                if (!Number.isNaN(ts.getTime())) {
+                    return ts;
+                }
+            }
+        } catch {
+            /* malformed first line */
+        }
+        return null;
+    }
+
+    /**
+     * Extract meaningful text from a user message content field.
+     *
+     * Handles multiple formats:
+     * - Plain string content
+     * - Array of content blocks (extracts first text block)
+     * - Skill slash-commands (<command-message> tags)
+     * - Expanded skill content (extracts ARGUMENTS line)
+     * - Filters noise messages (interruptions, tool loaded, session continued)
+     */
+    private extractUserMessageText(
+        content: string | Array<{ type?: string; text?: string }> | undefined,
+    ): string | undefined {
+        if (!content) {
+            return undefined;
+        }
+
+        let raw: string | undefined;
+
+        if (typeof content === 'string') {
+            raw = content.trim();
+        } else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === 'text' && block.text?.trim()) {
+                    raw = block.text.trim();
+                    break;
+                }
+            }
+        }
+
+        if (!raw) {
+            return undefined;
+        }
+
+        if (raw.startsWith('<command-message>')) {
+            return this.parseCommandMessage(raw);
+        }
+
+        if (raw.startsWith('Base directory for this skill:')) {
+            const argsMatch = raw.match(/\nARGUMENTS:\s*(.+)/);
+            return argsMatch?.[1]?.trim() || undefined;
+        }
+
+        if (isNoiseMessage(raw)) {
+            return undefined;
+        }
+
+        return raw;
+    }
+
+    /**
+     * Parse a <command-message> string into "/command args" format.
+     */
+    private parseCommandMessage(raw: string): string | undefined {
+        const nameMatch = raw.match(/<command-name>([^<]+)<\/command-name>/);
+        const argsMatch = raw.match(/<command-args>([^<]+)<\/command-args>/);
+        const name = nameMatch?.[1]?.trim();
+        if (!name) {
+            return undefined;
+        }
+        const args = argsMatch?.[1]?.trim();
+        return args ? `${name} ${args}` : name;
+    }
+
+    /**
+     * Extract displayable content from a message content field for conversation output.
+     */
+    private extractConversationContent(
+        content: string | ContentBlock[] | undefined,
+        role: ConversationMessage['role'],
+        verbose: boolean,
+    ): string | undefined {
+        if (!content) return undefined;
+
+        if (typeof content === 'string') {
+            const cleaned = stripHarnessTags(content);
+            if (role === 'user' && isNoiseMessage(cleaned)) return undefined;
+            return cleaned || undefined;
+        }
+
+        if (!Array.isArray(content)) return undefined;
+
+        const parts: string[] = [];
+
+        for (const block of content) {
+            if (block.type === 'text' && block.text?.trim()) {
+                const cleaned = stripHarnessTags(block.text);
+                if (!cleaned) continue;
+                if (role === 'user' && isNoiseMessage(cleaned)) continue;
+                parts.push(cleaned);
+            } else if (block.type === 'tool_use' && verbose) {
+                const inputSummary = block.input?.file_path || block.input?.pattern || block.input?.command || '';
+                parts.push(`[Tool: ${block.name}]${inputSummary ? ' ' + inputSummary : ''}`);
+            } else if (block.type === 'tool_result' && verbose) {
+                const truncated = truncateToolResult(block.content || '');
+                const prefix = block.is_error ? '[Tool Error]' : '[Tool Result]';
+                parts.push(`${prefix} ${truncated}`);
+            }
+        }
+
+        return parts.length > 0 ? parts.join('\n') : undefined;
+    }
+}
+
+/**
+ * Tags whose entire block (including content) should be dropped — they are
+ * harness-injected prompt context (system reminders, hook output, command
+ * stdout), not meaningful conversation content.
+ */
+const HARNESS_DROP_TAGS = [
+    'system-reminder',
+    'local-command-stdout',
+    'local-command-stderr',
+    'user-prompt-submit-hook',
+    'command-stdout',
+    'command-stderr',
+    'bash-input',
+    'bash-stdout',
+    'bash-stderr',
+    'command-message',
+] as const;
+
+const HARNESS_DROP_RE = new RegExp(
+    `<(${HARNESS_DROP_TAGS.join('|')})>[\\s\\S]*?</\\1>`,
+    'g',
+);
+
+const COMMAND_INVOCATION_RE =
+    /<command-name>([^<]+)<\/command-name>(?:\s*<command-args>([\s\S]*?)<\/command-args>)?/g;
+
+/**
+ * Remove harness-injected XML blocks from message text and collapse
+ * <command-name>/<command-args> pairs into a "/name args" shorthand.
+ *
+ * Returns the cleaned, trimmed text. Returns an empty string if nothing
+ * survives stripping.
+ */
+function stripHarnessTags(text: string): string {
+    let out = text.replace(HARNESS_DROP_RE, '');
+
+    out = out.replace(COMMAND_INVOCATION_RE, (_match, rawName: string, rawArgs?: string) => {
+        const name = rawName.trim();
+        const args = rawArgs?.trim();
+        return args ? `${name} ${args}` : name;
+    });
+
+    return out.replace(/\n{3,}/g, '\n\n').trim();
+}
+
+/** Check if a message is noise (not a meaningful user intent). */
+function isNoiseMessage(text: string): boolean {
+    return (
+        text.startsWith('[Request interrupted') ||
+        text === 'Tool loaded.' ||
+        text.startsWith('This session is being continued')
+    );
+}
+
+function truncateToolResult(content: string, maxLength = 200): string {
+    const firstLine = content.split('\n')[0] || '';
+    if (firstLine.length <= maxLength) return firstLine;
+    return firstLine.slice(0, maxLength - 3) + '...';
+}

package/src/utils/applescript.ts

@@ -0,0 +1,10 @@
+/**
+ * Escape a string for safe use inside an AppleScript double-quoted string.
+ * Backslashes, double quotes, and newlines must be escaped.
+ */
+export function escapeAppleScript(text: string): string {
+    return text
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\r\n|\r|\n/g, '\\n');
+}

package/src/utils/process.ts

@@ -2,19 +2,18 @@
  * Process Detection Utilities
  *
  * Shared shell command wrappers for detecting and inspecting running processes.
- * All execSync calls for process data live here — adapters must not call execSync directly.
+ * All execFileSync calls for process data live here — adapters must not call execFileSync directly.
  */
 
 import * as path from 'path';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import type { ProcessInfo } from '../adapters/AgentAdapter';
 
 /**
  * List running processes matching an agent executable name.
  *
- * Uses `ps aux | grep <pattern>` at shell level for performance, then post-filters
- * by checking that the executable basename matches exactly (avoids matching
- * `claude-helper`, `vscode-claude-extension`, or the grep process itself).
+ * Uses `ps aux` then filters in JS for exact executable basename match.
+ * This avoids shell pipelines and string interpolation.
  *
  * Returned ProcessInfo has pid, command, tty populated.
  * cwd and startTime are NOT populated — call enrichProcesses() to fill them.
@@ -26,14 +25,9 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
     }
 
     try {
-        // Use [c]laude trick to avoid matching the grep process itself
-        const escapedPattern = `[${namePattern[0]}]${namePattern.slice(1)}`;
-
-        const output = execSync(
-            `ps aux | grep -i '${escapedPattern}'`,
-            { encoding: 'utf-8' },
-        );
+        const output = execFileSync('ps', ['aux'], { encoding: 'utf-8' });
 
+        const lowerPattern = namePattern.toLowerCase();
         const processes: ProcessInfo[] = [];
 
         for (const line of output.trim().split('\n')) {
@@ -48,10 +42,10 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
             const tty = parts[6];
             const command = parts.slice(10).join(' ');
 
-            // Post-filter: check that the executable basename matches exactly
+            // Check that the executable basename matches exactly
             const executable = command.trim().split(/\s+/)[0] || '';
             const base = path.basename(executable).toLowerCase();
-            if (base !== namePattern.toLowerCase() && base !== `${namePattern.toLowerCase()}.exe`) {
+            if (base !== lowerPattern && base !== `${lowerPattern}.exe`) {
                 continue;
             }
 
@@ -82,9 +76,9 @@ export function batchGetProcessCwds(pids: number[]): Map<number, string> {
     if (pids.length === 0) return result;
 
     try {
-        const output = execSync(
-            `lsof -a -d cwd -Fn -p ${pids.join(',')} 2>/dev/null`,
-            { encoding: 'utf-8' },
+        const output = execFileSync(
+            'lsof', ['-a', '-d', 'cwd', '-Fn', '-p', pids.join(',')],
+            { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] },
         );
 
         // lsof output format: p{PID}\nn{path}\np{PID}\nn{path}...
@@ -101,7 +95,10 @@ export function batchGetProcessCwds(pids: number[]): Map<number, string> {
         // Try per-PID fallback with pwdx (Linux)
         for (const pid of pids) {
             try {
-                const output = execSync(`pwdx ${pid} 2>/dev/null`, { encoding: 'utf-8' });
+                const output = execFileSync(
+                    'pwdx', [String(pid)],
+                    { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] },
+                );
                 const match = output.match(/^\d+:\s*(.+)$/);
                 if (match) {
                     result.set(pid, match[1].trim());
@@ -127,8 +124,8 @@ export function batchGetProcessStartTimes(pids: number[]): Map<number, Date> {
     if (pids.length === 0) return result;
 
     try {
-        const output = execSync(
-            `ps -o pid=,lstart= -p ${pids.join(',')}`,
+        const output = execFileSync(
+            'ps', ['-o', 'pid=,lstart=', '-p', pids.join(',')],
             { encoding: 'utf-8' },
         );
 
@@ -185,9 +182,10 @@ export function enrichProcesses(processes: ProcessInfo[]): ProcessInfo[] {
  */
 export function getProcessTty(pid: number): string {
     try {
-        const output = execSync(`ps -p ${pid} -o tty=`, {
-            encoding: 'utf-8',
-        });
+        const output = execFileSync(
+            'ps', ['-p', String(pid), '-o', 'tty='],
+            { encoding: 'utf-8' },
+        );
 
         const tty = output.trim();
         return tty.startsWith('/dev/') ? tty.slice(5) : tty;
@@ -195,4 +193,3 @@ export function getProcessTty(pid: number): string {
         return '?';
     }
 }
-