atoo-studio 0.0.1 → 0.0.2

package/dist/src/agents/lib/codex/jsonl-mapper.js

@@ -0,0 +1,154 @@
+/**
+ * Map Codex CLI JSONL lines → SessionEvent[].
+ *
+ * Codex JSONL uses a wrapper format with top-level `type` + `payload`:
+ *   session_meta   → SystemEvent (init)
+ *   event_msg      → UserEvent / AssistantEvent / ResultEvent
+ *   response_item  → AssistantEvent (function_call) / UserEvent (function_call_output)
+ *   turn_context   → skipped
+ */
+import { v4 as uuidv4 } from 'uuid';
+// ═══════════════════════════════════════════════════════
+// Mapper
+// ═══════════════════════════════════════════════════════
+/**
+ * Convert a single parsed Codex JSONL line into zero or more SessionEvents.
+ */
+export function mapCodexJsonlLine(line) {
+    const ts = line.timestamp;
+    switch (line.type) {
+        case 'session_meta':
+            return mapSessionMeta(line.payload, ts);
+        case 'event_msg':
+            return mapEventMsg(line.payload, ts);
+        case 'response_item':
+            return mapResponseItem(line.payload, ts);
+        // turn_context — per-turn metadata, skip
+        default:
+            return [];
+    }
+}
+// ───────────────────────────────────────────────────────
+// session_meta → SystemEvent (init)
+// ───────────────────────────────────────────────────────
+function mapSessionMeta(payload, ts) {
+    const model = payload.model_provider === 'openai'
+        ? 'gpt-5.4'
+        : (payload.model_provider || 'unknown');
+    return [{
+            type: 'system',
+            uuid: uuidv4(),
+            subtype: 'init',
+            model,
+            timestamp: ts,
+            cwd: payload.cwd,
+        }];
+}
+// ───────────────────────────────────────────────────────
+// event_msg → various events
+// ───────────────────────────────────────────────────────
+function mapEventMsg(payload, ts) {
+    switch (payload.type) {
+        case 'user_message':
+            return [{
+                    type: 'user',
+                    uuid: uuidv4(),
+                    timestamp: ts,
+                    message: {
+                        role: 'user',
+                        content: payload.message || '',
+                    },
+                }];
+        case 'agent_message':
+            return [{
+                    type: 'assistant',
+                    uuid: uuidv4(),
+                    timestamp: ts,
+                    message: {
+                        role: 'assistant',
+                        content: [{ type: 'text', text: payload.message || '' }],
+                    },
+                }];
+        case 'task_complete':
+            return [{
+                    type: 'result',
+                    uuid: uuidv4(),
+                    timestamp: ts,
+                    subtype: 'task_complete',
+                    result: payload.last_agent_message,
+                }];
+        // task_started, token_count — skip
+        default:
+            return [];
+    }
+}
+// ───────────────────────────────────────────────────────
+// response_item → tool use / tool result
+// ───────────────────────────────────────────────────────
+function mapResponseItem(payload, ts) {
+    switch (payload.type) {
+        case 'function_call':
+            return mapFunctionCall(payload, ts);
+        case 'function_call_output':
+            return mapFunctionCallOutput(payload, ts);
+        // Skip: message (duplicates event_msg), reasoning (encrypted), web_search_call
+        default:
+            return [];
+    }
+}
+function mapFunctionCall(payload, ts) {
+    const callId = payload.call_id || uuidv4();
+    const name = payload.name || 'unknown';
+    let input = {};
+    try {
+        input = JSON.parse(payload.arguments || '{}');
+    }
+    catch {
+        input = { raw: payload.arguments };
+    }
+    // Map request_user_input to ControlRequestEvent (question UI)
+    if (name === 'request_user_input') {
+        return [{
+                type: 'control_request',
+                uuid: uuidv4(),
+                timestamp: ts,
+                request_id: callId,
+                request: {
+                    subtype: 'tool_use',
+                    tool_use: { name: 'AskUserQuestion', input },
+                },
+            }];
+    }
+    // Regular tool call → AssistantEvent with tool_use block
+    return [{
+            type: 'assistant',
+            uuid: uuidv4(),
+            timestamp: ts,
+            message: {
+                role: 'assistant',
+                content: [{
+                        type: 'tool_use',
+                        id: callId,
+                        name,
+                        input,
+                    }],
+            },
+        }];
+}
+function mapFunctionCallOutput(payload, ts) {
+    const callId = payload.call_id || '';
+    const output = payload.output || '';
+    return [{
+            type: 'user',
+            uuid: uuidv4(),
+            timestamp: ts,
+            message: {
+                role: 'user',
+                content: [{
+                        type: 'tool_result',
+                        tool_use_id: callId,
+                        content: output,
+                    }],
+            },
+        }];
+}

package/dist/src/agents/lib/codex/jsonl-writer.d.ts

@@ -0,0 +1,8 @@
+import type { SessionEvent } from '../../../events/types.js';
+/**
+ * Write SessionEvent[] as a Codex JSONL file for `codex resume`.
+ * Path: ~/.codex/sessions/YYYY/MM/DD/rollout-{timestamp}-{uuid}.jsonl
+ *
+ * @returns The full path to the written JSONL file
+ */
+export declare function writeForkedCodexJsonl(events: SessionEvent[], targetUuid: string, directory: string): string;

package/dist/src/agents/lib/codex/jsonl-writer.js

@@ -0,0 +1,440 @@
+/**
+ * Reconstruct Codex CLI JSONL from SessionEvent[] for fork/resume.
+ *
+ * Codex JSONL format:
+ *   {"timestamp":"...","type":"session_meta","payload":{...}}
+ *   {"timestamp":"...","type":"event_msg","payload":{"type":"user_message","message":"..."}}
+ *   {"timestamp":"...","type":"event_msg","payload":{"type":"agent_message","message":"...","phase":"final_answer"}}
+ *   {"timestamp":"...","type":"response_item","payload":{"type":"function_call","name":"...","arguments":"...","call_id":"..."}}
+ *   {"timestamp":"...","type":"response_item","payload":{"type":"function_call_output","call_id":"...","output":"..."}}
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+import { findMostRecentCodexSession } from '../session-precreate.js';
+const CODEX_SESSIONS_DIR = path.join(os.homedir(), '.codex', 'sessions');
+/**
+ * Build the Codex session directory path for the current date.
+ * ~/.codex/sessions/YYYY/MM/DD/
+ */
+function getDateDir() {
+    const now = new Date();
+    const y = now.getFullYear().toString();
+    const m = (now.getMonth() + 1).toString().padStart(2, '0');
+    const d = now.getDate().toString().padStart(2, '0');
+    return path.join(CODEX_SESSIONS_DIR, y, m, d);
+}
+/**
+ * Build the Codex JSONL filename.
+ * rollout-YYYY-MM-DDTHH-MM-SS-{uuid}.jsonl
+ */
+function buildFilename(uuid) {
+    const now = new Date();
+    const ts = now.toISOString().replace(/:/g, '-').replace(/\.\d+Z$/, '');
+    return `rollout-${ts}-${uuid}.jsonl`;
+}
+// ═══════════════════════════════════════════════════════
+// SessionEvent → Codex JSONL line reconstruction
+// ═══════════════════════════════════════════════════════
+function reconstructSessionMeta(event, sessionUuid, cwd) {
+    return {
+        timestamp: event.timestamp || new Date().toISOString(),
+        type: 'session_meta',
+        payload: {
+            id: sessionUuid,
+            timestamp: event.timestamp || new Date().toISOString(),
+            cwd,
+            originator: 'codex_cli_rs',
+            cli_version: '0.111.0',
+            source: 'cli',
+            model_provider: 'openai',
+        },
+    };
+}
+function reconstructUserMessage(event) {
+    const content = event.message.content;
+    const ts = event.timestamp || new Date().toISOString();
+    // Tool result events — map to function_call_output
+    if (Array.isArray(content)) {
+        const results = [];
+        for (const block of content) {
+            if (block.type === 'tool_result' && 'tool_use_id' in block) {
+                const output = typeof block.content === 'string'
+                    ? block.content
+                    : Array.isArray(block.content)
+                        ? block.content.map((b) => b.text || '').join('')
+                        : JSON.stringify(block.content || '');
+                results.push({
+                    timestamp: ts,
+                    type: 'response_item',
+                    payload: {
+                        type: 'function_call_output',
+                        call_id: block.tool_use_id,
+                        output,
+                    },
+                });
+            }
+        }
+        if (results.length > 0)
+            return results;
+    }
+    // Plain text user message — handle both string and array-of-text-blocks formats
+    let text = '';
+    if (typeof content === 'string') {
+        text = content;
+    }
+    else if (Array.isArray(content)) {
+        // Extract text from text blocks (e.g. [{ type: 'text', text: '...' }])
+        text = content
+            .filter((b) => b.type === 'text' || b.type === 'input_text')
+            .map((b) => b.text || '')
+            .join('\n');
+    }
+    if (!text)
+        return [];
+    return [
+        // response_item with role:"user" — this is what Codex uses to rebuild context
+        {
+            timestamp: ts,
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'user',
+                content: [{ type: 'input_text', text }],
+            },
+        },
+        // event_msg for UI display
+        {
+            timestamp: ts,
+            type: 'event_msg',
+            payload: {
+                type: 'user_message',
+                message: text,
+                images: [],
+                local_images: [],
+                text_elements: [],
+            },
+        },
+    ];
+}
+function reconstructAssistantMessage(event) {
+    const lines = [];
+    const content = event.message.content;
+    const ts = event.timestamp || new Date().toISOString();
+    // Collect text blocks for the response_item with role:"assistant"
+    const outputTextBlocks = [];
+    if (Array.isArray(content)) {
+        for (const block of content) {
+            if (block.type === 'text') {
+                outputTextBlocks.push({ type: 'output_text', text: block.text });
+                // event_msg for UI display
+                lines.push({
+                    timestamp: ts,
+                    type: 'event_msg',
+                    payload: {
+                        type: 'agent_message',
+                        message: block.text,
+                        phase: 'final_answer',
+                    },
+                });
+            }
+            else if (block.type === 'tool_use' && 'id' in block && 'name' in block) {
+                lines.push({
+                    timestamp: ts,
+                    type: 'response_item',
+                    payload: {
+                        type: 'function_call',
+                        name: block.name,
+                        arguments: JSON.stringify(block.input || {}),
+                        call_id: block.id,
+                    },
+                });
+            }
+        }
+    }
+    else if (typeof content === 'string') {
+        outputTextBlocks.push({ type: 'output_text', text: content });
+        lines.push({
+            timestamp: ts,
+            type: 'event_msg',
+            payload: {
+                type: 'agent_message',
+                message: content,
+                phase: 'final_answer',
+            },
+        });
+    }
+    // response_item with role:"assistant" — this is what Codex uses to rebuild context
+    if (outputTextBlocks.length > 0) {
+        lines.push({
+            timestamp: ts,
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'assistant',
+                content: outputTextBlocks,
+                phase: 'final_answer',
+            },
+        });
+    }
+    return lines;
+}
+function reconstructResult(event) {
+    return {
+        timestamp: event.timestamp || new Date().toISOString(),
+        type: 'event_msg',
+        payload: {
+            type: 'task_complete',
+            turn_id: uuidv4(),
+            last_agent_message: event.result || '',
+        },
+    };
+}
+function reconstructControlRequest(event) {
+    const toolUse = event.request?.tool_use;
+    if (!toolUse)
+        return null;
+    // Map AskUserQuestion back to request_user_input
+    const name = toolUse.name === 'AskUserQuestion' ? 'request_user_input' : toolUse.name;
+    return {
+        timestamp: event.timestamp || new Date().toISOString(),
+        type: 'response_item',
+        payload: {
+            type: 'function_call',
+            name,
+            arguments: JSON.stringify(toolUse.input || {}),
+            call_id: event.request_id || uuidv4(),
+        },
+    };
+}
+function reconstructTurnContext(turnId, cwd, model) {
+    return {
+        timestamp: new Date().toISOString(),
+        type: 'turn_context',
+        payload: {
+            turn_id: turnId,
+            cwd,
+            current_date: new Date().toISOString().split('T')[0],
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            approval_policy: 'on-request',
+            sandbox_policy: {
+                type: 'workspace-write',
+                writable_roots: [],
+                network_access: false,
+                exclude_tmpdir_env_var: false,
+                exclude_slash_tmp: false,
+            },
+            model,
+            personality: 'pragmatic',
+            collaboration_mode: { mode: 'default', settings: {} },
+            realtime_active: false,
+            summary: 'none',
+            user_instructions: '',
+            truncation_policy: { mode: 'tokens', limit: 10000 },
+        },
+    };
+}
+function reconstructTaskStarted(turnId, ts) {
+    return {
+        timestamp: ts,
+        type: 'event_msg',
+        payload: {
+            type: 'task_started',
+            turn_id: turnId,
+            model_context_window: 258400,
+            collaboration_mode_kind: 'default',
+        },
+    };
+}
+function reconstructTaskComplete(turnId, ts, lastMessage) {
+    return {
+        timestamp: ts,
+        type: 'event_msg',
+        payload: {
+            type: 'task_complete',
+            turn_id: turnId,
+            last_agent_message: lastMessage,
+        },
+    };
+}
+/**
+ * Convert SessionEvent to zero or more Codex JSONL line objects.
+ */
+function toCodexJsonlLines(event, sessionUuid, cwd) {
+    switch (event.type) {
+        case 'system': {
+            const se = event;
+            if (se.subtype === 'init') {
+                return [reconstructSessionMeta(se, sessionUuid, cwd)];
+            }
+            return [];
+        }
+        case 'user': {
+            return reconstructUserMessage(event);
+        }
+        case 'assistant':
+            return reconstructAssistantMessage(event);
+        case 'result':
+            return [reconstructResult(event)];
+        case 'control_request': {
+            const cr = reconstructControlRequest(event);
+            return cr ? [cr] : [];
+        }
+        default:
+            return [];
+    }
+}
+// ═══════════════════════════════════════════════════════
+// Public API
+// ═══════════════════════════════════════════════════════
+/**
+ * Group events into turns (user message + following assistant/result events).
+ * Each turn gets wrapped with task_started, turn_context, task_complete.
+ */
+function groupIntoTurns(events) {
+    const system = [];
+    const turns = [];
+    let currentTurn = [];
+    for (const event of events) {
+        if (event.type === 'system') {
+            system.push(event);
+            continue;
+        }
+        // Skip non-conversation events (progress, last-prompt, etc.)
+        if (!['user', 'assistant', 'result', 'control_request'].includes(event.type)) {
+            continue;
+        }
+        if (event.type === 'user') {
+            // Tool results belong to the current turn, not a new one
+            const ue = event;
+            const content = ue.message.content;
+            const isToolResult = Array.isArray(content) && content.some((b) => b.type === 'tool_result');
+            if (!isToolResult && currentTurn.length > 0) {
+                turns.push(currentTurn);
+                currentTurn = [];
+            }
+        }
+        currentTurn.push(event);
+    }
+    if (currentTurn.length > 0)
+        turns.push(currentTurn);
+    return { system, turns };
+}
+/**
+ * Extract the last assistant text message from a turn for task_complete.
+ */
+function getLastAssistantText(turn) {
+    for (let i = turn.length - 1; i >= 0; i--) {
+        if (turn[i].type === 'assistant') {
+            const ae = turn[i];
+            const content = ae.message.content;
+            if (typeof content === 'string')
+                return content;
+            if (Array.isArray(content)) {
+                const textBlock = [...content].reverse().find((b) => b.type === 'text');
+                if (textBlock && 'text' in textBlock)
+                    return textBlock.text;
+            }
+        }
+    }
+    return '';
+}
+/**
+ * Write SessionEvent[] as a Codex JSONL file for `codex resume`.
+ * Path: ~/.codex/sessions/YYYY/MM/DD/rollout-{timestamp}-{uuid}.jsonl
+ *
+ * @returns The full path to the written JSONL file
+ */
+export function writeForkedCodexJsonl(events, targetUuid, directory) {
+    const dateDir = getDateDir();
+    fs.mkdirSync(dateDir, { recursive: true });
+    const filename = buildFilename(targetUuid);
+    const jsonlPath = path.join(dateDir, filename);
+    const cwd = directory || process.cwd();
+    const model = 'gpt-5.4';
+    const lines = [];
+    // Ensure there's a session_meta + developer prompt at the start.
+    // Codex CLI requires the developer prompt (permissions, sandbox config) to resume.
+    // Clone the header (session_meta + developer prompt) from the most recent real session.
+    const hasInit = events.some(e => e.type === 'system' && e.subtype === 'init');
+    if (!hasInit) {
+        const donorFile = findMostRecentCodexSession();
+        if (donorFile) {
+            try {
+                const donorContent = fs.readFileSync(donorFile, 'utf-8');
+                const donorLines = donorContent.split('\n').filter(l => l.trim());
+                const headerLines = donorLines.slice(0, 2); // session_meta + developer prompt
+                // Extract donor UUID to replace with ours
+                const donorMeta = JSON.parse(headerLines[0]);
+                const donorUuid = donorMeta?.payload?.id;
+                for (const line of headerLines) {
+                    const replaced = donorUuid ? line.replace(new RegExp(donorUuid, 'g'), targetUuid) : line;
+                    lines.push(replaced);
+                }
+            }
+            catch {
+                // Fallback to minimal session_meta if donor read fails
+                lines.push(JSON.stringify({
+                    timestamp: new Date().toISOString(),
+                    type: 'session_meta',
+                    payload: {
+                        id: targetUuid,
+                        timestamp: new Date().toISOString(),
+                        cwd,
+                        originator: 'codex_cli_rs',
+                        cli_version: '0.111.0',
+                        source: 'cli',
+                        model_provider: 'openai',
+                    },
+                }));
+            }
+        }
+        else {
+            lines.push(JSON.stringify({
+                timestamp: new Date().toISOString(),
+                type: 'session_meta',
+                payload: {
+                    id: targetUuid,
+                    timestamp: new Date().toISOString(),
+                    cwd,
+                    originator: 'codex_cli_rs',
+                    cli_version: '0.111.0',
+                    source: 'cli',
+                    model_provider: 'openai',
+                },
+            }));
+        }
+    }
+    const { system, turns } = groupIntoTurns(events);
+    // Emit system events (session_meta from init)
+    for (const event of system) {
+        const codexLines = toCodexJsonlLines(event, targetUuid, cwd);
+        for (const line of codexLines) {
+            lines.push(JSON.stringify(line));
+        }
+    }
+    // Emit each turn with proper Codex structure
+    for (const turn of turns) {
+        const turnId = uuidv4();
+        const turnTs = turn[0]?.timestamp || new Date().toISOString();
+        // task_started
+        lines.push(JSON.stringify(reconstructTaskStarted(turnId, turnTs)));
+        // turn_context
+        lines.push(JSON.stringify(reconstructTurnContext(turnId, cwd, model)));
+        // Turn events (response_items + event_msgs)
+        for (const event of turn) {
+            const codexLines = toCodexJsonlLines(event, targetUuid, cwd);
+            for (const line of codexLines) {
+                lines.push(JSON.stringify(line));
+            }
+        }
+        // task_complete
+        const lastMsg = getLastAssistantText(turn);
+        const lastTs = turn[turn.length - 1]?.timestamp || new Date().toISOString();
+        lines.push(JSON.stringify(reconstructTaskComplete(turnId, lastTs, lastMsg)));
+    }
+    fs.writeFileSync(jsonlPath, lines.join('\n') + '\n');
+    console.log(`[codex-jsonl-writer] Reconstructed ${lines.length} lines to ${jsonlPath}`);
+    return jsonlPath;
+}

package/dist/src/agents/lib/fs-tracking.d.ts

@@ -0,0 +1,36 @@
+import type { SessionEvent } from '../../events/types.js';
+/**
+ * Add LD_PRELOAD environment variables to an env record.
+ * Only adds them if the preload .so exists on disk.
+ */
+export declare function addPreloadEnv(env: Record<string, string | undefined>, preloadSessionId: string): void;
+/**
+ * Initialize all three levels of file change detection for an agent session.
+ *
+ * Call this after spawning the CLI process and obtaining the envId/pid.
+ */
+export declare function initFileTracking(opts: {
+    sessionId: string;
+    cwd: string;
+    pid: number;
+    preloadSessionId?: string;
+}): void;
+/**
+ * Tracks pending tool_use blocks and detects completed file-modifying tools.
+ * Create one instance per agent session and call `processEvent()` for each
+ * SessionEvent received from the JSONL watcher.
+ */
+export declare class ToolResultFileTracker {
+    private pendingToolUses;
+    private sessionId;
+    constructor(sessionId: string);
+    /**
+     * Process a SessionEvent. Indexes tool_use blocks from assistant messages
+     * and detects tool_result blocks from user messages, notifying fsMonitor
+     * for Write/Edit/NotebookEdit completions.
+     */
+    processEvent(event: SessionEvent): void;
+    private indexToolUses;
+    private matchToolResults;
+    private notifyIfFileChange;
+}