atoo-studio 0.0.1 → 0.0.2

package/dist/src/agents/claude-code-terminal-chatro/index.js

@@ -0,0 +1,45 @@
+import { ClaudeCodeTerminalChatROAgent } from './adapter.js';
+import { fsSessionScanner } from '../lib/claude/fs-sessions.js';
+import { writeForkedClaudeJsonl } from '../lib/claude/jsonl-writer.js';
+export class ClaudeCodeTerminalChatROAgentFactory {
+    agentType = 'claude-code-terminal-chatro';
+    agentFamily = 'claude';
+    create(sessionId) {
+        return new ClaudeCodeTerminalChatROAgent(sessionId);
+    }
+    getDescriptor() {
+        return {
+            agentType: this.agentType,
+            agentFamily: this.agentFamily,
+            name: 'Claude Code + ChatUI',
+            mode: 'terminal+chatRO',
+            iconUrl: `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="#d97757" viewBox="0 0 16 16"><path d="m3.127 10.604 3.135-1.76.053-.153-.053-.085H6.11l-.525-.032-1.791-.048-1.554-.065-1.505-.08-.38-.081L0 7.832l.036-.234.32-.214.455.04 1.009.069 1.513.105 1.097.064 1.626.17h.259l.036-.105-.089-.065-.068-.064-1.566-1.062-1.695-1.121-.887-.646-.48-.327-.243-.306-.104-.67.435-.48.585.04.15.04.593.456 1.267.981 1.654 1.218.242.202.097-.068.012-.049-.109-.181-.9-1.626-.96-1.655-.428-.686-.113-.411a2 2 0 0 1-.068-.484l.496-.674L4.446 0l.662.089.279.242.411.94.666 1.48 1.033 2.014.302.597.162.553.06.17h.105v-.097l.085-1.134.157-1.392.154-1.792.052-.504.25-.605.497-.327.387.186.319.456-.045.294-.19 1.23-.37 1.93-.243 1.29h.142l.161-.16.654-.868 1.097-1.372.484-.545.565-.601.363-.287h.686l.505.751-.226.775-.707.895-.585.759-.839 1.13-.524.904.048.072.125-.012 1.897-.403 1.024-.186 1.223-.21.553.258.06.263-.218.536-1.307.323-1.533.307-2.284.54-.028.02.032.04 1.029.098.44.024h1.077l2.005.15.525.346.315.424-.053.323-.807.411-3.631-.863-.872-.218h-.12v.073l.726.71 1.331 1.202 1.667 1.55.084.383-.214.302-.226-.032-1.464-1.101-.565-.497-1.28-1.077h-.084v.113l.295.432 1.557 2.34.08.718-.112.234-.404.141-.444-.08-.911-1.28-.94-1.44-.759-1.291-.093.053-.448 4.821-.21.246-.484.186-.403-.307-.214-.496.214-.98.258-1.28.21-1.016.19-1.263.112-.42-.008-.028-.092.012-.953 1.307-1.448 1.957-1.146 1.227-.274.109-.477-.247.045-.44.266-.39 1.586-2.018.956-1.25.617-.723-.004-.105h-.036l-4.212 2.736-.75.096-.324-.302.04-.496.154-.162 1.267-.871z"/></svg>')}`,
+        };
+    }
+    async getHistoricalSessions() {
+        const fsSessions = await fsSessionScanner.scan();
+        return fsSessions.map(s => ({
+            id: s.uuid,
+            agentType: this.agentType,
+            title: s.title,
+            directory: s.directory,
+            lastModified: s.lastModified,
+            eventCount: s.eventCount,
+        }));
+    }
+    async ownsSession(uuid) {
+        // This agent shares the same session file format as the terminal agent.
+        // Ownership is ambiguous — return false so the terminal agent claims it.
+        // Users can start a new terminal-chatro session and resume with it explicitly.
+        return false;
+    }
+    async getSessionFilesForProject(cwds) {
+        return fsSessionScanner.getFilesForProject(cwds);
+    }
+    async readSessionEvents(uuid) {
+        return fsSessionScanner.readEvents(uuid);
+    }
+    writeSessionForResume(events, targetUuid, directory) {
+        return writeForkedClaudeJsonl(events, targetUuid, directory);
+    }
+}

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

@@ -0,0 +1,67 @@
+/**
+ * JSONL session file discovery and tailing.
+ * Watches Claude CLI's session JSONL files for new events in real-time.
+ * Also discovers and tails subagent JSONL files from progress events.
+ */
+import { EventEmitter } from 'events';
+export interface SubagentMetadata {
+    sidechain: true;
+    parentToolUseID: string;
+    agentId: string;
+}
+export declare class JsonlWatcher extends EventEmitter {
+    private cwd;
+    private resumeUuid?;
+    private dirPath;
+    private targetPath;
+    private sessionUuid;
+    private lastReadOffset;
+    private lineBuffer;
+    private dirWatcher;
+    private fileWatcher;
+    private debounceTimer;
+    private discoveryTimer;
+    private stopped;
+    private preExistingFiles;
+    /** Active subagent tailers keyed by agentId */
+    private subagentTailers;
+    /** Maps agentId → parentToolUseID from the progress event that spawned it */
+    private subagentParents;
+    constructor(options: {
+        cwd: string;
+        resumeUuid?: string;
+    });
+    /**
+     * Phase 1: Snapshot existing JSONL files BEFORE the CLI is spawned.
+     * Must be called before the PTY spawn to avoid a race where the CLI
+     * creates its file before we record what was already there.
+     */
+    snapshot(): void;
+    /**
+     * Phase 2: Begin watching for a new file (or the known resume file).
+     * Called AFTER the PTY spawn.
+     */
+    start(): Promise<void>;
+    /** Set of agentIds currently being tailed (for adapter to check) */
+    get tailedAgentIds(): ReadonlySet<string>;
+    /**
+     * Start tailing a known session UUID file directly, bypassing discovery.
+     * Used when hooks report the exact session ID.
+     */
+    startTailingKnownUuid(uuid: string): void;
+    stop(): void;
+    private snapshotExisting;
+    private watchForNewFile;
+    private waitForFile;
+    private fallbackDiscovery;
+    private startTailing;
+    private debouncedRead;
+    private readFromOffset;
+    /**
+     * If the event is a progress event with data.agentId, start tailing
+     * the subagent's JSONL file.
+     */
+    private maybeStartSubagentTailer;
+    private startSubagentTailing;
+    private readSubagentFromOffset;
+}

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

@@ -0,0 +1,431 @@
+/**
+ * JSONL session file discovery and tailing.
+ * Watches Claude CLI's session JSONL files for new events in real-time.
+ * Also discovers and tails subagent JSONL files from progress events.
+ */
+import { EventEmitter } from 'events';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+const DISCOVERY_TIMEOUT = 5_000;
+const DEBOUNCE_MS = 50;
+/**
+ * Convert a cwd path to Claude CLI's dir-hash format.
+ * Replaces all non-alphanumeric chars with '-'.
+ * "/home/furti/myproject" → "-home-furti-myproject"
+ */
+function cwdToDirHash(cwd) {
+    const hashed = cwd.replace(/[^a-zA-Z0-9]/g, '-');
+    if (hashed.length <= 200)
+        return hashed;
+    const suffix = crypto.createHash('sha256').update(cwd).digest('hex').slice(0, 12);
+    return `${hashed.slice(0, 200)}-${suffix}`;
+}
+export class JsonlWatcher extends EventEmitter {
+    cwd;
+    resumeUuid;
+    dirPath;
+    targetPath = null;
+    sessionUuid = null;
+    lastReadOffset = 0;
+    lineBuffer = '';
+    dirWatcher = null;
+    fileWatcher = null;
+    debounceTimer = null;
+    discoveryTimer = null;
+    stopped = false;
+    preExistingFiles = new Set();
+    /** Active subagent tailers keyed by agentId */
+    subagentTailers = new Map();
+    /** Maps agentId → parentToolUseID from the progress event that spawned it */
+    subagentParents = new Map();
+    constructor(options) {
+        super();
+        this.cwd = options.cwd;
+        this.resumeUuid = options.resumeUuid;
+        this.dirPath = path.join(CLAUDE_PROJECTS_DIR, cwdToDirHash(this.cwd));
+    }
+    /**
+     * Phase 1: Snapshot existing JSONL files BEFORE the CLI is spawned.
+     * Must be called before the PTY spawn to avoid a race where the CLI
+     * creates its file before we record what was already there.
+     */
+    snapshot() {
+        if (this.resumeUuid)
+            return; // resume doesn't need a snapshot
+        this.snapshotExisting();
+        console.log(`[jsonl-watcher] Snapshot: ${this.preExistingFiles.size} existing JSONL files in ${this.dirPath}`);
+    }
+    /**
+     * Phase 2: Begin watching for a new file (or the known resume file).
+     * Called AFTER the PTY spawn.
+     */
+    async start() {
+        if (this.resumeUuid) {
+            // Known UUID — wait for that specific file
+            this.targetPath = path.join(this.dirPath, `${this.resumeUuid}.jsonl`);
+            this.sessionUuid = this.resumeUuid;
+            this.waitForFile(this.targetPath);
+        }
+        else {
+            // Watch for a new file that wasn't in the snapshot
+            this.watchForNewFile();
+        }
+    }
+    /** Set of agentIds currently being tailed (for adapter to check) */
+    get tailedAgentIds() {
+        return new Set(this.subagentTailers.keys());
+    }
+    /**
+     * Start tailing a known session UUID file directly, bypassing discovery.
+     * Used when hooks report the exact session ID.
+     */
+    startTailingKnownUuid(uuid) {
+        this.targetPath = path.join(this.dirPath, `${uuid}.jsonl`);
+        this.sessionUuid = uuid;
+        // Stop any active discovery
+        if (this.dirWatcher) {
+            this.dirWatcher.close();
+            this.dirWatcher = null;
+        }
+        if (this.discoveryTimer) {
+            clearTimeout(this.discoveryTimer);
+            this.discoveryTimer = null;
+        }
+        // Wait for the file to exist, then start tailing
+        this.waitForFile(this.targetPath);
+    }
+    stop() {
+        this.stopped = true;
+        if (this.dirWatcher) {
+            this.dirWatcher.close();
+            this.dirWatcher = null;
+        }
+        if (this.fileWatcher) {
+            this.fileWatcher.close();
+            this.fileWatcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.discoveryTimer) {
+            clearTimeout(this.discoveryTimer);
+            this.discoveryTimer = null;
+        }
+        // Stop all subagent tailers
+        for (const [agentId, tailer] of this.subagentTailers) {
+            if (tailer.fileWatcher)
+                tailer.fileWatcher.close();
+            if (tailer.debounceTimer)
+                clearTimeout(tailer.debounceTimer);
+            console.log(`[jsonl-watcher] Stopped subagent tailer: ${agentId}`);
+        }
+        this.subagentTailers.clear();
+        this.subagentParents.clear();
+    }
+    snapshotExisting() {
+        try {
+            if (fs.existsSync(this.dirPath)) {
+                for (const f of fs.readdirSync(this.dirPath)) {
+                    if (f.endsWith('.jsonl'))
+                        this.preExistingFiles.add(f);
+                }
+            }
+        }
+        catch { }
+    }
+    watchForNewFile() {
+        // Ensure the projects dir exists
+        try {
+            fs.mkdirSync(this.dirPath, { recursive: true });
+        }
+        catch { }
+        try {
+            this.dirWatcher = fs.watch(this.dirPath, (eventType, filename) => {
+                if (this.stopped || this.targetPath)
+                    return;
+                if (!filename || !filename.endsWith('.jsonl'))
+                    return;
+                if (this.preExistingFiles.has(filename))
+                    return;
+                // New JSONL file appeared
+                this.targetPath = path.join(this.dirPath, filename);
+                this.sessionUuid = filename.replace('.jsonl', '');
+                if (this.dirWatcher) {
+                    this.dirWatcher.close();
+                    this.dirWatcher = null;
+                }
+                if (this.discoveryTimer) {
+                    clearTimeout(this.discoveryTimer);
+                    this.discoveryTimer = null;
+                }
+                console.log(`[jsonl-watcher] Discovered session file: ${filename}`);
+                this.startTailing();
+            });
+        }
+        catch (err) {
+            console.warn(`[jsonl-watcher] Cannot watch directory ${this.dirPath}:`, err.message);
+        }
+        // Fallback: if no new file detected, pick the most recently modified one
+        this.discoveryTimer = setTimeout(() => {
+            if (this.stopped || this.targetPath)
+                return;
+            this.fallbackDiscovery();
+        }, DISCOVERY_TIMEOUT);
+    }
+    waitForFile(filePath) {
+        if (fs.existsSync(filePath)) {
+            console.log(`[jsonl-watcher] Resume file exists: ${path.basename(filePath)}`);
+            this.startTailing();
+            return;
+        }
+        // Watch directory for the file to appear
+        try {
+            fs.mkdirSync(this.dirPath, { recursive: true });
+        }
+        catch { }
+        const targetName = path.basename(filePath);
+        try {
+            this.dirWatcher = fs.watch(this.dirPath, (eventType, filename) => {
+                if (this.stopped)
+                    return;
+                if (filename === targetName) {
+                    if (this.dirWatcher) {
+                        this.dirWatcher.close();
+                        this.dirWatcher = null;
+                    }
+                    if (this.discoveryTimer) {
+                        clearTimeout(this.discoveryTimer);
+                        this.discoveryTimer = null;
+                    }
+                    console.log(`[jsonl-watcher] Resume file appeared: ${targetName}`);
+                    this.startTailing();
+                }
+            });
+        }
+        catch { }
+        this.discoveryTimer = setTimeout(() => {
+            if (this.stopped)
+                return;
+            if (fs.existsSync(filePath)) {
+                this.startTailing();
+            }
+            else {
+                console.warn(`[jsonl-watcher] Timeout waiting for resume file: ${targetName}`);
+            }
+        }, DISCOVERY_TIMEOUT);
+    }
+    fallbackDiscovery() {
+        try {
+            const files = fs.readdirSync(this.dirPath).filter(f => f.endsWith('.jsonl'));
+            if (files.length === 0) {
+                console.warn('[jsonl-watcher] No JSONL files found in', this.dirPath);
+                return;
+            }
+            // Prefer files NOT in the pre-existing snapshot (i.e., created after we started)
+            const newFiles = files.filter(f => !this.preExistingFiles.has(f));
+            const candidates = newFiles.length > 0 ? newFiles : files;
+            // Pick the most recently modified
+            let best = null;
+            for (const f of candidates) {
+                try {
+                    const stat = fs.statSync(path.join(this.dirPath, f));
+                    if (!best || stat.mtimeMs > best.mtime) {
+                        best = { name: f, mtime: stat.mtimeMs };
+                    }
+                }
+                catch { }
+            }
+            if (best) {
+                this.targetPath = path.join(this.dirPath, best.name);
+                this.sessionUuid = best.name.replace('.jsonl', '');
+                if (this.dirWatcher) {
+                    this.dirWatcher.close();
+                    this.dirWatcher = null;
+                }
+                console.log(`[jsonl-watcher] Fallback: using ${newFiles.length > 0 ? 'new' : 'most recent'} file: ${best.name}`);
+                this.startTailing();
+            }
+        }
+        catch { }
+    }
+    startTailing() {
+        if (this.stopped || !this.targetPath)
+            return;
+        // Read any existing content first (for resume or late discovery)
+        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(`[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;
+        }
+        // Handle truncation
+        if (stat.size < this.lastReadOffset) {
+            console.warn('[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');
+            // Last element may be incomplete — buffer it
+            this.lineBuffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    // Check for subagent progress events and start tailing subagent files
+                    this.maybeStartSubagentTailer(event);
+                    this.emit('event', event);
+                }
+                catch {
+                    // Skip unparseable lines
+                }
+            }
+        }
+        catch (err) {
+            console.error('[jsonl-watcher] Read error:', err.message);
+        }
+    }
+    /**
+     * If the event is a progress event with data.agentId, start tailing
+     * the subagent's JSONL file.
+     */
+    maybeStartSubagentTailer(event) {
+        if (event.type !== 'progress')
+            return;
+        const agentId = event.data?.agentId;
+        if (!agentId || this.subagentTailers.has(agentId))
+            return;
+        if (!this.sessionUuid)
+            return;
+        const parentToolUseID = event.parentToolUseID || event.toolUseID || '';
+        this.subagentParents.set(agentId, parentToolUseID);
+        const subagentPath = path.join(this.dirPath, this.sessionUuid, 'subagents', `agent-${agentId}.jsonl`);
+        // Start tailing, but the file may not exist yet
+        this.startSubagentTailing(agentId, subagentPath, parentToolUseID);
+    }
+    startSubagentTailing(agentId, filePath, parentToolUseID) {
+        const tailer = {
+            filePath,
+            lastReadOffset: 0,
+            lineBuffer: '',
+            fileWatcher: null,
+            debounceTimer: null,
+        };
+        this.subagentTailers.set(agentId, tailer);
+        const metadata = {
+            sidechain: true,
+            parentToolUseID,
+            agentId,
+        };
+        // Try to read existing content
+        this.readSubagentFromOffset(tailer, metadata);
+        // Watch for changes — file might not exist yet, retry with polling
+        const tryWatch = () => {
+            if (this.stopped)
+                return;
+            if (!fs.existsSync(filePath)) {
+                // File doesn't exist yet, retry shortly
+                setTimeout(tryWatch, 200);
+                return;
+            }
+            try {
+                tailer.fileWatcher = fs.watch(filePath, (eventType) => {
+                    if (this.stopped || eventType !== 'change')
+                        return;
+                    if (tailer.debounceTimer)
+                        return;
+                    tailer.debounceTimer = setTimeout(() => {
+                        tailer.debounceTimer = null;
+                        this.readSubagentFromOffset(tailer, metadata);
+                    }, DEBOUNCE_MS);
+                });
+                console.log(`[jsonl-watcher] Tailing subagent ${agentId}: ${path.basename(filePath)}`);
+                // Read again in case content appeared between our first read and the watch
+                this.readSubagentFromOffset(tailer, metadata);
+            }
+            catch (err) {
+                console.warn(`[jsonl-watcher] Cannot watch subagent file ${filePath}:`, err.message);
+            }
+        };
+        tryWatch();
+    }
+    readSubagentFromOffset(tailer, metadata) {
+        let stat;
+        try {
+            stat = fs.statSync(tailer.filePath);
+        }
+        catch {
+            return; // File doesn't exist yet
+        }
+        if (stat.size < tailer.lastReadOffset) {
+            tailer.lastReadOffset = 0;
+            tailer.lineBuffer = '';
+        }
+        if (stat.size <= tailer.lastReadOffset)
+            return;
+        try {
+            const fd = fs.openSync(tailer.filePath, 'r');
+            const buf = Buffer.alloc(stat.size - tailer.lastReadOffset);
+            fs.readSync(fd, buf, 0, buf.length, tailer.lastReadOffset);
+            fs.closeSync(fd);
+            tailer.lastReadOffset = stat.size;
+            const chunk = tailer.lineBuffer + buf.toString('utf-8');
+            const lines = chunk.split('\n');
+            tailer.lineBuffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    this.emit('event', event, metadata);
+                }
+                catch {
+                    // Skip unparseable lines
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[jsonl-watcher] Subagent read error (${metadata.agentId}):`, err.message);
+        }
+    }
+}

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

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

package/dist/src/agents/claude-code-terminal-chatro/spawner.js

@@ -0,0 +1,37 @@
+/**
+ * Claude Code Terminal+ChatRO–specific spawn logic.
+ * Plain `claude` PTY with MCP, system prompt, and LD_PRELOAD for file tracking.
+ */
+import os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+import { spawnProcess } from '../../spawner.js';
+import { ensureWorkspaceTrust } from '../lib/claude/workspace-trust.js';
+import { getMcpConfigPath, MCP_SYSTEM_PROMPT, CHAIN_SYSTEM_PROMPT } from '../../mcp/config.js';
+import { addPreloadEnv } from '../lib/fs-tracking.js';
+export function spawnTerminalCliProcess(options) {
+    const cwd = options.cwd || process.env.HOME || os.homedir();
+    ensureWorkspaceTrust(cwd);
+    const systemPrompt = options.isChainContinuation
+        ? MCP_SYSTEM_PROMPT + CHAIN_SYSTEM_PROMPT
+        : MCP_SYSTEM_PROMPT;
+    const mcpConfigPath = getMcpConfigPath(options.resumeSessionUuid);
+    const args = [];
+    if (options.skipPermissions)
+        args.push('--dangerously-skip-permissions');
+    args.push('--append-system-prompt', systemPrompt, '--mcp-config', mcpConfigPath);
+    if (options.resumeSessionUuid)
+        args.push('--resume', options.resumeSessionUuid);
+    const preloadSessionId = uuidv4();
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+    addPreloadEnv(env, preloadSessionId);
+    const { envId } = spawnProcess({
+        command: 'claude',
+        args,
+        cwd,
+        env,
+        preloadSessionId,
+        logPrefix: 'claude-terminal-chatro',
+    });
+    return { envId, preloadSessionId };
+}

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

@@ -0,0 +1,40 @@
+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-only Codex agent.
+ * Spawns a plain `codex` PTY — no JSONL tailing, no chat overlay.
+ * The user interacts purely via the terminal xterm view.
+ */
+export declare class CodexTerminalAgent extends EventEmitter implements Agent {
+    readonly sessionId: string;
+    envId: string | null;
+    private status;
+    private cwd;
+    private createdAt;
+    private destroyed;
+    private cliSessionId;
+    private activityTracker;
+    constructor(sessionId: string);
+    initialize(options: AgentInitOptions): Promise<void>;
+    destroy(): Promise<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;
+    onFocused(): void;
+    onBlurred(): void;
+    sendKey(key: string): void;
+    getInfo(): AgentSessionInfo;
+    forkToResumable(_afterEventUuid: string, _fromEventUuid?: string, _targetDir?: string): string | null;
+    getMessages(): WireMessage[];
+    getEvents(): SessionEvent[];
+    getCliSessionId(): string | null;
+    getWireMessages(): WireMessage[];
+    private getCapabilities;
+    private setStatus;
+}