atoo-studio 0.0.1 → 0.0.2

package/dist/src/agents/codex-terminal-chatro/jsonl-watcher.d.ts

@@ -0,0 +1,36 @@
+/**
+ * JSONL session file tailer for Codex CLI.
+ *
+ * Codex stores sessions at:
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-{timestamp}-{uuid}.jsonl
+ *
+ * Session discovery is handled by the notify callback (notify.ts).
+ * This watcher only tails a known file by UUID.
+ */
+import { EventEmitter } from 'events';
+export declare class CodexJsonlWatcher extends EventEmitter {
+    private targetPath;
+    private lastReadOffset;
+    private lineBuffer;
+    private fileWatcher;
+    private debounceTimer;
+    private waitTimer;
+    private stopped;
+    private initialOffset;
+    /**
+     * Set the initial read offset to skip content already loaded historically.
+     * Must be called before startTailingUuid().
+     */
+    setInitialOffset(bytes: number): void;
+    /**
+     * Start tailing the session file for a known UUID.
+     * Finds the file on disk, waits for it to appear if needed, then tails.
+     */
+    startTailingUuid(uuid: string): void;
+    stop(): void;
+    private clearWaitTimer;
+    private findFileByUuid;
+    private beginTailing;
+    private debouncedRead;
+    private readFromOffset;
+}

package/dist/src/agents/codex-terminal-chatro/jsonl-watcher.js

@@ -0,0 +1,205 @@
+/**
+ * JSONL session file tailer for Codex CLI.
+ *
+ * Codex stores sessions at:
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-{timestamp}-{uuid}.jsonl
+ *
+ * Session discovery is handled by the notify callback (notify.ts).
+ * This watcher only tails a known file by UUID.
+ */
+import { EventEmitter } from 'events';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { mapCodexJsonlLine } from '../lib/codex/jsonl-mapper.js';
+const CODEX_SESSIONS_DIR = path.join(os.homedir(), '.codex', 'sessions');
+const DEBOUNCE_MS = 50;
+const FILE_WAIT_INTERVAL = 200;
+const FILE_WAIT_TIMEOUT = 30_000;
+export class CodexJsonlWatcher extends EventEmitter {
+    targetPath = null;
+    lastReadOffset = 0;
+    lineBuffer = '';
+    fileWatcher = null;
+    debounceTimer = null;
+    waitTimer = null;
+    stopped = false;
+    initialOffset = 0;
+    /**
+     * Set the initial read offset to skip content already loaded historically.
+     * Must be called before startTailingUuid().
+     */
+    setInitialOffset(bytes) {
+        this.initialOffset = bytes;
+    }
+    /**
+     * Start tailing the session file for a known UUID.
+     * Finds the file on disk, waits for it to appear if needed, then tails.
+     */
+    startTailingUuid(uuid) {
+        const filePath = this.findFileByUuid(uuid);
+        if (filePath) {
+            this.targetPath = filePath;
+            this.beginTailing();
+        }
+        else {
+            // File doesn't exist yet — poll until it appears
+            console.log(`[codex-jsonl-watcher] Waiting for session file for ${uuid}...`);
+            const startTime = Date.now();
+            this.waitTimer = setInterval(() => {
+                if (this.stopped) {
+                    this.clearWaitTimer();
+                    return;
+                }
+                const found = this.findFileByUuid(uuid);
+                if (found) {
+                    this.clearWaitTimer();
+                    this.targetPath = found;
+                    console.log(`[codex-jsonl-watcher] Found session file: ${path.basename(found)}`);
+                    this.beginTailing();
+                }
+                else if (Date.now() - startTime > FILE_WAIT_TIMEOUT) {
+                    this.clearWaitTimer();
+                    console.warn(`[codex-jsonl-watcher] Timed out waiting for session file for ${uuid}`);
+                }
+            }, FILE_WAIT_INTERVAL);
+        }
+    }
+    stop() {
+        this.stopped = true;
+        this.clearWaitTimer();
+        if (this.fileWatcher) {
+            this.fileWatcher.close();
+            this.fileWatcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+    }
+    clearWaitTimer() {
+        if (this.waitTimer) {
+            clearInterval(this.waitTimer);
+            this.waitTimer = null;
+        }
+    }
+    findFileByUuid(uuid) {
+        try {
+            const yearDirs = fs.readdirSync(CODEX_SESSIONS_DIR);
+            for (const year of yearDirs) {
+                const yearPath = path.join(CODEX_SESSIONS_DIR, year);
+                let monthDirs;
+                try {
+                    monthDirs = fs.readdirSync(yearPath);
+                }
+                catch {
+                    continue;
+                }
+                for (const month of monthDirs) {
+                    const monthPath = path.join(yearPath, month);
+                    let dayDirs;
+                    try {
+                        dayDirs = fs.readdirSync(monthPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const day of dayDirs) {
+                        const dayPath = path.join(monthPath, day);
+                        let files;
+                        try {
+                            files = fs.readdirSync(dayPath);
+                        }
+                        catch {
+                            continue;
+                        }
+                        for (const file of files) {
+                            if (file.includes(uuid) && file.endsWith('.jsonl')) {
+                                return path.join(dayPath, file);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+        return null;
+    }
+    beginTailing() {
+        if (this.stopped || !this.targetPath)
+            return;
+        // Skip content already loaded by historical pre-load
+        if (this.initialOffset > 0) {
+            this.lastReadOffset = this.initialOffset;
+            this.initialOffset = 0;
+        }
+        // Read any new content since the offset
+        this.readFromOffset();
+        // Watch for future changes
+        try {
+            this.fileWatcher = fs.watch(this.targetPath, (eventType) => {
+                if (this.stopped || eventType !== 'change')
+                    return;
+                this.debouncedRead();
+            });
+            this.emit('ready');
+        }
+        catch (err) {
+            console.error(`[codex-jsonl-watcher] Cannot watch file ${this.targetPath}:`, err.message);
+            this.emit('error', err);
+        }
+    }
+    debouncedRead() {
+        if (this.debounceTimer)
+            return;
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.readFromOffset();
+        }, DEBOUNCE_MS);
+    }
+    readFromOffset() {
+        if (!this.targetPath)
+            return;
+        let stat;
+        try {
+            stat = fs.statSync(this.targetPath);
+        }
+        catch {
+            return;
+        }
+        if (stat.size < this.lastReadOffset) {
+            console.warn('[codex-jsonl-watcher] File truncated, re-reading from start');
+            this.lastReadOffset = 0;
+            this.lineBuffer = '';
+        }
+        if (stat.size <= this.lastReadOffset)
+            return;
+        try {
+            const fd = fs.openSync(this.targetPath, 'r');
+            const buf = Buffer.alloc(stat.size - this.lastReadOffset);
+            fs.readSync(fd, buf, 0, buf.length, this.lastReadOffset);
+            fs.closeSync(fd);
+            this.lastReadOffset = stat.size;
+            const chunk = this.lineBuffer + buf.toString('utf-8');
+            const lines = chunk.split('\n');
+            this.lineBuffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    const events = mapCodexJsonlLine(parsed);
+                    for (const event of events) {
+                        this.emit('event', event);
+                    }
+                }
+                catch {
+                    // Skip unparseable lines
+                }
+            }
+        }
+        catch (err) {
+            console.error('[codex-jsonl-watcher] Read error:', err.message);
+        }
+    }
+}

package/dist/src/agents/codex-terminal-chatro/spawner.d.ts

@@ -0,0 +1,9 @@
+export declare function spawnCodexCliProcess(options: {
+    skipPermissions?: boolean;
+    cwd?: string;
+    resumeSessionUuid?: string;
+    isChainContinuation?: boolean;
+}): {
+    envId: string;
+    preloadSessionId: string;
+};

package/dist/src/agents/codex-terminal-chatro/spawner.js

@@ -0,0 +1,57 @@
+/**
+ * Codex Terminal+ChatRO spawn logic.
+ * Spawns a plain `codex` PTY or `codex resume <uuid>`.
+ */
+import crypto from 'crypto';
+import os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+import { spawnProcess } from '../../spawner.js';
+import { getMcpServerDef, MCP_SYSTEM_PROMPT, CHAIN_SYSTEM_PROMPT, registerMcpToken } from '../../mcp/config.js';
+import { addPreloadEnv } from '../lib/fs-tracking.js';
+export function spawnCodexCliProcess(options) {
+    const cwd = options.cwd || process.env.HOME || os.homedir();
+    let command;
+    let args;
+    const baseArgs = [];
+    if (options.skipPermissions)
+        baseArgs.push('--full-auto');
+    // Inject MCP server config via -c flags (per-process, doesn't affect other codex instances)
+    const mcpToken = crypto.randomUUID();
+    registerMcpToken(mcpToken);
+    const mcp = getMcpServerDef();
+    const mcpEnv = { ...mcp.env, ATOO_MCP_TOKEN: mcpToken };
+    if (options.resumeSessionUuid) {
+        mcpEnv.ATOO_CURRENT_SESSION_UUID = options.resumeSessionUuid;
+    }
+    baseArgs.push('-c', `mcp_servers.atoo-studio.command="${mcp.command}"`);
+    baseArgs.push('-c', `mcp_servers.atoo-studio.args=${JSON.stringify(mcp.args)}`);
+    for (const [key, value] of Object.entries(mcpEnv)) {
+        baseArgs.push('-c', `mcp_servers.atoo-studio.env.${key}="${value}"`);
+    }
+    // Inject system prompt with MCP tool usage instructions
+    const systemPrompt = options.isChainContinuation
+        ? MCP_SYSTEM_PROMPT + CHAIN_SYSTEM_PROMPT
+        : MCP_SYSTEM_PROMPT;
+    baseArgs.push('-c', `developer_instructions=${JSON.stringify(systemPrompt)}`);
+    if (options.resumeSessionUuid) {
+        // codex resume <session_id> [flags]
+        command = 'codex';
+        args = ['resume', options.resumeSessionUuid, ...baseArgs];
+    }
+    else {
+        command = 'codex';
+        args = [...baseArgs];
+    }
+    const preloadSessionId = uuidv4();
+    const env = { ...process.env };
+    addPreloadEnv(env, preloadSessionId);
+    const { envId } = spawnProcess({
+        command,
+        args,
+        cwd,
+        env,
+        preloadSessionId,
+        logPrefix: 'codex-terminal-chatro',
+    });
+    return { envId, preloadSessionId };
+}

package/dist/src/agents/lib/chain-builder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Chain builder: creates a new chain-linked session from a source session.
+ *
+ * Instead of compacting context (which loses information), a chain link:
+ * 1. Carries forward the last N log entries + all user messages from the source
+ * 2. Tells the LLM to use search_session_history(CurrentSessionChain) for deeper context
+ * 3. Links to the source via the session ID schema ({parent-last16}c{random15})
+ */
+import type { SessionEvent } from '../../events/types.js';
+/**
+ * Build chain link events and UUID from a source session's events.
+ * Does NOT write to disk — the caller decides which format to write (Claude/Codex).
+ *
+ * @param sourceEvents - Events from the source session
+ * @param parentSessionId - The source session's ID (for parent-linking)
+ * @returns { uuid, events } or null if source has no conversation content
+ */
+export declare function buildChainSession(sourceEvents: SessionEvent[], parentSessionId: string): {
+    uuid: string;
+    events: SessionEvent[];
+} | null;

package/dist/src/agents/lib/chain-builder.js

@@ -0,0 +1,139 @@
+import { buildLinkedUuid } from './session-id-utils.js';
+const MAX_PAIRS = 10;
+/**
+ * Extract text from an assistant event's content, stripping tool_use blocks and thinking.
+ * Returns only the final text response, or null if there's no text.
+ */
+function extractAssistantText(event) {
+    const content = event.message?.content;
+    if (typeof content === 'string')
+        return content || null;
+    if (Array.isArray(content)) {
+        const texts = content
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text || '');
+        const joined = texts.join('\n').trim();
+        return joined || null;
+    }
+    return null;
+}
+/**
+ * Extract the last N user messages + their final assistant text responses.
+ * No tool calls, no tool results, no thinking, no intermediate events —
+ * just the clean conversation thread.
+ */
+function extractChainEvents(events) {
+    if (events.length === 0)
+        return [];
+    // Walk through events and pair each real user text message with the
+    // last assistant text response before the next user message.
+    // Also count hidden events (tool calls, tool results, thinking, etc.)
+    // between each user message so we can inform the LLM.
+    const pairs = [];
+    let lastUserIdx = -1;
+    let hiddenCount = 0;
+    for (let i = 0; i < events.length; i++) {
+        const e = events[i];
+        // Real user text message (not tool_result)
+        if (e.type === 'user') {
+            const content = e.message?.content;
+            const isToolResult = Array.isArray(content) && content.some((b) => b.type === 'tool_result');
+            if (isToolResult) {
+                hiddenCount++;
+                continue;
+            }
+            // Attribute accumulated hidden events to the previous pair
+            if (lastUserIdx >= 0) {
+                pairs[lastUserIdx].hiddenCount = hiddenCount;
+            }
+            hiddenCount = 0;
+            pairs.push({ user: e, assistant: null, hiddenCount: 0 });
+            lastUserIdx = pairs.length - 1;
+        }
+        else if (e.type === 'assistant' && lastUserIdx >= 0) {
+            const text = extractAssistantText(e);
+            if (text) {
+                // Build a clean assistant event with text-only content
+                pairs[lastUserIdx].assistant = {
+                    ...e,
+                    message: {
+                        ...e.message,
+                        content: [{ type: 'text', text }],
+                    },
+                };
+            }
+            // Count assistant events with only tool_use (no text) as hidden
+            if (!text)
+                hiddenCount++;
+        }
+        else {
+            // All other event types (progress, system, result, etc.) are hidden
+            hiddenCount++;
+        }
+    }
+    // Attribute final hidden count to last pair
+    if (lastUserIdx >= 0) {
+        pairs[lastUserIdx].hiddenCount = hiddenCount;
+    }
+    if (pairs.length === 0)
+        return [];
+    // Take the last N pairs
+    const selected = pairs.slice(-MAX_PAIRS);
+    // Flatten to event list: user, assistant, user, assistant, ...
+    // Prepend hidden count to assistant responses
+    const result = [];
+    for (const pair of selected) {
+        result.push(pair.user);
+        if (pair.assistant && pair.hiddenCount > 0) {
+            const a = pair.assistant;
+            const text = a.message.content[0].text;
+            result.push({
+                ...a,
+                message: {
+                    ...a.message,
+                    content: [{ type: 'text', text: `[${pair.hiddenCount} intermediate tool calls/results hidden]\n\n${text}` }],
+                },
+            });
+        }
+        else if (pair.assistant) {
+            result.push(pair.assistant);
+        }
+    }
+    // Inject chain context header into the first user message
+    if (result.length > 0) {
+        const header = '[This is a chain continuation session. The messages below are carried forward from the previous session in this chain. For full context from earlier in the conversation, use the search_session_history tool with type "CurrentSessionChain".]';
+        const first = result[0];
+        const msg = first.message;
+        const content = typeof msg.content === 'string'
+            ? `${header}\n\n${msg.content}`
+            : Array.isArray(msg.content)
+                ? [{ type: 'text', text: header }, ...msg.content]
+                : msg.content;
+        result[0] = { ...first, message: { ...msg, content } };
+    }
+    return result;
+}
+/**
+ * Build chain link events and UUID from a source session's events.
+ * Does NOT write to disk — the caller decides which format to write (Claude/Codex).
+ *
+ * @param sourceEvents - Events from the source session
+ * @param parentSessionId - The source session's ID (for parent-linking)
+ * @returns { uuid, events } or null if source has no conversation content
+ */
+export function buildChainSession(sourceEvents, parentSessionId) {
+    if (sourceEvents.length === 0)
+        return null;
+    const chainEvents = extractChainEvents(sourceEvents);
+    if (chainEvents.length === 0)
+        return null;
+    // Verify there are actual conversational events (user/assistant) that will
+    // survive JSONL reconstruction. Non-conversational events (progress, etc.)
+    // are filtered out by the writers, which would produce an empty file.
+    const CONVERSATIONAL_TYPES = new Set(['user', 'assistant', 'system', 'result', 'control_request', 'control_response']);
+    const hasConversation = chainEvents.some(e => CONVERSATIONAL_TYPES.has(e.type));
+    if (!hasConversation)
+        return null;
+    const chainUuid = buildLinkedUuid(parentSessionId, 'chain');
+    return { uuid: chainUuid, events: chainEvents };
+}

package/dist/src/agents/lib/claude/fs-sessions.d.ts

@@ -0,0 +1,31 @@
+export interface FsSessionMeta {
+    uuid: string;
+    dirHash: string;
+    directory: string;
+    title: string;
+    lastModified: string;
+    fileSize: number;
+    eventCount: number;
+    jsonlPath: string;
+}
+declare class FsSessionScanner {
+    private cache;
+    private lastScanTime;
+    scan(): Promise<FsSessionMeta[]>;
+    private parseSessionMeta;
+    readEvents(uuid: string): Promise<any[]>;
+    getByUuid(uuid: string): FsSessionMeta | undefined;
+    invalidate(): void;
+    /**
+     * Find the most recently modified session UUID for a given working directory.
+     * Useful as a fallback when hook-based CLI session discovery fails.
+     */
+    findMostRecentForCwd(cwd: string): Promise<string | null>;
+    /**
+     * Return all JSONL file paths (sessions + subagents) for sessions
+     * whose working directory matches any of the given cwds.
+     */
+    getFilesForProject(cwds: string[]): Promise<string[]>;
+}
+export declare const fsSessionScanner: FsSessionScanner;
+export {};