@addai/node 0.30.12 → 0.30.14

package/dist/direct/board-chat.d.ts

@@ -0,0 +1,40 @@
+import { type ChatProvider, type ProviderEvent } from './board-chat-provider';
+export type BoardBinding = {
+    sessionId: string;
+    desktopId: string;
+    spaceId: string;
+    workspaceId: string;
+    label: string;
+};
+export declare const CHAT_RECONNECT_MS = 90000;
+type Options = {
+    directory: string;
+    emit: (viewer: string, event: unknown) => void;
+    canStart: () => boolean;
+    onCount: () => void;
+    provider?: (cwd: string, emit: (event: ProviderEvent) => void, ended: (error: string) => void) => ChatProvider;
+};
+export declare function validateBinding(value: any): BoardBinding;
+/** Owner-scoped durable conversations. No prompts or actions are replayed on reconnect. */
+export declare class BoardChats {
+    private options;
+    private records;
+    constructor(options: Options);
+    get count(): number;
+    private save;
+    private emit;
+    private item;
+    private snapshot;
+    request(viewer: string, owner: string, input: unknown): unknown;
+    private run;
+    private event;
+    private armPending;
+    private resolve;
+    private finish;
+    private interrupt;
+    disconnect(viewer: string): void;
+    detach(viewer: string): void;
+    detachAll(): void;
+    stop(): void;
+}
+export {};

package/dist/direct/board-chat.js

@@ -0,0 +1,414 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoardChats = exports.CHAT_RECONNECT_MS = void 0;
+exports.validateBinding = validateBinding;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const protocol_1 = require("./protocol");
+const board_chat_provider_1 = require("./board-chat-provider");
+exports.CHAT_RECONNECT_MS = 90_000;
+function validateBinding(value) {
+    if (!value || !protocol_1.UUID.test(value.sessionId ?? '') || !protocol_1.UUID.test(value.desktopId ?? '') || !protocol_1.UUID.test(value.workspaceId ?? '') ||
+        typeof value.spaceId !== 'string' || !value.spaceId || value.spaceId.length > 200 || /[\x00-\x1f]/.test(value.spaceId) ||
+        typeof value.label !== 'string' || value.label.length > 200)
+        throw new Error('Open a saved board before starting a chat.');
+    return { sessionId: value.sessionId, desktopId: value.desktopId, spaceId: value.spaceId, workspaceId: value.workspaceId, label: value.label };
+}
+const sameBoard = (a, b) => ['sessionId', 'desktopId', 'spaceId', 'workspaceId'].every(k => a[k] === b[k]);
+const bounded = (value, size = 48_000) => JSON.stringify(value ?? null).slice(0, size);
+/** Tool consent is an empty MCP form. Never treat a data-entry form as consent. */
+function mcpConsent(params) {
+    const schema = params.requestedSchema;
+    if (params.mode !== 'form' || typeof params.serverName !== 'string' || !params.serverName || params.serverName.length > 200 ||
+        typeof params.message !== 'string' || !params.message.trim() || params.message.length > 8000 ||
+        !schema || schema.type !== 'object' || !schema.properties || typeof schema.properties !== 'object' || Array.isArray(schema.properties) ||
+        Object.keys(schema.properties).length ||
+        (schema.required !== undefined && (!Array.isArray(schema.required) || schema.required.length)) ||
+        Object.keys(schema).some(key => !['type', 'properties', 'required', 'title', 'description', 'additionalProperties'].includes(key)) ||
+        (schema.additionalProperties !== undefined && typeof schema.additionalProperties !== 'boolean'))
+        return null;
+    // Deliberately omit _meta: the browser cannot choose persistent/session approval.
+    return { serverName: params.serverName, message: params.message };
+}
+/** Owner-scoped durable conversations. No prompts or actions are replayed on reconnect. */
+class BoardChats {
+    options;
+    records = new Map();
+    constructor(options) {
+        this.options = options;
+        fs.mkdirSync(options.directory, { recursive: true, mode: 0o700 });
+        for (const name of fs.readdirSync(options.directory).slice(0, 2000)) {
+            if (!protocol_1.UUID.test(name.replace(/\.json$/, '')) || !name.endsWith('.json'))
+                continue;
+            try {
+                const file = path.join(options.directory, name);
+                if (fs.statSync(file).size > 16 * 1024 * 1024)
+                    continue;
+                const r = JSON.parse(fs.readFileSync(file, 'utf8'));
+                if (name !== `${r.id}.json` || !protocol_1.UUID.test(r.ownerId) || !Array.isArray(r.items) || !Array.isArray(r.sent) || !Number.isSafeInteger(r.seq))
+                    continue;
+                validateBinding(r.binding);
+                // A worker restart never resumes a partially completed action automatically.
+                for (const item of r.items)
+                    if (item.status === 'running')
+                        item.status = 'interrupted';
+                this.records.set(r.id, { record: r, busy: false, pending: new Map() });
+            }
+            catch { /* Quarantine unreadable records by leaving their files untouched. */ }
+        }
+    }
+    get count() { return [...this.records.values()].filter(l => l.provider).length; }
+    save(l) {
+        l.record.updatedAt = new Date().toISOString();
+        const file = path.join(this.options.directory, `${l.record.id}.json`);
+        fs.writeFileSync(file + '.tmp', JSON.stringify(l.record), { mode: 0o600 });
+        fs.renameSync(file + '.tmp', file);
+    }
+    emit(l, event) {
+        if (l.viewer)
+            this.options.emit(l.viewer, { type: 'board-chat', sessionId: l.record.id, attachmentId: l.attachment, ...event });
+    }
+    item(l, id, kind, text, status, append = false) {
+        l.bytes ??= Buffer.byteLength(JSON.stringify(l.record));
+        let item = l.record.items.find(i => i.id === id);
+        const priorBytes = item ? Buffer.byteLength(JSON.stringify(item)) : 0;
+        if (!item) {
+            item = { id, kind, text: '', seq: ++l.record.seq };
+            l.record.items.push(item);
+        }
+        item.text = (append ? item.text + text : text).slice(0, 48_000);
+        item.status = status;
+        while (Buffer.byteLength(JSON.stringify(item)) > 48_000)
+            item.text = item.text.slice(0, Math.floor(item.text.length * .8));
+        l.bytes += Buffer.byteLength(JSON.stringify(item)) - priorBytes;
+        this.emit(l, { item: { ...item }, busy: l.busy });
+    }
+    snapshot(l, before = Infinity) {
+        const items = [];
+        let size = 0;
+        for (const item of l.record.items.filter(i => i.seq < before).reverse()) {
+            const bytes = Buffer.byteLength(JSON.stringify(item));
+            if (items.length && (size + bytes > 100_000 || items.length >= 60))
+                break;
+            items.unshift(item);
+            size += bytes;
+        }
+        return { id: l.record.id, binding: l.record.binding, attachmentId: l.attachment, busy: l.busy, items,
+            before: items[0]?.seq > 1 ? items[0].seq : null,
+            pending: [...l.pending.values()].map(({ timer, rpcId, ...p }) => p) };
+    }
+    request(viewer, owner, input) {
+        if (!protocol_1.UUID.test(viewer) || !protocol_1.UUID.test(owner))
+            throw new Error('Invalid chat owner.');
+        const r = (0, protocol_1.parseRequest)(input), chat = r.chat;
+        if (r.op !== 'chat')
+            throw new Error('Invalid chat request.');
+        if (chat.action === 'open') {
+            const binding = validateBinding(chat.binding);
+            let l = this.records.get(r.sessionId);
+            if (!l && !chat.fresh)
+                l = [...this.records.values()].filter(x => x.record.ownerId === owner && sameBoard(x.record.binding, binding)).sort((a, b) => b.record.updatedAt.localeCompare(a.record.updatedAt))[0];
+            if (!l) {
+                if ([...this.records.values()].filter(x => x.record.ownerId === owner).length >= 500)
+                    throw new Error('This machine has reached its saved chat limit.');
+                l = { record: { id: r.sessionId, ownerId: owner, binding, items: [], sent: [], seq: 0, updatedAt: new Date().toISOString() }, busy: false, pending: new Map() };
+                this.save(l);
+                this.records.set(l.record.id, l);
+            }
+            if (l.record.ownerId !== owner || !sameBoard(l.record.binding, binding))
+                throw new Error('This conversation belongs to a different board or account.');
+            // Reopening the same conversation transfers its attachment, never its turn.
+            // This also covers a refresh racing the old socket's close notification.
+            for (const previous of this.records.values())
+                if (previous !== l && previous.viewer === viewer) {
+                    this.interrupt(previous, 'You switched conversations. Send a message to continue this one.');
+                    previous.viewer = undefined;
+                    previous.attachment = undefined;
+                }
+            if (l.viewer && l.viewer !== viewer)
+                this.emit(l, { detached: true, busy: false, clearPending: true });
+            if (l.reconnectTimer)
+                clearTimeout(l.reconnectTimer);
+            l.reconnectTimer = undefined;
+            l.viewer = viewer;
+            l.attachment = (0, node_crypto_1.randomUUID)();
+            for (const pending of l.pending.values())
+                this.armPending(l, pending);
+            return this.snapshot(l);
+        }
+        const l = this.records.get(r.sessionId);
+        if (!l || l.record.ownerId !== owner || l.viewer !== viewer || l.attachment !== r.attachmentId)
+            throw new Error('This chat connection changed. Reopen it before continuing.');
+        if (chat.action === 'conversations')
+            return { conversations: [...this.records.values()]
+                    .filter(x => x.record.ownerId === owner && sameBoard(x.record.binding, l.record.binding))
+                    .sort((a, b) => b.record.updatedAt.localeCompare(a.record.updatedAt))
+                    .map(x => ({ id: x.record.id, title: (x.record.items.find(i => i.kind === 'user')?.text || 'New conversation').slice(0, 40), updatedAt: x.record.updatedAt })) };
+        if (chat.action === 'history')
+            return this.snapshot(l, chat.before);
+        if (chat.action === 'detach') {
+            this.detach(viewer);
+            return { detached: true };
+        }
+        if (chat.action === 'cancel') {
+            this.interrupt(l);
+            return { cancelled: true };
+        }
+        if (chat.action === 'reply') {
+            const pending = l.pending.get(chat.callId);
+            if (!pending || pending.expiresAt <= Date.now())
+                throw new Error('This request has expired.');
+            this.resolve(l, pending, chat);
+            return { received: true };
+        }
+        if (chat.action === 'send') {
+            if (l.record.sent.includes(chat.messageId))
+                return { accepted: true, duplicate: true };
+            if (l.busy)
+                throw new Error('Wait for the current reply, or stop it first.');
+            if (!this.options.canStart())
+                throw new Error('Your machine is busy. Stop another coding session or try again shortly.');
+            if (l.record.items.length >= 1500 || l.record.sent.length >= 500 || (l.bytes ?? Buffer.byteLength(JSON.stringify(l.record))) >= 8 * 1024 * 1024)
+                throw new Error('Start a new conversation to continue. This chat remains saved.');
+            l.record.sent.push(chat.messageId);
+            l.busy = true;
+            this.item(l, chat.messageId, 'user', chat.text);
+            try {
+                this.save(l);
+            }
+            catch (error) {
+                l.busy = false;
+                throw error;
+            }
+            // Return immediately: tool answers and approvals must not wait behind a model turn.
+            void this.run(l, chat.text);
+            return { accepted: true };
+        }
+        throw new Error('Unknown chat action.');
+    }
+    async run(l, text) {
+        let provider;
+        try {
+            const cwd = path.join(this.options.directory, 'workspaces', l.record.id);
+            fs.mkdirSync(cwd, { recursive: true, mode: 0o700 });
+            provider = (this.options.provider || ((cwd, emit, ended) => new board_chat_provider_1.CodexBoardProvider(cwd, emit, ended)))(cwd, event => { if (l.provider === provider)
+                this.event(l, event); }, error => { if (l.provider === provider)
+                this.finish(l, error); });
+            l.provider = provider;
+            this.options.onCount();
+            const threadId = await provider.start(l.record.threadId);
+            if (l.provider !== provider || (!l.viewer && !l.reconnectTimer))
+                return;
+            l.record.threadId = threadId;
+            this.save(l);
+            await provider.send(threadId, text);
+        }
+        catch (error) {
+            if (!provider || l.provider === provider)
+                this.finish(l, error.message);
+        }
+    }
+    event(l, event) {
+        if (l.record.items.length >= 2000 || (l.bytes ?? 0) > 8 * 1024 * 1024) {
+            this.finish(l, 'This conversation is full. Start a new one to continue; its history remains saved.');
+            return;
+        }
+        const p = event.params || {};
+        if (event.id !== undefined) {
+            const mcp = event.method === 'mcpServer/elicitation/request';
+            const consent = mcp ? mcpConsent(p) : null;
+            if (mcp && (p.threadId !== l.record.threadId || (p.turnId && p.turnId !== l.turnId))) {
+                l.provider?.reply(event.id, { action: 'decline' });
+                return;
+            }
+            if (mcp && !consent) {
+                l.provider?.reply(event.id, { action: 'decline' });
+                this.item(l, (0, node_crypto_1.randomUUID)(), 'notice', 'A tool requested a form or sign-in interaction this chat cannot display yet. That request was declined; no permission was granted.');
+                return;
+            }
+            const kind = event.method === 'item/tool/call' && p.tool === 'aiboards' ? 'board-tool'
+                : ['item/commandExecution/requestApproval', 'item/fileChange/requestApproval'].includes(event.method) ? 'approval'
+                    : mcp ? 'mcp-approval'
+                        : event.method === 'item/tool/requestUserInput' ? 'question' : null;
+            if (!kind) {
+                this.finish(l, 'Codex requested an interaction this chat does not support yet. Continue in the native CodeFlows terminal.');
+                return;
+            }
+            if ((!l.viewer && !l.reconnectTimer) || l.pending.size >= 8) {
+                this.finish(l, 'Board access is paused or there are too many pending requests.');
+                return;
+            }
+            const id = (0, node_crypto_1.randomUUID)(), expiresAt = Date.now() + (kind === 'board-tool' ? 30_000 : 5 * 60_000);
+            const params = kind === 'board-tool' ? { arguments: p.arguments }
+                : kind === 'mcp-approval' ? consent
+                    : kind === 'question' ? { questions: p.questions }
+                        : { reason: p.reason, command: p.command, cwd: p.cwd, changes: p.changes || l.changes?.get(p.itemId), grantRoot: p.grantRoot };
+            if (Buffer.byteLength(JSON.stringify(params)) > 12_000) {
+                this.finish(l, 'A tool request was too large to review here. Continue in the native CodeFlows terminal.');
+                return;
+            }
+            const pending = { id, rpcId: event.id, kind, params, expiresAt };
+            l.pending.set(id, pending);
+            if (l.viewer)
+                this.armPending(l, pending);
+            this.emit(l, { pending: { id, kind, params, expiresAt } });
+            return;
+        }
+        if (event.method === 'serverRequest/resolved' && p.threadId === l.record.threadId) {
+            for (const pending of l.pending.values())
+                if (pending.rpcId === p.requestId) {
+                    clearTimeout(pending.timer);
+                    l.pending.delete(pending.id);
+                    this.emit(l, { resolved: pending.id });
+                }
+            return;
+        }
+        if (event.method === 'turn/started') {
+            l.turnId = p.turn?.id;
+            this.emit(l, { busy: true });
+        }
+        const itemKey = (id) => `${p.turnId || l.turnId || 'starting'}:${id}`;
+        if (event.method === 'item/agentMessage/delta')
+            this.item(l, itemKey(p.itemId), 'assistant', p.delta || '', 'running', true);
+        if (['item/started', 'item/completed'].includes(event.method)) {
+            const item = p.item || {}, status = event.method === 'item/started' ? 'running' : 'done';
+            if (item.type === 'fileChange' && item.changes) {
+                l.changes ??= new Map();
+                l.changes.set(item.id, item.changes);
+            }
+            if (item.type === 'agentMessage')
+                this.item(l, itemKey(item.id), 'assistant', item.text || '', status);
+            if (['commandExecution', 'fileChange', 'mcpToolCall', 'dynamicToolCall', 'webSearch'].includes(item.type)) {
+                const label = item.type === 'commandExecution' ? item.command : item.type === 'mcpToolCall' ? `${item.server}: ${item.tool}` : item.type === 'dynamicToolCall' ? item.tool : item.type === 'webSearch' ? 'Searching the web' : 'Editing files';
+                this.item(l, itemKey(item.id), 'tool', String(label || item.type).slice(0, 4000), item.status === 'failed' ? 'failed' : status);
+            }
+            if (status === 'done')
+                this.save(l);
+        }
+        if (event.method === 'board/mcp')
+            this.emit(l, { mcp: p });
+        if (event.method === 'turn/completed')
+            this.finish(l, p.turn?.error?.message || (p.turn?.status === 'interrupted' ? 'Reply stopped.' : undefined));
+        if (event.method === 'error' && !p.willRetry)
+            this.finish(l, p.error?.message || 'Codex could not finish this reply.');
+    }
+    armPending(l, pending) {
+        clearTimeout(pending.timer);
+        pending.expiresAt = Date.now() + (pending.kind === 'board-tool' ? 30_000 : 5 * 60_000);
+        pending.timer = setTimeout(() => {
+            if (l.pending.has(pending.id))
+                this.resolve(l, pending, { ok: false, error: 'The request expired.', decision: 'decline' });
+        }, pending.expiresAt - Date.now());
+    }
+    resolve(l, p, answer) {
+        clearTimeout(p.timer);
+        l.pending.delete(p.id);
+        const result = p.kind === 'board-tool' ? { success: answer.ok === true, contentItems: [{ type: 'inputText', text: bounded(answer.ok ? answer.result : { error: answer.error || 'Board access is paused.' }) }] }
+            : p.kind === 'mcp-approval' ? answer.decision === 'accept' ? { action: 'accept', content: {} } : { action: 'decline' }
+                : p.kind === 'approval' ? { decision: answer.decision === 'accept' ? 'accept' : 'decline' }
+                    : { answers: answer.answers || {} };
+        l.provider?.reply(p.rpcId, result);
+        this.emit(l, { resolved: p.id });
+    }
+    finish(l, error) {
+        if (l.reconnectTimer)
+            clearTimeout(l.reconnectTimer);
+        l.reconnectTimer = undefined;
+        const provider = l.provider;
+        l.provider = undefined;
+        l.busy = false;
+        l.turnId = undefined;
+        l.changes?.clear();
+        for (const p of l.pending.values())
+            clearTimeout(p.timer);
+        l.pending.clear();
+        provider?.close();
+        for (const item of l.record.items)
+            if (item.status === 'running')
+                item.status = error ? 'interrupted' : 'done';
+        if (error)
+            this.item(l, (0, node_crypto_1.randomUUID)(), 'notice', error.slice(0, 1000));
+        try {
+            this.save(l);
+        }
+        catch {
+            this.emit(l, { error: 'Conversation storage failed. Check free space on your machine.' });
+        }
+        this.emit(l, { busy: false, clearPending: true, interrupted: !!error });
+        this.options.onCount();
+    }
+    interrupt(l, reason = 'Reply stopped by you. Send a message to continue.') {
+        if (!l.busy && !l.provider)
+            return;
+        const provider = l.provider;
+        if (provider && l.turnId && l.record.threadId)
+            void provider.cancel(l.record.threadId, l.turnId).catch(() => { });
+        this.finish(l, reason);
+    }
+    // Network loss is not a user cancellation. Keep an accepted turn alive briefly;
+    // browser actions and approvals wait for a newly authenticated attachment.
+    disconnect(viewer) {
+        for (const l of this.records.values())
+            if (l.viewer === viewer) {
+                l.viewer = undefined;
+                l.attachment = undefined;
+                if (!l.busy && !l.provider)
+                    continue;
+                for (const pending of l.pending.values()) {
+                    clearTimeout(pending.timer);
+                    pending.timer = undefined;
+                }
+                if (!l.reconnectTimer)
+                    l.reconnectTimer = setTimeout(() => {
+                        l.reconnectTimer = undefined;
+                        this.interrupt(l, 'The board did not reconnect within 90 seconds, so this reply was stopped. Your work is saved; send a message to continue.');
+                    }, exports.CHAT_RECONNECT_MS);
+            }
+    }
+    detach(viewer) { for (const l of this.records.values())
+        if (l.viewer === viewer) {
+            this.interrupt(l, 'Chat closed. Send a message to continue.');
+            l.viewer = undefined;
+            l.attachment = undefined;
+        } }
+    detachAll() { for (const l of this.records.values())
+        if (l.viewer)
+            this.disconnect(l.viewer); }
+    stop() { for (const l of this.records.values())
+        this.interrupt(l, 'Your machine stopped the chat service. Your work is saved; send a message to continue.'); }
+}
+exports.BoardChats = BoardChats;

package/dist/direct/config.d.ts

@@ -0,0 +1,2 @@
+/** Optional local configuration survives normal Node restarts. Explicit env wins. */
+export declare function directEnvironment(env?: NodeJS.ProcessEnv, file?: string): NodeJS.ProcessEnv;

package/dist/direct/config.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directEnvironment = directEnvironment;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const paths_1 = require("../paths");
+/** Optional local configuration survives normal Node restarts. Explicit env wins. */
+function directEnvironment(env = process.env, file = path.join(paths_1.RUNTIME_HOME, 'codeflows.json')) {
+    if (env.AINODE_DIRECT_SESSIONS !== undefined)
+        return env;
+    try {
+        if (fs.statSync(file).size > 16_384)
+            return env;
+        const config = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (config?.enabled !== true || typeof config.relayUrl !== 'string' || !Array.isArray(config.roots))
+            return env;
+        return {
+            ...env, AINODE_DIRECT_SESSIONS: '1',
+            AINODE_DIRECT_RELAY_URL: env.AINODE_DIRECT_RELAY_URL ?? config.relayUrl,
+            AINODE_DIRECT_ROOTS: env.AINODE_DIRECT_ROOTS ?? JSON.stringify(config.roots),
+            AINODE_DIRECT_MAX_SESSIONS: env.AINODE_DIRECT_MAX_SESSIONS ?? String(config.maxSessions ?? 2),
+        };
+    }
+    catch {
+        return env;
+    } // Missing or damaged optional settings cannot prevent Node startup.
+}

package/dist/direct/launch.d.ts

@@ -0,0 +1,14 @@
+import type * as pty from 'node-pty';
+import type { SessionRecord, TerminalProcess } from './sessions';
+import { type AiosLaunch } from './aios-bridge';
+import type { DesktopCall } from './aios-tools';
+export declare function directProviders(): {
+    claude: boolean;
+    codex: boolean;
+};
+export declare function directArgs(record: SessionRecord, resume: boolean, aios?: AiosLaunch): string[];
+export declare function spawnDirect(record: SessionRecord, size: {
+    cols: number;
+    rows: number;
+}, resume: boolean, desktop?: DesktopCall): TerminalProcess;
+export declare function spawnDirectTerminal(file: string, args: string[], options: pty.IPtyForkOptions): TerminalProcess;

package/dist/direct/launch.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directProviders = directProviders;
+exports.directArgs = directArgs;
+exports.spawnDirect = spawnDirect;
+exports.spawnDirectTerminal = spawnDirectTerminal;
+const node_child_process_1 = require("node:child_process");
+const node_events_1 = require("node:events");
+const path = __importStar(require("node:path"));
+const claude_binary_1 = require("../claude-binary");
+const codex_binary_1 = require("../codex-binary");
+const win_1 = require("../win");
+const aios_bridge_1 = require("./aios-bridge");
+function directProviders() { return { claude: !!(0, claude_binary_1.findClaudeBinary)(), codex: !!(0, codex_binary_1.findCodexBinary)() }; }
+function directArgs(record, resume, aios) {
+    if (record.provider === 'claude') {
+        return ['--permission-mode', 'default', ...(resume ? ['--resume', record.nativeSessionId] : ['--session-id', record.nativeSessionId]), ...(aios ? ['--mcp-config', aios.claudeConfig] : [])];
+    }
+    // The native picker is deliberate. --last could resume an entity or another project's conversation.
+    const extra = aios ? Object.entries({ command: aios.command, args: aios.args, enabled: true, startup_timeout_sec: 10, tool_timeout_sec: 15 })
+        .flatMap(([key, value]) => ['-c', `mcp_servers.addai_codeflows.${key}=${JSON.stringify(value)}`]) : [];
+    return [...(resume ? ['resume'] : []), '--sandbox', 'workspace-write', '--ask-for-approval', 'on-request', ...extra];
+}
+function spawnDirect(record, size, resume, desktop) {
+    const bin = record.provider === 'claude' ? (0, claude_binary_1.findClaudeBinary)() : (0, codex_binary_1.findCodexBinary)();
+    if (!bin)
+        throw new Error('The selected program is not installed.');
+    const aios = record.aios === true && desktop ? (0, aios_bridge_1.createAiosBridge)(desktop) : undefined;
+    try {
+        const command = (0, win_1.resolveCliInvocation)(bin, directArgs(record, resume, aios));
+        const env = { ...process.env };
+        // Internal transport/config credentials are not agent inputs. Native provider credentials stay native.
+        for (const key of Object.keys(env))
+            if (key.startsWith('AINODE_DIRECT_') || key === 'SUPABASE_SERVICE_ROLE_KEY' || key === 'NODE_CHANNEL_FD')
+                delete env[key];
+        const proc = spawnDirectTerminal(command.file, command.args, {
+            name: 'xterm-256color', ...size, cwd: record.cwd,
+            env: { ...env, TERM: 'xterm-256color', COLORTERM: 'truecolor' },
+        });
+        proc.onExit(() => aios?.close());
+        return proc;
+    }
+    catch (err) {
+        aios?.close();
+        throw err;
+    }
+}
+function spawnDirectTerminal(file, args, options) {
+    // Each terminal owns a process tree. Stopping it bypasses node-pty's Windows
+    // console-list teardown race, and a finished terminal releases all host handles.
+    const hostOptions = {
+        stdio: ['ignore', 'ignore', 'ignore', 'ipc'], windowsHide: true, env: options.env,
+    };
+    const child = (0, node_child_process_1.fork)(path.join(__dirname, 'terminal.js'), [], hostOptions);
+    const events = new node_events_1.EventEmitter();
+    let ended = false, stopping = false, terminalExitCode;
+    const send = (message) => {
+        if (!ended && child.connected)
+            child.send(message, () => { });
+    };
+    child.on('message', (value) => {
+        if (value?.type === 'data' && typeof value.data === 'string')
+            events.emit('data', value.data);
+        if (value?.type === 'exit' && typeof value.exitCode === 'number')
+            terminalExitCode = value.exitCode;
+    });
+    const finish = (code) => {
+        if (ended)
+            return;
+        ended = true;
+        events.emit('exit', { exitCode: terminalExitCode ?? code });
+    };
+    child.on('error', () => finish(1));
+    child.on('exit', code => finish(code ?? 1));
+    send({ type: 'start', file, args, options });
+    return {
+        write: data => { if (!stopping)
+            send({ type: 'input', data }); },
+        resize: (cols, rows) => { if (!stopping)
+            send({ type: 'resize', cols, rows }); },
+        pause: () => send({ type: 'pause' }), resume: () => send({ type: 'resume' }),
+        kill: () => { if (!ended && !stopping) {
+            stopping = true;
+            (0, win_1.killProcessTree)(child);
+        } },
+        onData: cb => events.on('data', cb), onExit: cb => events.on('exit', cb),
+    };
+}