atoo-studio 0.0.1 → 0.0.2

package/dist/src/agents/codex-terminal/adapter.js

@@ -0,0 +1,160 @@
+import { EventEmitter } from 'events';
+import os from 'os';
+import { getProcessPid, getPty, killCliProcess } from '../../spawner.js';
+import { spawnCodexCliProcess } from './spawner.js';
+import { initFileTracking } from '../lib/fs-tracking.js';
+import { PtyActivityTracker } from '../lib/pty-activity-tracker.js';
+import { precreateCodexSession } from '../lib/session-precreate.js';
+/**
+ * Terminal-only Codex agent.
+ * Spawns a plain `codex` PTY — no JSONL tailing, no chat overlay.
+ * The user interacts purely via the terminal xterm view.
+ */
+export class CodexTerminalAgent extends EventEmitter {
+    sessionId;
+    envId = null;
+    status = 'open';
+    cwd = null;
+    createdAt = Date.now();
+    destroyed = false;
+    cliSessionId = null;
+    activityTracker = null;
+    constructor(sessionId) {
+        super();
+        this.sessionId = sessionId;
+    }
+    async initialize(options) {
+        this.cwd = options.cwd || os.homedir();
+        // Determine session UUID: use provided resume UUID, or pre-create a new one
+        const resumeUuid = options.resumeSessionUuid || precreateCodexSession(this.cwd);
+        this.cliSessionId = resumeUuid;
+        try {
+            const { envId, preloadSessionId } = spawnCodexCliProcess({
+                skipPermissions: options.skipPermissions,
+                cwd: this.cwd,
+                resumeSessionUuid: resumeUuid,
+                isChainContinuation: options.isChainContinuation,
+            });
+            this.envId = envId;
+            // Set up PTY activity tracking (burst detection → status events)
+            this.activityTracker = new PtyActivityTracker((status) => {
+                this.setStatus(status);
+            });
+            const pty = getPty(this.envId);
+            if (pty) {
+                pty.onData((data) => this.activityTracker?.onPtyData(data));
+            }
+            // Start file change detection (levels 1+2: LD_PRELOAD + inotify)
+            const pid = getProcessPid(this.envId);
+            if (pid) {
+                initFileTracking({
+                    sessionId: this.cliSessionId,
+                    cwd: this.cwd,
+                    pid,
+                    preloadSessionId,
+                });
+            }
+            this.emit('ready');
+        }
+        catch (err) {
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        if (this.activityTracker) {
+            this.activityTracker.dispose();
+            this.activityTracker = null;
+        }
+        if (this.envId) {
+            killCliProcess(this.envId);
+        }
+        this.setStatus('exited');
+        this.emit('exit');
+    }
+    // Terminal-only: type message directly into the PTY
+    sendMessage(text, _attachments) {
+        if (!text || !this.envId)
+            return;
+        const pty = getPty(this.envId);
+        if (!pty)
+            return;
+        setTimeout(() => {
+            const p = getPty(this.envId);
+            if (p)
+                p.write(text + '\n');
+        }, 2000);
+    }
+    approve(_requestId, _updatedInput) { }
+    deny(_requestId) { }
+    answerQuestion(_requestId, _answers) { }
+    setMode(_mode) { }
+    setModel(_model) { }
+    refreshContext() { }
+    onFocused() { this.activityTracker?.onFocused(); }
+    onBlurred() { this.activityTracker?.onBlurred(); }
+    sendKey(key) {
+        if (!this.envId)
+            return;
+        const pty = getPty(this.envId);
+        if (!pty)
+            return;
+        const KEY_MAP = {
+            escape: '\x1b',
+        };
+        const sequence = KEY_MAP[key];
+        if (sequence) {
+            pty.write(sequence);
+        }
+    }
+    getInfo() {
+        return {
+            sessionId: this.sessionId,
+            agentType: 'codex-terminal',
+            agentMode: 'terminal',
+            status: this.status,
+            mode: 'default',
+            cwd: this.cwd || undefined,
+            capabilities: this.getCapabilities(),
+            createdAt: this.createdAt,
+            cliSessionId: this.cliSessionId || undefined,
+        };
+    }
+    forkToResumable(_afterEventUuid, _fromEventUuid, _targetDir) {
+        return null;
+    }
+    getMessages() {
+        return [];
+    }
+    getEvents() {
+        return [];
+    }
+    getCliSessionId() {
+        return this.cliSessionId;
+    }
+    getWireMessages() {
+        return [];
+    }
+    getCapabilities() {
+        return {
+            canChangeMode: false,
+            canChangeModel: false,
+            hasContextUsage: false,
+            canFork: false,
+            canResume: true,
+            hasTerminal: true,
+            hasFileTracking: true,
+            availableModes: [],
+            availableModels: [],
+        };
+    }
+    setStatus(status) {
+        if (this.status === status)
+            return;
+        this.status = status;
+        this.emit('status', status);
+    }
+}

package/dist/src/agents/codex-terminal/index.d.ts

@@ -0,0 +1,13 @@
+import type { AgentFactory, Agent, AgentDescriptor, HistoricalSession } from '../types.js';
+import type { SessionEvent } from '../../events/types.js';
+export declare class CodexTerminalAgentFactory implements AgentFactory {
+    agentType: string;
+    agentFamily: string;
+    create(sessionId: string): Agent;
+    getDescriptor(): AgentDescriptor;
+    getHistoricalSessions(): Promise<HistoricalSession[]>;
+    ownsSession(uuid: string): Promise<boolean>;
+    getSessionFilesForProject(cwds: string[]): Promise<string[]>;
+    readSessionEvents(uuid: string): Promise<SessionEvent[]>;
+    writeSessionForResume(events: SessionEvent[], targetUuid: string, directory: string): string;
+}

package/dist/src/agents/codex-terminal/index.js

@@ -0,0 +1,47 @@
+import { CodexTerminalAgent } from './adapter.js';
+import { codexSessionScanner } from '../lib/codex/fs-sessions.js';
+import { writeForkedCodexJsonl } from '../lib/codex/jsonl-writer.js';
+export class CodexTerminalAgentFactory {
+    agentType = 'codex-terminal';
+    agentFamily = 'codex';
+    create(sessionId) {
+        return new CodexTerminalAgent(sessionId);
+    }
+    getDescriptor() {
+        return {
+            agentType: this.agentType,
+            agentFamily: this.agentFamily,
+            name: 'Codex',
+            mode: 'terminal',
+            iconUrl: `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="#10a37f" viewBox="0 0 24 24"><path d="M22.282 9.821a5.985 5.985 0 0 0-.516-4.91 6.046 6.046 0 0 0-6.51-2.9A6.065 6.065 0 0 0 4.981 4.18a5.985 5.985 0 0 0-3.998 2.9 6.046 6.046 0 0 0 .743 7.097 5.98 5.98 0 0 0 .51 4.911 6.051 6.051 0 0 0 6.515 2.9A5.985 5.985 0 0 0 13.26 24a6.056 6.056 0 0 0 5.772-4.206 5.99 5.99 0 0 0 3.997-2.9 6.056 6.056 0 0 0-.747-7.073zM13.26 22.43a4.476 4.476 0 0 1-2.876-1.04l.141-.081 4.779-2.758a.795.795 0 0 0 .392-.681v-6.737l2.02 1.168a.071.071 0 0 1 .038.052v5.583a4.504 4.504 0 0 1-4.494 4.494zM3.6 18.304a4.47 4.47 0 0 1-.535-3.014l.142.085 4.783 2.759a.771.771 0 0 0 .78 0l5.843-3.369v2.332a.08.08 0 0 1-.033.062L9.74 19.95a4.5 4.5 0 0 1-6.14-1.646zM2.34 7.896a4.485 4.485 0 0 1 2.366-1.973V11.6a.766.766 0 0 0 .388.676l5.815 3.355-2.02 1.168a.076.076 0 0 1-.071 0l-4.83-2.786A4.504 4.504 0 0 1 2.34 7.872zm16.597 3.855l-5.833-3.387L15.119 7.2a.076.076 0 0 1 .071 0l4.83 2.791a4.494 4.494 0 0 1-.676 8.105v-5.678a.79.79 0 0 0-.407-.667zm2.01-3.023l-.141-.085-4.774-2.782a.776.776 0 0 0-.785 0L9.409 9.23V6.897a.066.066 0 0 1 .028-.061l4.83-2.787a4.5 4.5 0 0 1 6.68 4.66zm-12.64 4.135l-2.02-1.164a.08.08 0 0 1-.038-.057V6.075a4.5 4.5 0 0 1 7.375-3.453l-.142.08L8.704 5.46a.795.795 0 0 0-.393.681zm1.097-2.365l2.602-1.5 2.607 1.5v2.999l-2.597 1.5-2.607-1.5z"/></svg>')}`,
+        };
+    }
+    async getHistoricalSessions() {
+        const sessions = await codexSessionScanner.scan();
+        return sessions.map(s => ({
+            id: s.uuid,
+            agentType: this.agentType,
+            title: s.title,
+            directory: s.directory,
+            lastModified: s.lastModified,
+            eventCount: s.eventCount,
+        }));
+    }
+    async ownsSession(uuid) {
+        const meta = codexSessionScanner.getByUuid(uuid);
+        if (meta)
+            return true;
+        codexSessionScanner.invalidate();
+        await codexSessionScanner.scan();
+        return !!codexSessionScanner.getByUuid(uuid);
+    }
+    async getSessionFilesForProject(cwds) {
+        return codexSessionScanner.getFilesForProject(cwds);
+    }
+    async readSessionEvents(uuid) {
+        return codexSessionScanner.readEvents(uuid);
+    }
+    writeSessionForResume(events, targetUuid, directory) {
+        return writeForkedCodexJsonl(events, targetUuid, directory);
+    }
+}

package/dist/src/agents/codex-terminal/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/spawner.js

@@ -0,0 +1,56 @@
+/**
+ * Codex Terminal–specific spawn logic.
+ * Spawns a plain `codex` PTY with MCP, system prompt, and LD_PRELOAD for file tracking.
+ */
+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) {
+        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',
+    });
+    return { envId, preloadSessionId };
+}

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

@@ -0,0 +1,58 @@
+import { EventEmitter } from 'events';
+import type { Agent, AgentInitOptions, AgentSessionInfo, Attachment } from '../types.js';
+import type { SessionEvent } from '../../events/types.js';
+import type { WireMessage } from '../../events/wire.js';
+/**
+ * Terminal + Chat Read-Only agent for Codex CLI.
+ * Spawns a plain `codex` PTY and uses the notify callback to discover
+ * the session thread-id, then tails the JSONL file for chat content.
+ */
+export declare class CodexTerminalChatROAgent extends EventEmitter implements Agent {
+    readonly sessionId: string;
+    envId: string | null;
+    private status;
+    private activityTracker;
+    private cwd;
+    private createdAt;
+    private destroyed;
+    private jsonlWatcher;
+    private toolTracker;
+    private wireMessages;
+    private events;
+    private pendingToolUses;
+    private cliSessionId;
+    private resumeSessionUuid;
+    constructor(sessionId: string);
+    initialize(options: AgentInitOptions): Promise<void>;
+    destroy(): Promise<void>;
+    onFocused(): void;
+    onBlurred(): void;
+    sendMessage(text: string, _attachments?: Attachment[]): void;
+    approve(_requestId: string, _updatedInput?: any): void;
+    deny(_requestId: string): void;
+    answerQuestion(_requestId: string, _answers: Record<string, string>): void;
+    setMode(_mode: string): void;
+    setModel(_model: string): void;
+    refreshContext(): void;
+    sendKey(key: string): void;
+    getInfo(): AgentSessionInfo;
+    forkToResumable(afterEventUuid: string, fromEventUuid?: string, targetDir?: string): string | null;
+    getCliSessionId(): string | null;
+    getMessages(): WireMessage[];
+    getEvents(): SessionEvent[];
+    getWireMessages(): WireMessage[];
+    /**
+     * Start tailing the JSONL file for a known session UUID.
+     * For resume: tails from the end of historical content (new appended content only).
+     * For new sessions: tails from offset 0 (reads everything).
+     */
+    private startTailing;
+    /**
+     * Read the known session file by UUID and populate events/wireMessages.
+     * Synchronous — no watcher, no discovery, just a direct file read.
+     */
+    private loadHistoricalFile;
+    private handleEvent;
+    private getCapabilities;
+    private setStatus;
+}

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

@@ -0,0 +1,266 @@
+import { EventEmitter } from 'events';
+import fs from 'fs';
+import os from 'os';
+import { toWireMessages } from '../../events/wire.js';
+import { mapCodexJsonlLine } from '../lib/codex/jsonl-mapper.js';
+import { codexSessionScanner } from '../lib/codex/fs-sessions.js';
+import { forkEventsToResumable } from '../lib/claude/jsonl-writer.js';
+import { getProcessPid, getPty, killCliProcess } from '../../spawner.js';
+import { spawnCodexCliProcess } from './spawner.js';
+import { CodexJsonlWatcher } from './jsonl-watcher.js';
+import { initFileTracking, ToolResultFileTracker } from '../lib/fs-tracking.js';
+import { PtyActivityTracker } from '../lib/pty-activity-tracker.js';
+import { precreateCodexSession } from '../lib/session-precreate.js';
+/**
+ * Terminal + Chat Read-Only agent for Codex CLI.
+ * Spawns a plain `codex` PTY and uses the notify callback to discover
+ * the session thread-id, then tails the JSONL file for chat content.
+ */
+export class CodexTerminalChatROAgent extends EventEmitter {
+    sessionId;
+    envId = null;
+    status = 'open';
+    activityTracker = null;
+    cwd = null;
+    createdAt = Date.now();
+    destroyed = false;
+    jsonlWatcher = null;
+    toolTracker = null;
+    wireMessages = [];
+    events = [];
+    pendingToolUses = new Map();
+    cliSessionId = null;
+    resumeSessionUuid = null;
+    constructor(sessionId) {
+        super();
+        this.sessionId = sessionId;
+    }
+    async initialize(options) {
+        this.cwd = options.cwd || os.homedir();
+        // Determine session UUID: use provided resume UUID, or pre-create a new one
+        const resumeUuid = options.resumeSessionUuid || precreateCodexSession(this.cwd);
+        this.cliSessionId = resumeUuid;
+        try {
+            if (options.resumeSessionUuid) {
+                this.resumeSessionUuid = options.resumeSessionUuid;
+                // Read historical events directly from the known file
+                this.loadHistoricalFile(options.resumeSessionUuid);
+            }
+            // Spawn the terminal PTY — always with resume since we pre-created the file
+            const { envId, preloadSessionId } = spawnCodexCliProcess({
+                skipPermissions: options.skipPermissions,
+                cwd: this.cwd,
+                resumeSessionUuid: resumeUuid,
+                isChainContinuation: options.isChainContinuation,
+            });
+            this.envId = envId;
+            // Set up PTY activity tracking (burst detection → status events)
+            this.activityTracker = new PtyActivityTracker((status) => {
+                this.setStatus(status);
+            });
+            const pty = getPty(this.envId);
+            if (pty) {
+                pty.onData((data) => this.activityTracker?.onPtyData(data));
+            }
+            // Start file change detection (all 3 levels)
+            const pid = getProcessPid(this.envId);
+            if (pid) {
+                initFileTracking({
+                    sessionId: this.cliSessionId,
+                    cwd: this.cwd,
+                    pid,
+                    preloadSessionId,
+                });
+            }
+            this.toolTracker = new ToolResultFileTracker(this.cliSessionId);
+            // Start tailing the known session file — UUID is known, no discovery needed
+            this.startTailing(resumeUuid);
+            this.emit('ready');
+        }
+        catch (err) {
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        if (this.activityTracker) {
+            this.activityTracker.dispose();
+            this.activityTracker = null;
+        }
+        if (this.jsonlWatcher) {
+            this.jsonlWatcher.stop();
+            this.jsonlWatcher = null;
+        }
+        if (this.envId) {
+            killCliProcess(this.envId);
+        }
+        this.setStatus('exited');
+        this.emit('exit');
+    }
+    onFocused() { this.activityTracker?.onFocused(); }
+    onBlurred() { this.activityTracker?.onBlurred(); }
+    // Terminal-only: type message directly into the PTY
+    sendMessage(text, _attachments) {
+        if (!text || !this.envId)
+            return;
+        const pty = getPty(this.envId);
+        if (!pty)
+            return;
+        setTimeout(() => {
+            const p = getPty(this.envId);
+            if (p)
+                p.write(text + '\n');
+        }, 2000);
+    }
+    approve(_requestId, _updatedInput) { }
+    deny(_requestId) { }
+    answerQuestion(_requestId, _answers) { }
+    setMode(_mode) { }
+    setModel(_model) { }
+    refreshContext() { }
+    sendKey(key) {
+        if (!this.envId)
+            return;
+        const pty = getPty(this.envId);
+        if (!pty)
+            return;
+        const KEY_MAP = {
+            escape: '\x1b',
+        };
+        const sequence = KEY_MAP[key];
+        if (sequence) {
+            pty.write(sequence);
+        }
+    }
+    getInfo() {
+        return {
+            sessionId: this.sessionId,
+            agentType: 'codex-terminal-chatro',
+            agentMode: 'terminal+chatRO',
+            status: this.status,
+            mode: 'default',
+            cwd: this.cwd || undefined,
+            capabilities: this.getCapabilities(),
+            createdAt: this.createdAt,
+            cliSessionId: this.cliSessionId || undefined,
+        };
+    }
+    forkToResumable(afterEventUuid, fromEventUuid, targetDir) {
+        const dir = targetDir || this.cwd || os.homedir();
+        const parentId = this.resumeSessionUuid || this.cliSessionId || this.sessionId;
+        return forkEventsToResumable(this.events, afterEventUuid, dir, parentId, fromEventUuid);
+    }
+    getCliSessionId() {
+        return this.cliSessionId;
+    }
+    getMessages() {
+        return this.wireMessages;
+    }
+    getEvents() {
+        return this.events;
+    }
+    getWireMessages() {
+        const wireToolUses = new Map();
+        const result = [];
+        for (const event of this.events) {
+            result.push(...toWireMessages(this.sessionId, event, wireToolUses));
+        }
+        return result;
+    }
+    /**
+     * Start tailing the JSONL file for a known session UUID.
+     * For resume: tails from the end of historical content (new appended content only).
+     * For new sessions: tails from offset 0 (reads everything).
+     */
+    startTailing(uuid) {
+        if (this.jsonlWatcher)
+            return; // already tailing
+        this.jsonlWatcher = new CodexJsonlWatcher();
+        this.jsonlWatcher.on('event', (event) => {
+            this.handleEvent(event);
+        });
+        this.jsonlWatcher.on('error', (err) => {
+            console.error(`[codex-terminal-chatro] JSONL watcher error:`, err.message);
+        });
+        // For resume: skip bytes already loaded by loadHistoricalFile
+        const filePath = codexSessionScanner.findSessionFile(uuid);
+        if (filePath && this.resumeSessionUuid) {
+            try {
+                const stat = fs.statSync(filePath);
+                this.jsonlWatcher.setInitialOffset(stat.size);
+            }
+            catch { }
+        }
+        this.jsonlWatcher.startTailingUuid(uuid);
+    }
+    /**
+     * Read the known session file by UUID and populate events/wireMessages.
+     * Synchronous — no watcher, no discovery, just a direct file read.
+     */
+    loadHistoricalFile(uuid) {
+        const filePath = codexSessionScanner.findSessionFile(uuid);
+        if (!filePath) {
+            console.warn(`[codex-terminal-chatro] Session file not found for ${uuid}`);
+            return;
+        }
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            for (const line of content.split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    const events = mapCodexJsonlLine(parsed);
+                    for (const event of events) {
+                        this.events.push(event);
+                        const wireMsgs = toWireMessages(this.sessionId, event, this.pendingToolUses);
+                        for (const msg of wireMsgs) {
+                            this.wireMessages.push(msg);
+                        }
+                    }
+                }
+                catch { /* skip unparseable lines */ }
+            }
+            console.log(`[codex-terminal-chatro] Loaded ${this.wireMessages.length} historical messages from ${uuid}`);
+        }
+        catch (err) {
+            console.warn(`[codex-terminal-chatro] Failed to read session file for ${uuid}:`, err.message);
+        }
+    }
+    handleEvent(event) {
+        this.events.push(event);
+        // Level 3: detect file-modifying tool results
+        this.toolTracker?.processEvent(event);
+        const mapped = toWireMessages(this.sessionId, event, this.pendingToolUses);
+        for (const msg of mapped) {
+            this.wireMessages.push(msg);
+            this.emit('message', msg);
+        }
+        // New content from watcher means codex is working
+        if (this.status !== 'active') {
+            this.setStatus('active');
+        }
+    }
+    getCapabilities() {
+        return {
+            canChangeMode: false,
+            canChangeModel: false,
+            hasContextUsage: false,
+            canFork: true,
+            canResume: true,
+            hasTerminal: true,
+            hasFileTracking: true,
+            availableModes: [],
+            availableModels: [],
+        };
+    }
+    setStatus(status) {
+        if (this.status === status)
+            return;
+        this.status = status;
+        this.emit('status', status);
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { AgentFactory, Agent, AgentDescriptor, HistoricalSession } from '../types.js';
+import type { SessionEvent } from '../../events/types.js';
+export declare class CodexTerminalChatROAgentFactory implements AgentFactory {
+    agentType: string;
+    agentFamily: string;
+    create(sessionId: string): Agent;
+    getDescriptor(): AgentDescriptor;
+    getHistoricalSessions(): Promise<HistoricalSession[]>;
+    ownsSession(uuid: string): Promise<boolean>;
+    getSessionFilesForProject(cwds: string[]): Promise<string[]>;
+    readSessionEvents(uuid: string): Promise<SessionEvent[]>;
+    writeSessionForResume(events: SessionEvent[], targetUuid: string, directory: string): string;
+}

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

@@ -0,0 +1,50 @@
+import { CodexTerminalChatROAgent } from './adapter.js';
+import { codexSessionScanner } from '../lib/codex/fs-sessions.js';
+import { writeForkedCodexJsonl } from '../lib/codex/jsonl-writer.js';
+export class CodexTerminalChatROAgentFactory {
+    agentType = 'codex-terminal-chatro';
+    agentFamily = 'codex';
+    create(sessionId) {
+        return new CodexTerminalChatROAgent(sessionId);
+    }
+    getDescriptor() {
+        return {
+            agentType: this.agentType,
+            agentFamily: this.agentFamily,
+            name: 'Codex + ChatUI',
+            mode: 'terminal+chatRO',
+            // Codex logo (green terminal icon)
+            iconUrl: `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="#10a37f" viewBox="0 0 24 24"><path d="M22.282 9.821a5.985 5.985 0 0 0-.516-4.91 6.046 6.046 0 0 0-6.51-2.9A6.065 6.065 0 0 0 4.981 4.18a5.985 5.985 0 0 0-3.998 2.9 6.046 6.046 0 0 0 .743 7.097 5.98 5.98 0 0 0 .51 4.911 6.051 6.051 0 0 0 6.515 2.9A5.985 5.985 0 0 0 13.26 24a6.056 6.056 0 0 0 5.772-4.206 5.99 5.99 0 0 0 3.997-2.9 6.056 6.056 0 0 0-.747-7.073zM13.26 22.43a4.476 4.476 0 0 1-2.876-1.04l.141-.081 4.779-2.758a.795.795 0 0 0 .392-.681v-6.737l2.02 1.168a.071.071 0 0 1 .038.052v5.583a4.504 4.504 0 0 1-4.494 4.494zM3.6 18.304a4.47 4.47 0 0 1-.535-3.014l.142.085 4.783 2.759a.771.771 0 0 0 .78 0l5.843-3.369v2.332a.08.08 0 0 1-.033.062L9.74 19.95a4.5 4.5 0 0 1-6.14-1.646zM2.34 7.896a4.485 4.485 0 0 1 2.366-1.973V11.6a.766.766 0 0 0 .388.676l5.815 3.355-2.02 1.168a.076.076 0 0 1-.071 0l-4.83-2.786A4.504 4.504 0 0 1 2.34 7.872zm16.597 3.855l-5.833-3.387L15.119 7.2a.076.076 0 0 1 .071 0l4.83 2.791a4.494 4.494 0 0 1-.676 8.105v-5.678a.79.79 0 0 0-.407-.667zm2.01-3.023l-.141-.085-4.774-2.782a.776.776 0 0 0-.785 0L9.409 9.23V6.897a.066.066 0 0 1 .028-.061l4.83-2.787a4.5 4.5 0 0 1 6.68 4.66zm-12.64 4.135l-2.02-1.164a.08.08 0 0 1-.038-.057V6.075a4.5 4.5 0 0 1 7.375-3.453l-.142.08L8.704 5.46a.795.795 0 0 0-.393.681zm1.097-2.365l2.602-1.5 2.607 1.5v2.999l-2.597 1.5-2.607-1.5z"/></svg>')}`,
+        };
+    }
+    async getHistoricalSessions() {
+        const sessions = await codexSessionScanner.scan();
+        return sessions.map(s => ({
+            id: s.uuid,
+            agentType: this.agentType,
+            title: s.title,
+            directory: s.directory,
+            lastModified: s.lastModified,
+            eventCount: s.eventCount,
+        }));
+    }
+    async ownsSession(uuid) {
+        // Check if we can find this session in Codex's session storage
+        const meta = codexSessionScanner.getByUuid(uuid);
+        if (meta)
+            return true;
+        // Try scanning if cache is empty
+        codexSessionScanner.invalidate();
+        await codexSessionScanner.scan();
+        return !!codexSessionScanner.getByUuid(uuid);
+    }
+    async getSessionFilesForProject(cwds) {
+        return codexSessionScanner.getFilesForProject(cwds);
+    }
+    async readSessionEvents(uuid) {
+        return codexSessionScanner.readEvents(uuid);
+    }
+    writeSessionForResume(events, targetUuid, directory) {
+        return writeForkedCodexJsonl(events, targetUuid, directory);
+    }
+}