@addai/node 0.30.13 → 0.30.14

package/dist/direct/sessions.js

@@ -0,0 +1,368 @@
+"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.DirectSessions = void 0;
+exports.isWithin = isWithin;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const headless_1 = require("@xterm/headless");
+const addon_serialize_1 = require("@xterm/addon-serialize");
+const protocol_1 = require("./protocol");
+const aios_tools_1 = require("./aios-tools");
+function isWithin(root, folder) {
+    const rel = path.relative(root, folder);
+    return rel === '' || (!path.isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${path.sep}`));
+}
+class DirectSessions {
+    deps;
+    records = new Map();
+    live = new Map();
+    roots;
+    shuttingDown = false;
+    // Operations are serialized by the worker; callers must not concurrently create/resume.
+    constructor(deps) {
+        this.deps = deps;
+        this.roots = deps.roots.map(root => fs.realpathSync(root));
+        if (!this.roots.length || this.roots.some(root => !fs.statSync(root).isDirectory()))
+            throw new Error('Configure at least one project root.');
+        fs.mkdirSync(deps.directory, { recursive: true, mode: 0o700 });
+        for (const name of fs.readdirSync(deps.directory)) {
+            if (!name.endsWith('.json') || !protocol_1.UUID.test(name.slice(0, -5)))
+                continue;
+            try {
+                const file = path.join(deps.directory, name);
+                if (fs.statSync(file).size > 16_384)
+                    continue;
+                const r = JSON.parse(fs.readFileSync(file, 'utf8'));
+                if (r.id !== name.slice(0, -5) || !protocol_1.UUID.test(r.ownerId) || !['claude', 'codex'].includes(r.provider) ||
+                    typeof r.cwd !== 'string' || typeof r.title !== 'string')
+                    continue;
+                if (r.provider === 'claude' && !protocol_1.UUID.test(r.nativeSessionId ?? ''))
+                    continue;
+                if (r.status === 'running') {
+                    r.status = 'exited';
+                    r.reason = 'The node restarted. Resume to continue.';
+                    this.save(r);
+                }
+                this.records.set(r.id, r);
+            }
+            catch { /* A damaged record must not prevent other sessions or the node starting. */ }
+        }
+    }
+    get count() { return this.live.size; }
+    save(r) {
+        const target = path.join(this.deps.directory, `${r.id}.json`);
+        const tmp = `${target}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(r), { mode: 0o600 });
+        fs.renameSync(tmp, target);
+    }
+    folder(raw) {
+        if (!path.isAbsolute(raw))
+            throw new Error('Use an absolute project path on the paired machine.');
+        let folder;
+        try {
+            folder = fs.realpathSync(raw);
+        }
+        catch {
+            throw new Error('That project folder does not exist on this machine.');
+        }
+        if (!fs.statSync(folder).isDirectory() || !this.roots.some(root => isWithin(root, folder))) {
+            throw new Error('That folder is outside the project roots enabled on this machine.');
+        }
+        for (const live of this.live.values()) {
+            if (isWithin(live.record.cwd, folder) || isWithin(folder, live.record.cwd)) {
+                throw new Error('A direct session already uses this folder. Reopen it or choose a separate working copy.');
+            }
+        }
+        return folder;
+    }
+    owned(id, ownerId) {
+        const r = this.records.get(id);
+        if (!r || r.ownerId !== ownerId)
+            throw new Error('Session not found.');
+        return r;
+    }
+    controlled(id, ownerId, viewerId) {
+        this.owned(id, ownerId);
+        const live = this.live.get(id);
+        if (!live || live.stopping)
+            throw new Error('This session is no longer running.');
+        if (live.viewer !== viewerId)
+            throw new Error('Connect to this session before controlling it.');
+        return live;
+    }
+    start(r, cols, rows, resume) {
+        if (this.shuttingDown)
+            throw new Error('The node is shutting down.');
+        if (this.deps.canStart && !this.deps.canStart())
+            throw new Error('This machine has reached its coding-session limit.');
+        if (this.live.size >= (this.deps.maxActive ?? 2))
+            throw new Error('This machine has reached its direct-session limit.');
+        if (!this.deps.providers()[r.provider])
+            throw new Error(`${r.provider === 'claude' ? 'Claude Code' : 'Codex'} is not installed on this machine.`);
+        r.cwd = this.folder(r.cwd);
+        r.status = 'running';
+        r.updatedAt = new Date().toISOString();
+        delete r.exitCode;
+        delete r.reason;
+        this.save(r);
+        const terminal = new headless_1.Terminal({ cols, rows, scrollback: 1000, allowProposedApi: true });
+        const serializer = new addon_serialize_1.SerializeAddon();
+        terminal.loadAddon(serializer);
+        let proc;
+        try {
+            proc = this.deps.spawn(r, { cols, rows }, resume, (name, args) => this.callDesktop(r.id, name, args));
+        }
+        catch (err) {
+            terminal.dispose();
+            r.status = 'exited';
+            r.reason = 'The program could not start.';
+            this.save(r);
+            throw err;
+        }
+        const live = { record: r, proc, terminal, serializer, viewer: null, seq: 0, pendingBytes: 0, stopping: false, unacked: new Map(), unackedBytes: 0, attachmentId: null, aios: false, calls: new Map() };
+        this.live.set(r.id, live);
+        this.deps.onCount?.(this.count);
+        proc.onData(data => {
+            // Bound the parser queue as well as the serialized screen. The PTY pauses until caught up.
+            live.pendingBytes += data.length;
+            if (live.pendingBytes > 1024 * 1024)
+                proc.pause?.();
+            terminal.write(data, () => {
+                live.pendingBytes -= data.length;
+                if (live.pendingBytes < 256 * 1024 && live.unackedBytes < 256 * 1024)
+                    proc.resume?.();
+                if (this.live.get(r.id) !== live)
+                    return;
+                // Each frame fits comfortably within the relay's payload limit.
+                for (let i = 0; i < data.length; i += 16_384) {
+                    const chunk = data.slice(i, i + 16_384);
+                    live.seq++;
+                    if (live.viewer) {
+                        live.unacked.set(live.seq, chunk.length);
+                        live.unackedBytes += chunk.length;
+                        this.deps.emit(live.viewer, { type: 'output', sessionId: r.id, seq: live.seq, data: chunk });
+                    }
+                }
+                if (live.unackedBytes > 256 * 1024)
+                    proc.pause?.();
+            });
+        });
+        proc.onExit(({ exitCode }) => {
+            const wasStopped = live.stopping;
+            live.stopping = true;
+            this.cancelCalls(live);
+            // Flush pending output before disposing the screen or emitting the exit event.
+            terminal.write('', () => {
+                if (this.live.get(r.id) !== live)
+                    return;
+                r.status = 'exited';
+                r.exitCode = exitCode;
+                r.updatedAt = new Date().toISOString();
+                r.reason = wasStopped ? 'Stopped.' : 'The program exited.';
+                try {
+                    this.save(r);
+                }
+                catch { /* Keep shutdown independent of disk health. */ }
+                this.live.delete(r.id);
+                this.deps.onCount?.(this.count);
+                if (live.viewer)
+                    this.deps.emit(live.viewer, { type: 'exit', session: { ...r } });
+                terminal.dispose();
+            });
+        });
+    }
+    async request(viewerId, ownerId, value) {
+        if (!protocol_1.UUID.test(ownerId) || !protocol_1.UUID.test(viewerId))
+            throw new Error('Invalid viewer.');
+        const q = (0, protocol_1.parseRequest)(value);
+        if (q.op === 'describe')
+            return { roots: this.roots, providers: this.deps.providers(), maxActive: this.deps.maxActive ?? 2, aios: aios_tools_1.AIOS_VERSION, aiosTools: aios_tools_1.AIOS_TOOLS.map(tool => tool.name) };
+        if (q.op === 'list')
+            return [...this.records.values()].filter(r => r.ownerId === ownerId).map(r => ({ ...r })).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        const id = q.sessionId;
+        if (q.op === 'create') {
+            // A retry with the same session ID must not spawn a second program.
+            if (this.records.has(id)) {
+                const prior = this.owned(id, ownerId);
+                if (prior.provider !== q.provider || prior.cwd !== fs.realpathSync(q.cwd))
+                    throw new Error('Session ID already exists.');
+                return { ...prior };
+            }
+            if ([...this.records.values()].filter(r => r.ownerId === ownerId).length >= 500)
+                throw new Error('The local session history is full.');
+            const now = new Date().toISOString();
+            const r = { id, ownerId, provider: q.provider, cwd: q.cwd, title: q.title?.trim() || path.basename(q.cwd), createdAt: now, updatedAt: now, status: 'exited' };
+            if (r.provider === 'claude')
+                r.nativeSessionId = (0, node_crypto_1.randomUUID)();
+            if (q.aios === true)
+                r.aios = true;
+            this.start(r, q.cols, q.rows, false);
+            this.records.set(id, r);
+            return { ...r };
+        }
+        const r = this.owned(id, ownerId);
+        if (q.op === 'resume') {
+            if (!this.live.has(id))
+                this.start(r, q.cols, q.rows, true);
+            return { ...r };
+        }
+        if (q.op === 'attach') {
+            const live = this.live.get(id);
+            if (!live || live.stopping)
+                throw new Error('This session has ended. Resume it to continue.');
+            if (live.viewer && live.viewer !== viewerId)
+                throw new Error('This session is open in another window. Close that connection first.');
+            // Detach this viewer from a previous session; only one input target per connection.
+            this.detach(viewerId);
+            await new Promise(resolve => live.terminal.write('', resolve));
+            if (this.live.get(id) !== live)
+                throw new Error('This session has ended.');
+            live.viewer = viewerId;
+            live.attachmentId = (0, node_crypto_1.randomUUID)();
+            live.aios = r.aios === true && q.aios === true;
+            live.terminal.resize(q.cols, q.rows);
+            live.proc.resize(q.cols, q.rows);
+            return { session: { ...r }, seq: live.seq, screen: live.serializer.serialize({ scrollback: 1000 }), attachmentId: live.attachmentId };
+        }
+        if (q.op === 'detach') {
+            if (this.live.get(id)?.viewer === viewerId)
+                this.detach(viewerId);
+            return {};
+        }
+        const live = this.controlled(id, ownerId, viewerId);
+        if (q.op === 'aios-result' || q.op === 'aios-access') {
+            if (q.attachmentId !== live.attachmentId)
+                throw new Error('The +Ai connection changed.');
+            if (q.op === 'aios-access') {
+                live.aios = r.aios === true && q.aios === true;
+                if (!live.aios)
+                    this.cancelCalls(live);
+            }
+            else {
+                const pending = live.calls.get(q.callId);
+                if (!pending)
+                    throw new Error('This +Ai call is no longer pending.');
+                live.calls.delete(q.callId);
+                clearTimeout(pending.timer);
+                if (q.ok)
+                    pending.resolve(q.result);
+                else
+                    pending.reject(new Error(q.error || '+Ai request failed.'));
+            }
+            return {};
+        }
+        if (q.op === 'ack') {
+            if (q.seq > live.seq)
+                throw new Error('Invalid output acknowledgment.');
+            for (const [seq, bytes] of live.unacked)
+                if (seq <= q.seq) {
+                    live.unackedBytes -= bytes;
+                    live.unacked.delete(seq);
+                }
+            if (live.unackedBytes < 64 * 1024 && live.pendingBytes < 256 * 1024)
+                live.proc.resume?.();
+        }
+        if (q.op === 'input')
+            live.proc.write(q.data);
+        if (q.op === 'resize') {
+            live.terminal.resize(q.cols, q.rows);
+            live.proc.resize(q.cols, q.rows);
+        }
+        if (q.op === 'stop') {
+            live.stopping = true;
+            this.cancelCalls(live);
+            live.proc.kill();
+        }
+        return {};
+    }
+    detach(viewerId) {
+        for (const live of this.live.values())
+            if (live.viewer === viewerId) {
+                this.cancelCalls(live);
+                live.attachmentId = null;
+                live.aios = false;
+                live.viewer = null;
+                live.unacked.clear();
+                live.unackedBytes = 0;
+                if (live.pendingBytes < 256 * 1024)
+                    live.proc.resume?.();
+            }
+    }
+    detachAll() { for (const live of this.live.values())
+        if (live.viewer)
+            this.detach(live.viewer); }
+    stop() {
+        this.shuttingDown = true;
+        for (const live of this.live.values()) {
+            live.stopping = true;
+            this.cancelCalls(live);
+            try {
+                live.proc.kill();
+            }
+            catch { /* Continue stopping the other direct sessions. */ }
+        }
+    }
+    cancelCalls(live) {
+        for (const pending of live.calls.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('+Ai access paused or disconnected. Reopen CodeFlows to continue.'));
+        }
+        live.calls.clear();
+    }
+    async callDesktop(id, name, args) {
+        (0, aios_tools_1.validateDesktopCall)(name, args);
+        const live = this.live.get(id);
+        if (!live || live.stopping || !live.viewer || !live.aios || !live.attachmentId)
+            throw new Error('+Ai access is unavailable. Attach this session in CodeFlows and enable +Ai access.');
+        if (live.calls.size >= 8)
+            throw new Error('Too many pending +Ai calls.');
+        const callId = (0, node_crypto_1.randomUUID)(), expiresAt = Date.now() + aios_tools_1.AIOS_TIMEOUT;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { live.calls.delete(callId); reject(new Error('+Ai desktop did not respond. Check the board before retrying an action.')); }, aios_tools_1.AIOS_TIMEOUT);
+            live.calls.set(callId, { resolve, reject, timer });
+            try {
+                this.deps.emit(live.viewer, { type: 'aios-request', sessionId: id, attachmentId: live.attachmentId, callId, expiresAt, name, args });
+            }
+            catch (err) {
+                clearTimeout(timer);
+                live.calls.delete(callId);
+                reject(err);
+            }
+        });
+    }
+}
+exports.DirectSessions = DirectSessions;

package/dist/direct/supervisor.d.ts

@@ -0,0 +1,9 @@
+import { fork } from 'node:child_process';
+export interface DirectService {
+    busy(): boolean;
+    quiesce(): Promise<boolean>;
+    release(): void;
+    stop(): Promise<void>;
+}
+/** The default branch creates no processes, timers, connections, folders or config. */
+export declare function startDirectService(env?: NodeJS.ProcessEnv, spawn?: typeof fork, report?: (message: string) => void): DirectService;

package/dist/direct/supervisor.js

@@ -0,0 +1,137 @@
+"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.startDirectService = startDirectService;
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const protocol_1 = require("./protocol");
+const node_crypto_1 = require("node:crypto");
+/** The default branch creates no processes, timers, connections, folders or config. */
+function startDirectService(env = process.env, spawn = node_child_process_1.fork, report = message => console.error(`[direct-sessions] ${message}`)) {
+    const off = { busy: () => false, quiesce: async () => true, release: () => { }, stop: async () => { } };
+    if (env.AINODE_DIRECT_SESSIONS !== '1')
+        return off;
+    try {
+        (0, protocol_1.relayUrl)(env.AINODE_DIRECT_RELAY_URL ?? '', '/node');
+        const roots = JSON.parse(env.AINODE_DIRECT_ROOTS ?? '[]');
+        if (!Array.isArray(roots) || !roots.length || roots.some(r => typeof r !== 'string' || !path.isAbsolute(r))) {
+            throw new Error('Configure AINODE_DIRECT_ROOTS as a JSON array of absolute project paths.');
+        }
+    }
+    catch (err) {
+        report(err.message);
+        return off;
+    }
+    let child;
+    try {
+        const options = {
+            env: { ...env }, stdio: ['ignore', 'ignore', 'ignore', 'ipc'], windowsHide: true,
+        };
+        child = spawn(path.join(__dirname, 'worker.js'), [], options);
+    }
+    catch {
+        report('Could not start the optional session service. Existing workloads remain available.');
+        return off;
+    }
+    let count = -1; // Treat startup as busy until the child confirms its state.
+    let exited = false;
+    let leases = 0;
+    let pending;
+    const startup = setTimeout(() => { if (count === -1) {
+        report('The optional session service did not start in time.');
+        child.kill();
+    } }, 15_000);
+    const clearPending = (ok) => { if (pending) {
+        clearTimeout(pending.timer);
+        pending.resolve(ok);
+        pending = undefined;
+    } };
+    child.on('message', (value) => {
+        if (value?.type === 'direct-count' && Number.isInteger(value.count) && value.count >= 0) {
+            count = value.count;
+            clearTimeout(startup);
+        }
+        if (value?.type === 'direct-quiesced' && pending?.id === value.id) {
+            if (value.count === 0)
+                leases++;
+            clearPending(value.count === 0);
+        }
+        if (value?.type === 'direct-error')
+            report('The optional session service could not start. Check its project roots and relay configuration.');
+    });
+    child.on('error', () => { exited = true; count = 0; clearTimeout(startup); clearPending(false); report('The optional session service failed.'); });
+    child.on('exit', () => { exited = true; count = 0; clearTimeout(startup); clearPending(false); });
+    return {
+        busy: () => !exited && count !== 0,
+        async quiesce() {
+            if (exited)
+                return true;
+            if (leases > 0) {
+                leases++;
+                return true;
+            }
+            if (count !== 0 || pending || !child.connected)
+                return false;
+            return new Promise(resolve => {
+                const id = (0, node_crypto_1.randomUUID)();
+                const timer = setTimeout(() => { clearPending(false); if (child.connected)
+                    child.send({ type: 'direct-accept' }, () => { }); }, 10_000);
+                pending = { id, resolve, timer };
+                child.send({ type: 'direct-quiesce', id }, err => { if (err)
+                    clearPending(false); });
+            });
+        },
+        release() {
+            if (leases > 0)
+                leases--;
+            if (!leases && child.connected)
+                child.send({ type: 'direct-accept' }, () => { });
+        },
+        async stop() {
+            clearTimeout(startup);
+            clearPending(false);
+            if (exited)
+                return;
+            await new Promise(resolve => {
+                const timer = setTimeout(() => { child.kill(); resolve(); }, 5000);
+                child.once('exit', () => { clearTimeout(timer); resolve(); });
+                if (child.connected)
+                    child.send({ type: 'direct-stop' }, () => { });
+                else
+                    child.kill();
+            });
+        },
+    };
+}

package/dist/direct/terminal.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/direct/terminal.js

@@ -0,0 +1,106 @@
+"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 });
+const pty = __importStar(require("node-pty"));
+const win_1 = require("../win");
+// A private per-terminal host. Its parent owns termination of the entire process
+// tree; no native CLI, prompt or approval protocol is interpreted here.
+let terminal;
+let paused = false, sending = 0, ending = false;
+function send(message, done) {
+    if (!process.connected || !process.send) {
+        done?.();
+        return;
+    }
+    process.send(message, () => done?.());
+}
+function end(exitCode) {
+    if (ending)
+        return;
+    ending = true;
+    send({ type: 'exit', exitCode }, () => process.exit(0));
+}
+function stopTree() {
+    if (ending)
+        return;
+    ending = true;
+    (0, win_1.killProcessTree)({ pid: process.pid, kill: signal => { process.kill(process.pid, signal); } });
+}
+// Keep the host alive through POSIX's polite phase so tree escalation can still
+// find descendants that ignore SIGINT. Windows uses taskkill /T /F directly.
+process.on('SIGINT', () => { });
+process.on('SIGTERM', stopTree);
+process.on('disconnect', stopTree);
+process.on('message', (message) => {
+    if (ending)
+        return;
+    try {
+        if (message?.type === 'start' && !terminal) {
+            terminal = pty.spawn(message.file, message.args, message.options);
+            terminal.onData(data => {
+                terminal.pause();
+                for (let i = 0; i < data.length; i += 16_384) {
+                    sending++;
+                    send({ type: 'data', data: data.slice(i, i + 16_384) }, () => {
+                        sending--;
+                        if (!sending && !paused && !ending)
+                            terminal?.resume();
+                    });
+                }
+            });
+            terminal.onExit(({ exitCode }) => end(exitCode));
+        }
+        if (message?.type === 'input' && typeof message.data === 'string')
+            terminal?.write(message.data);
+        if (message?.type === 'resize')
+            terminal?.resize(message.cols, message.rows);
+        if (message?.type === 'pause') {
+            paused = true;
+            terminal?.pause();
+        }
+        if (message?.type === 'resume') {
+            paused = false;
+            if (!sending)
+                terminal?.resume();
+        }
+    }
+    catch (error) {
+        if (!terminal) {
+            send({ type: 'data', data: `\r\nThe terminal could not start: ${error instanceof Error ? error.message : String(error)}\r\n` });
+            end(1);
+        }
+        // A resize/input racing an exited terminal must not crash a different session.
+    }
+});

package/dist/direct/worker.d.ts

@@ -0,0 +1 @@
+export declare function runDirectWorker(): () => void;