@myagentroam/node 0.11.36 → 0.11.37

package/dist/codex-app-server.js

@@ -1,471 +1 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from './operational.js';
-const REQUEST_TIMEOUT_MS = 15_000;
-/**
- * Maps the facts that the Node can establish to the unified session controls.
- * Native-session activation is validated atomically with the first message.
- */
-export function codexSessionControl(input) {
-    void [input.available, input.nativeThreadId, input.nativeControl];
-    if (input.activeTurn) {
-        return {
-            level: 'MANAGED',
-            capabilities: ['history.read', 'events.live', 'turn.steer', 'turn.interrupt']
-        };
-    }
-    return {
-        level: 'MANAGED',
-        capabilities: ['history.read', 'turn.start']
-    };
-}
-export class CodexAppServerRpcError extends Error {
-    code;
-    rpcMessage;
-    data;
-    constructor(payload) {
-        const rpcMessage = typeof payload.message === 'string' ? payload.message : 'Codex App Server request failed';
-        super(`CODEX_APP_SERVER_RPC_ERROR:${JSON.stringify(payload)}`);
-        this.name = 'CodexAppServerRpcError';
-        this.code = payload.code;
-        this.rpcMessage = rpcMessage;
-        this.data = payload.data;
-    }
-}
-export function isCodexRolloutMissingError(error) {
-    return (error instanceof CodexAppServerRpcError &&
-        error.code === -32600 &&
-        (/^no rollout found for thread id\b/i.test(error.rpcMessage) ||
-            /^thread not loaded:\s*/i.test(error.rpcMessage)));
-}
-/**
- * Local JSON-RPC client for a Node-supervised Codex App Server over stdio.
- * The transport is not exposed to MAR Server or the browser.
- */
-export class CodexAppServerClient {
-    options;
-    child;
-    transport;
-    nextId = 1;
-    pending = new Map();
-    pendingDrainWaiters = new Set();
-    notifications = new Set();
-    environment = {};
-    starting;
-    restarting;
-    lifecycleRevision = 0;
-    constructor(options = {}) {
-        this.options = options;
-    }
-    configureEnvironment(environment) {
-        if (this.child !== undefined)
-            throw new Error('CODEX_APP_SERVER_ALREADY_STARTED');
-        this.environment = { ...environment };
-    }
-    clearEnvironment() {
-        if (this.child !== undefined)
-            throw new Error('CODEX_APP_SERVER_ALREADY_STARTED');
-        this.environment = {};
-    }
-    start() {
-        if (this.restarting !== undefined)
-            return this.restarting;
-        if (this.starting !== undefined)
-            return this.starting;
-        if (this.child !== undefined)
-            return Promise.resolve();
-        const starting = this.startManaged();
-        this.starting = starting;
-        const clearStarting = () => {
-            if (this.starting === starting)
-                this.starting = undefined;
-        };
-        void starting.then(clearStarting, clearStarting);
-        return starting;
-    }
-    restart() {
-        if (this.restarting !== undefined)
-            return this.restarting;
-        const restarting = this.restartManaged(this.lifecycleRevision);
-        this.restarting = restarting;
-        const clearRestarting = () => {
-            if (this.restarting === restarting)
-                this.restarting = undefined;
-        };
-        void restarting.then(clearRestarting, clearRestarting);
-        return restarting;
-    }
-    async startManaged() {
-        const command = this.options.command ?? 'codex';
-        const args = this.options.args ?? ['app-server'];
-        const spawnProcess = this.options.spawnProcess ?? defaultSpawn;
-        const child = spawnProcess(command, args, {
-            ...(this.options.cwd === undefined ? {} : { cwd: this.options.cwd }),
-            env: { ...minimalRunnerEnvironment(), ...this.environment }
-        });
-        this.child = child;
-        this.transport = stdioTransport(child);
-        const lines = createInterface({ input: child.stdout });
-        lines.on('line', (line) => this.handleLine(line));
-        const managedChild = child;
-        child.once('error', (error) => {
-            if (this.child !== managedChild)
-                return;
-            this.failAll(new Error(`CODEX_APP_SERVER_START_FAILED:${error.message}`));
-        });
-        child.once('exit', () => {
-            if (this.child !== managedChild)
-                return;
-            this.child = undefined;
-            this.failAll(new Error('CODEX_APP_SERVER_EXITED'));
-        });
-        await this.requestDirect('initialize', {
-            clientInfo: { name: 'codex_vscode', title: 'MyAgentRoam', version: '0.1.4' },
-            capabilities: { experimentalApi: true }
-        });
-        this.notify('initialized', {});
-    }
-    async restartManaged(lifecycleRevision) {
-        await Promise.resolve();
-        if (this.starting !== undefined)
-            await this.starting;
-        await this.waitForPendingRequests();
-        if (this.lifecycleRevision !== lifecycleRevision)
-            throw new Error('CODEX_APP_SERVER_STOPPED');
-        this.stopManaged();
-        await this.startManaged();
-    }
-    stop() {
-        this.lifecycleRevision += 1;
-        this.stopManaged();
-    }
-    async stopAndWait() {
-        const child = this.child;
-        if (child === undefined) {
-            this.stop();
-            return;
-        }
-        const exited = new Promise((resolve, reject) => {
-            if (child.exitCode !== null || child.signalCode !== null)
-                resolve();
-            else {
-                let forcedTimeout;
-                const onExit = () => {
-                    clearTimeout(timeout);
-                    if (forcedTimeout !== undefined)
-                        clearTimeout(forcedTimeout);
-                    resolve();
-                };
-                const timeout = setTimeout(() => {
-                    child.kill('SIGKILL');
-                    forcedTimeout = setTimeout(() => {
-                        child.off('exit', onExit);
-                        reject(new Error('CODEX_APP_SERVER_STOP_TIMEOUT'));
-                    }, 2_000);
-                }, 2_000);
-                child.once('exit', onExit);
-            }
-        });
-        this.stop();
-        await exited;
-    }
-    stopManaged() {
-        this.transport?.destroy();
-        this.transport = undefined;
-        this.child?.kill();
-        this.child = undefined;
-        this.failAll(new Error('CODEX_APP_SERVER_STOPPED'));
-    }
-    onNotification(listener) {
-        this.notifications.add(listener);
-        return () => this.notifications.delete(listener);
-    }
-    async request(method, params) {
-        if (this.restarting !== undefined)
-            await this.restarting;
-        else if (this.starting !== undefined)
-            await this.starting;
-        return this.requestDirect(method, params);
-    }
-    requestDirect(method, params) {
-        const transport = this.transport;
-        if (transport === undefined || !transport.writable)
-            throw new Error('CODEX_APP_SERVER_UNAVAILABLE');
-        const id = this.nextId++;
-        const timeoutMs = this.options.timeoutMs ?? REQUEST_TIMEOUT_MS;
-        const result = new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                this.resolvePendingDrain();
-                reject(new Error('CODEX_APP_SERVER_TIMEOUT'));
-            }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
-        });
-        transport.write(`${JSON.stringify({ method, id, params })}\n`);
-        return result;
-    }
-    waitForPendingRequests() {
-        if (this.pending.size === 0)
-            return Promise.resolve();
-        return new Promise((resolve) => this.pendingDrainWaiters.add(resolve));
-    }
-    resolvePendingDrain() {
-        if (this.pending.size !== 0)
-            return;
-        for (const resolve of this.pendingDrainWaiters)
-            resolve();
-        this.pendingDrainWaiters.clear();
-    }
-    notify(method, params) {
-        const transport = this.transport;
-        if (transport === undefined || !transport.writable)
-            throw new Error('CODEX_APP_SERVER_UNAVAILABLE');
-        transport.write(`${JSON.stringify({ method, params })}\n`);
-    }
-    respond(requestId, result) {
-        const transport = this.transport;
-        if (transport === undefined || !transport.writable)
-            throw new Error('CODEX_APP_SERVER_UNAVAILABLE');
-        transport.write(`${JSON.stringify({ id: requestId, result })}\n`);
-    }
-    startThread(cwd, configuration = {}) {
-        return this.request('thread/start', {
-            cwd,
-            experimentalRawEvents: true,
-            ...codexThreadConfiguration(cwd, configuration)
-        });
-    }
-    listThreads(params = {}) {
-        return this.request('thread/list', params);
-    }
-    readThread(threadId) {
-        return this.request('thread/read', { threadId, includeTurns: false });
-    }
-    listCollaborationModes() {
-        return this.request('collaborationMode/list', {});
-    }
-    listModels(params) {
-        return this.request('model/list', params);
-    }
-    forkThread(threadId, cwd, lastTurnId, configuration = {}) {
-        return this.request('thread/fork', {
-            threadId,
-            lastTurnId,
-            cwd,
-            ...codexThreadConfiguration(cwd, configuration)
-        });
-    }
-    revertThread(threadId, beforeTurnId) {
-        return this.request('thread/revert', { threadId, beforeTurnId });
-    }
-    listThreadTurns(threadId, input) {
-        return this.request('thread/turns/list', {
-            threadId,
-            ...input,
-            itemsView: 'full',
-            sortDirection: 'desc'
-        });
-    }
-    setThreadName(threadId, name) {
-        return this.request('thread/name/set', { threadId, name });
-    }
-    resumeThread(threadId, cwd, configuration = {}) {
-        return this.request('thread/resume', {
-            threadId,
-            cwd,
-            ...codexThreadConfiguration(cwd, configuration)
-        });
-    }
-    startTurn(threadId, text, cwd, configuration = {}, attachments = []) {
-        return this.request('turn/start', {
-            threadId,
-            cwd,
-            input: [{ type: 'text', text }, ...attachments],
-            ...codexTurnConfiguration(cwd, configuration)
-        });
-    }
-    steerTurn(threadId, expectedTurnId, text) {
-        return this.request('turn/steer', {
-            threadId,
-            expectedTurnId,
-            input: [{ type: 'text', text }]
-        });
-    }
-    interruptTurn(threadId, turnId) {
-        return this.request('turn/interrupt', { threadId, turnId });
-    }
-    handleLine(line) {
-        let message;
-        try {
-            message = JSON.parse(line);
-        }
-        catch {
-            return;
-        }
-        if ((typeof message.id === 'number' || typeof message.id === 'string') &&
-            typeof message.method === 'string') {
-            for (const listener of this.notifications) {
-                listener({ method: message.method, params: message.params, requestId: message.id });
-            }
-            return;
-        }
-        if (typeof message.id === 'number') {
-            const pending = this.pending.get(message.id);
-            if (pending === undefined)
-                return;
-            clearTimeout(pending.timer);
-            this.pending.delete(message.id);
-            this.resolvePendingDrain();
-            if (message.error !== undefined) {
-                pending.reject(new CodexAppServerRpcError(isRecord(message.error) ? message.error : { message: String(message.error) }));
-            }
-            else {
-                pending.resolve(message.result);
-            }
-            return;
-        }
-        if (typeof message.method === 'string') {
-            for (const listener of this.notifications)
-                listener({ method: message.method, params: message.params });
-        }
-    }
-    failAll(error) {
-        for (const [id, pending] of this.pending) {
-            clearTimeout(pending.timer);
-            pending.reject(error);
-            this.pending.delete(id);
-        }
-        this.resolvePendingDrain();
-    }
-}
-function codexThreadConfiguration(cwd, configuration) {
-    return {
-        ...modelOption(configuration.model),
-        ...(configuration.developerInstructions === undefined
-            ? {}
-            : { developerInstructions: configuration.developerInstructions }),
-        ...(configuration.mcpServers === undefined
-            ? {}
-            : {
-                config: {
-                    mcp_servers: configuration.mcpServers
-                }
-            }),
-        ...codexPermissionConfiguration(cwd, configuration.access, 'thread')
-    };
-}
-function codexTurnConfiguration(cwd, configuration) {
-    const effort = typeof configuration.effort === 'string' && configuration.effort.trim().length > 0
-        ? configuration.effort
-        : null;
-    return {
-        ...modelOption(configuration.model),
-        ...(effort === null ? {} : { effort }),
-        ...(configuration.serviceTier === 'fast' ? { serviceTier: 'fast' } : {}),
-        ...(configuration.collaborationMode === undefined
-            ? {}
-            : {
-                collaborationMode: {
-                    mode: configuration.collaborationMode,
-                    settings: {
-                        model: configuration.model ?? 'gpt-5.6-sol',
-                        reasoningEffort: effort
-                    }
-                }
-            }),
-        ...codexPermissionConfiguration(cwd, configuration.access, 'turn')
-    };
-}
-function modelOption(model) {
-    return model === undefined || model === null ? {} : { model };
-}
-function codexPermissionConfiguration(cwd, access, phase) {
-    const sandbox = access === 'read-only'
-        ? 'read-only'
-        : access === 'workspace-write' || access === 'on-request'
-            ? 'workspace-write'
-            : access === 'full-access'
-                ? 'danger-full-access'
-                : undefined;
-    const approvalPolicy = access === 'workspace-write' || access === 'full-access' ? 'never' : 'on-request';
-    if (phase === 'thread')
-        return {
-            ...(sandbox === undefined ? {} : { sandbox }),
-            approvalPolicy
-        };
-    return {
-        ...(sandbox === undefined
-            ? {}
-            : {
-                sandboxPolicy: sandbox === 'read-only'
-                    ? { type: 'readOnly' }
-                    : sandbox === 'danger-full-access'
-                        ? { type: 'dangerFullAccess' }
-                        : { type: 'workspaceWrite', writableRoots: [cwd], networkAccess: true }
-            }),
-        approvalPolicy
-    };
-}
-export function probeCodex(command = 'codex') {
-    const invocation = platformCliInvocation(command, ['--version']);
-    const result = spawnSync(invocation.command, invocation.args, {
-        windowsHide: true,
-        env: minimalRunnerEnvironment(),
-        timeout: 3_000,
-        encoding: 'utf8'
-    });
-    if (result.status !== 0 || result.error !== undefined)
-        return { available: false, compatible: false };
-    const version = `${result.stdout}${result.stderr}`.trim().slice(0, 128);
-    return {
-        available: true,
-        ...(version.length === 0 ? {} : { version }),
-        // The CLI version is metadata only. Actual compatibility is established
-        // by the App Server initialize handshake when the client starts.
-        compatible: true
-    };
-}
-export async function probeCodexAsync(command = 'codex') {
-    const invocation = platformCliInvocation(command, ['--version']);
-    const result = await runRunnerProbe(invocation.command, invocation.args, {
-        env: minimalRunnerEnvironment(),
-        timeoutMs: 3_000
-    });
-    if (result.status !== 0)
-        return { available: false, compatible: false };
-    const version = `${result.stdout}${result.stderr}`.trim().slice(0, 128);
-    return {
-        available: true,
-        ...(version.length === 0 ? {} : { version }),
-        // Do not reject a newer CLI before its App Server has had a chance to
-        // negotiate the protocol it actually supports.
-        compatible: true
-    };
-}
-export function isSupportedCodexVersion(version) {
-    return version.trim().length > 0;
-}
-function defaultSpawn(command, args, options) {
-    const invocation = platformCliInvocation(command, args);
-    return spawn(invocation.command, invocation.args, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        shell: false,
-        windowsHide: true,
-        ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
-        ...(options.env === undefined ? {} : { env: options.env })
-    });
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function stdioTransport(child) {
-    return {
-        get writable() {
-            return child.stdin.writable;
-        },
-        write: (data) => child.stdin.write(data),
-        on: (event, listener) => child.stdout.on(event, listener),
-        once: (event, listener) => child.stdout.once(event, listener),
-        destroy: () => child.stdout.destroy()
-    };
-}
+export {};

package/dist/connection/authorization.js

@@ -0,0 +1,26 @@
+const USER_AUTHORIZATION_CLOCK_SKEW_MS = 60 * 60 * 1_000;
+export function validUserAuthorization(value, envelope, operation, nodeId, now = Date.now()) {
+    if (typeof value !== 'object' || value === null || nodeId === undefined)
+        return false;
+    const authorization = value;
+    const modelResourceCapability = operation === 'model.resource.read' &&
+        authorization.userId === 0 &&
+        authorization.sessionHash === 'model-resource';
+    return ((modelResourceCapability ||
+        (typeof authorization.userId === 'number' &&
+            Number.isSafeInteger(authorization.userId) &&
+            authorization.userId > 0 &&
+            typeof authorization.sessionHash === 'string' &&
+            /^[A-Za-z0-9_-]{43}$/.test(authorization.sessionHash))) &&
+        authorization.nodeId === nodeId &&
+        authorization.operation === operation &&
+        authorization.requestId === envelope.id &&
+        typeof authorization.issuedAt === 'number' &&
+        typeof authorization.expiresAt === 'number' &&
+        Number.isSafeInteger(authorization.issuedAt) &&
+        Number.isSafeInteger(authorization.expiresAt) &&
+        authorization.expiresAt >= authorization.issuedAt &&
+        authorization.issuedAt <= now + USER_AUTHORIZATION_CLOCK_SKEW_MS &&
+        authorization.expiresAt >= now - USER_AUTHORIZATION_CLOCK_SKEW_MS &&
+        authorization.expiresAt - authorization.issuedAt <= 15_000);
+}

package/dist/{service → connection}/direct-transfer-service.js

@@ -1,7 +1,7 @@
 import { createSocket } from 'node:dgram';
 import { isIP } from 'node:net';
 import { directDataControlFrameSchema, directNodeCommandSchema } from '@myagentroam/protocol';
-import { TerminalDirectService } from './terminal-direct-service.js';
+import { TerminalDirectService } from '../service/terminal-direct-service.js';
 import { IceUdpMuxListener as NativeIceUdpMuxListener } from 'node-datachannel';
 import { RTCPeerConnection } from 'node-datachannel/polyfill';
 const MAX_HOST_CANDIDATES = 32;

package/dist/connection/endpoints.js

@@ -0,0 +1,32 @@
+import { nodeCapabilitiesSchema } from '@myagentroam/protocol';
+export function validatedCapabilities(value) {
+    return nodeCapabilitiesSchema.parse(value);
+}
+export function nodeConnectEndpoint(serverUrl) {
+    const endpoint = new URL(serverUrl);
+    if (endpoint.protocol === 'http:')
+        endpoint.protocol = 'ws:';
+    if (endpoint.protocol === 'https:')
+        endpoint.protocol = 'wss:';
+    if (endpoint.protocol !== 'ws:' && endpoint.protocol !== 'wss:') {
+        throw new Error('SERVER_URL_INVALID');
+    }
+    endpoint.pathname = `${endpoint.pathname.replace(/\/$/, '')}/api/node/connect`;
+    endpoint.search = '';
+    endpoint.hash = '';
+    return endpoint.toString();
+}
+export function nodeTerminalConnectEndpoint(serverUrl) {
+    const endpoint = new URL(serverUrl);
+    if (endpoint.protocol === 'http:')
+        endpoint.protocol = 'ws:';
+    if (endpoint.protocol === 'https:')
+        endpoint.protocol = 'wss:';
+    if (endpoint.protocol !== 'ws:' && endpoint.protocol !== 'wss:') {
+        throw new Error('SERVER_URL_INVALID');
+    }
+    endpoint.pathname = `${endpoint.pathname.replace(/\/$/, '')}/api/node/terminal-connect`;
+    endpoint.search = '';
+    endpoint.hash = '';
+    return endpoint.toString();
+}