@myagentroam/agent 0.11.32 → 0.11.34

package/dist/network/http.js

@@ -0,0 +1,421 @@
+import { connect as connectTcp } from 'node:net';
+import { connect as connectTls } from 'node:tls';
+import { Client, Socks5ProxyAgent, buildConnector, fetch as undiciFetch } from 'undici';
+import { TransportFault } from './transport-error.js';
+const SOCKS5_HANDSHAKE_TIMEOUT_MS = 10_000;
+export async function fetchWithConnectionTimeout(url, attempt, signal, connectionTimeoutMs) {
+    if (signal.aborted)
+        throw signal.reason;
+    const controller = new AbortController();
+    const timeoutError = new TransportFault('connection-timeout', 'Connection timed out.');
+    let rejectInterruption = () => undefined;
+    const interruption = new Promise((_resolve, reject) => {
+        rejectInterruption = reject;
+    });
+    const abortFromCaller = () => {
+        const reason = signal.reason;
+        controller.abort(reason);
+        rejectInterruption(reason);
+    };
+    signal.addEventListener('abort', abortFromCaller, { once: true });
+    const timeout = setTimeout(() => {
+        controller.abort(timeoutError);
+        rejectInterruption(timeoutError);
+    }, Math.max(1, connectionTimeoutMs));
+    try {
+        return await Promise.race([fetchHttpAttempt(url, attempt, controller.signal), interruption]);
+    }
+    finally {
+        clearTimeout(timeout);
+        signal.removeEventListener('abort', abortFromCaller);
+    }
+}
+async function fetchHttpAttempt(url, attempt, signal) {
+    if (attempt.httpVersion === '1.1' && attempt.socks5Url === undefined)
+        return await fetch(url, { ...attempt.request, signal });
+    const dispatcher = attempt.socks5Url === undefined
+        ? http2Client(url)
+        : attempt.httpVersion === '2'
+            ? http2SocksClient(url, attempt.socks5Url)
+            : new Socks5ProxyAgent(attempt.socks5Url);
+    try {
+        const response = await undiciFetch(url, {
+            ...attempt.request,
+            signal,
+            dispatcher
+        });
+        return responseWithDispatcherLifecycle(response, dispatcher);
+    }
+    catch (error) {
+        await dispatcher.destroy(error instanceof Error ? error : null).catch(() => undefined);
+        if (hasErrorCode(error, 'MAR_AGENT_HTTP2_NEGOTIATION_FAILED'))
+            throw new TransportFault('http2-negotiation', 'HTTP/2 negotiation failed.', error);
+        throw error;
+    }
+}
+function http2Client(url) {
+    return new Client(new URL(url).origin, {
+        allowH2: true,
+        connect: strictHttp2Connector()
+    });
+}
+function http2SocksClient(url, socks5Url) {
+    return new Client(new URL(url).origin, {
+        allowH2: true,
+        connect: async (options, callback) => {
+            try {
+                const tlsSocket = await connectSocks5Target({
+                    socks5Url,
+                    targetHost: options.hostname,
+                    targetPort: Number(options.port || 443),
+                    tls: true,
+                    servername: options.servername || options.hostname,
+                    alpnProtocols: ['h2'],
+                    requiredAlpnProtocol: 'h2'
+                });
+                callback(null, tlsSocket);
+            }
+            catch (error) {
+                callback(asError(error), null);
+            }
+        }
+    });
+}
+export async function connectSocks5Target(input) {
+    if (input.signal?.aborted)
+        throw input.signal.reason;
+    const proxy = parseSocks5Proxy(input.socks5Url);
+    const targetHost = Buffer.from(input.targetHost, 'utf8');
+    if (targetHost.length === 0 ||
+        targetHost.length > 255 ||
+        !Number.isSafeInteger(input.targetPort) ||
+        input.targetPort < 1 ||
+        input.targetPort > 65_535)
+        throw invalidSocks5Proxy();
+    const socket = connectTcp({ host: proxy.hostname, port: proxy.port });
+    const timeoutError = Object.assign(new Error('SOCKS5 connection timed out.'), {
+        code: 'ETIMEDOUT'
+    });
+    const abort = () => socket.destroy(asError(input.signal?.reason));
+    const timeout = () => socket.destroy(timeoutError);
+    input.signal?.addEventListener('abort', abort, { once: true });
+    socket.setTimeout(SOCKS5_HANDSHAKE_TIMEOUT_MS);
+    socket.once('timeout', timeout);
+    try {
+        await waitForSocketConnect(socket);
+        const methods = proxy.username === undefined ? [0x00] : [0x00, 0x02];
+        await writeSocket(socket, Buffer.from([0x05, methods.length, ...methods]));
+        const greeting = await readSocketExactly(socket, 2);
+        if (greeting[0] !== 0x05 || greeting[1] === 0xff)
+            throw socks5ProtocolError('EACCES', 'SOCKS5 proxy rejected authentication methods.');
+        if (greeting[1] === 0x02) {
+            if (proxy.username === undefined || proxy.password === undefined)
+                throw socks5ProtocolError('EACCES', 'SOCKS5 proxy requires authentication.');
+            const username = Buffer.from(proxy.username, 'utf8');
+            const password = Buffer.from(proxy.password, 'utf8');
+            await writeSocket(socket, Buffer.concat([
+                Buffer.from([0x01, username.length]),
+                username,
+                Buffer.from([password.length]),
+                password
+            ]));
+            const authentication = await readSocketExactly(socket, 2);
+            if (authentication[0] !== 0x01 || authentication[1] !== 0x00)
+                throw socks5ProtocolError('EACCES', 'SOCKS5 proxy authentication failed.');
+        }
+        else if (greeting[1] !== 0x00)
+            throw socks5ProtocolError('EACCES', 'SOCKS5 proxy selected an unsupported method.');
+        const port = Buffer.allocUnsafe(2);
+        port.writeUInt16BE(input.targetPort);
+        await writeSocket(socket, Buffer.concat([Buffer.from([0x05, 0x01, 0x00, 0x03, targetHost.length]), targetHost, port]));
+        const reply = await readSocketExactly(socket, 4);
+        if (reply[0] !== 0x05 || reply[2] !== 0x00)
+            throw socks5ProtocolError('EPROTO', 'SOCKS5 proxy returned an invalid response.');
+        if (reply[1] !== 0x00)
+            throw socks5ReplyError(reply[1]);
+        await consumeSocks5BoundAddress(socket, reply[3]);
+        socket.setTimeout(0);
+        socket.off('timeout', timeout);
+        input.signal?.removeEventListener('abort', abort);
+        if (!input.tls)
+            return socket;
+        return await upgradeSocks5Tls(socket, input);
+    }
+    catch (error) {
+        socket.destroy();
+        throw error;
+    }
+    finally {
+        socket.off('timeout', timeout);
+        input.signal?.removeEventListener('abort', abort);
+    }
+}
+function parseSocks5Proxy(value) {
+    try {
+        const url = new URL(value);
+        const port = url.port === '' ? 1080 : Number(url.port);
+        if (url.protocol !== 'socks5:' ||
+            url.hostname.length === 0 ||
+            !Number.isSafeInteger(port) ||
+            port < 1 ||
+            port > 65_535 ||
+            (url.pathname !== '' && url.pathname !== '/') ||
+            url.search !== '' ||
+            url.hash !== '')
+            throw invalidSocks5Proxy();
+        const hasAuthentication = url.username !== '' || url.password !== '';
+        const username = hasAuthentication ? decodeURIComponent(url.username) : undefined;
+        const password = hasAuthentication ? decodeURIComponent(url.password) : undefined;
+        if ((hasAuthentication && username?.length === 0) ||
+            (username !== undefined && Buffer.byteLength(username) > 255) ||
+            (password !== undefined && Buffer.byteLength(password) > 255))
+            throw invalidSocks5Proxy();
+        return {
+            hostname: url.hostname,
+            port,
+            ...(username === undefined ? {} : { username, password: password ?? '' })
+        };
+    }
+    catch (cause) {
+        if (cause instanceof TransportFault)
+            throw cause;
+        throw invalidSocks5Proxy(cause);
+    }
+}
+async function waitForSocketConnect(socket) {
+    if (socket.readyState === 'open')
+        return;
+    await new Promise((resolve, reject) => {
+        const cleanup = () => {
+            socket.off('connect', connected);
+            socket.off('error', failed);
+            socket.off('close', closed);
+        };
+        const connected = () => {
+            cleanup();
+            resolve();
+        };
+        const failed = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const closed = () => {
+            cleanup();
+            reject(Object.assign(new Error('SOCKS5 proxy connection closed.'), { code: 'ECONNRESET' }));
+        };
+        socket.once('connect', connected);
+        socket.once('error', failed);
+        socket.once('close', closed);
+    });
+}
+async function writeSocket(socket, value) {
+    await new Promise((resolve, reject) => {
+        socket.write(value, (error) => (error ? reject(error) : resolve()));
+    });
+}
+async function readSocketExactly(socket, length) {
+    while (socket.readableLength < length) {
+        if (socket.readableEnded || socket.destroyed)
+            throw Object.assign(new Error('SOCKS5 proxy connection ended early.'), {
+                code: 'ECONNRESET'
+            });
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                socket.off('readable', readable);
+                socket.off('error', failed);
+                socket.off('end', ended);
+                socket.off('close', ended);
+            };
+            const readable = () => {
+                cleanup();
+                resolve();
+            };
+            const failed = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const ended = () => {
+                cleanup();
+                reject(Object.assign(new Error('SOCKS5 proxy connection ended early.'), {
+                    code: 'ECONNRESET'
+                }));
+            };
+            socket.once('readable', readable);
+            socket.once('error', failed);
+            socket.once('end', ended);
+            socket.once('close', ended);
+        });
+    }
+    const value = socket.read(length);
+    if (!Buffer.isBuffer(value) || value.length !== length)
+        throw socks5ProtocolError('EPROTO', 'SOCKS5 proxy returned an invalid response.');
+    return value;
+}
+async function consumeSocks5BoundAddress(socket, addressType) {
+    if (addressType === 0x01) {
+        await readSocketExactly(socket, 6);
+        return;
+    }
+    if (addressType === 0x04) {
+        await readSocketExactly(socket, 18);
+        return;
+    }
+    if (addressType === 0x03) {
+        const length = (await readSocketExactly(socket, 1))[0];
+        await readSocketExactly(socket, length + 2);
+        return;
+    }
+    throw socks5ProtocolError('EPROTO', 'SOCKS5 proxy returned an invalid address.');
+}
+async function upgradeSocks5Tls(socket, input) {
+    const tlsSocket = connectTls({
+        socket,
+        servername: input.servername ?? input.targetHost,
+        ...(input.alpnProtocols === undefined ? {} : { ALPNProtocols: [...input.alpnProtocols] })
+    });
+    const abort = () => tlsSocket.destroy(asError(input.signal?.reason));
+    const timeoutError = Object.assign(new Error('TLS connection timed out.'), {
+        code: 'ETIMEDOUT'
+    });
+    const timeout = () => tlsSocket.destroy(timeoutError);
+    input.signal?.addEventListener('abort', abort, { once: true });
+    tlsSocket.setTimeout(SOCKS5_HANDSHAKE_TIMEOUT_MS);
+    tlsSocket.once('timeout', timeout);
+    try {
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                tlsSocket.off('secureConnect', connected);
+                tlsSocket.off('error', failed);
+                tlsSocket.off('close', closed);
+            };
+            const connected = () => {
+                cleanup();
+                resolve();
+            };
+            const failed = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const closed = () => {
+                cleanup();
+                reject(Object.assign(new Error('TLS connection closed early.'), { code: 'ECONNRESET' }));
+            };
+            tlsSocket.once('secureConnect', connected);
+            tlsSocket.once('error', failed);
+            tlsSocket.once('close', closed);
+        });
+        tlsSocket.setTimeout(0);
+        tlsSocket.off('timeout', timeout);
+        if (input.requiredAlpnProtocol !== undefined &&
+            tlsSocket.alpnProtocol !== input.requiredAlpnProtocol)
+            throw http2NegotiationError();
+        return tlsSocket;
+    }
+    catch (error) {
+        tlsSocket.destroy();
+        throw error;
+    }
+    finally {
+        tlsSocket.off('timeout', timeout);
+        input.signal?.removeEventListener('abort', abort);
+    }
+}
+function socks5ReplyError(reply) {
+    const code = reply === 0x03
+        ? 'ENETUNREACH'
+        : reply === 0x04
+            ? 'EHOSTUNREACH'
+            : reply === 0x05
+                ? 'ECONNREFUSED'
+                : reply === 0x06
+                    ? 'ETIMEDOUT'
+                    : reply === 0x07
+                        ? 'EPROTONOSUPPORT'
+                        : reply === 0x08
+                            ? 'EAFNOSUPPORT'
+                            : 'EIO';
+    return socks5ProtocolError(code, 'SOCKS5 proxy could not connect to the endpoint.');
+}
+function socks5ProtocolError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+function invalidSocks5Proxy(cause) {
+    return new TransportFault('invalid-proxy', 'SOCKS5 proxy URL is invalid.', cause);
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error('Transport failed.', { cause: error });
+}
+function strictHttp2Connector() {
+    const connector = buildConnector({ allowH2: true });
+    return (options, callback) => connector(options, (error, socket) => {
+        if (error || socket === null) {
+            callback(error, socket);
+            return;
+        }
+        if (!('alpnProtocol' in socket) || socket.alpnProtocol !== 'h2') {
+            const negotiationError = http2NegotiationError();
+            socket.destroy(negotiationError);
+            callback(negotiationError, null);
+            return;
+        }
+        callback(null, socket);
+    });
+}
+function http2NegotiationError() {
+    return Object.assign(new Error('HTTP/2 ALPN negotiation failed.'), {
+        code: 'MAR_AGENT_HTTP2_NEGOTIATION_FAILED'
+    });
+}
+function responseWithDispatcherLifecycle(response, dispatcher) {
+    if (response.body === null) {
+        void dispatcher.close();
+        return response;
+    }
+    const reader = response.body.getReader();
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        await dispatcher.close().catch(() => undefined);
+    };
+    const body = new ReadableStream({
+        async pull(controller) {
+            try {
+                const result = await reader.read();
+                if (result.done) {
+                    controller.close();
+                    await close();
+                }
+                else
+                    controller.enqueue(result.value);
+            }
+            catch (error) {
+                controller.error(error);
+                await close();
+            }
+        },
+        async cancel(reason) {
+            await reader.cancel(reason).catch(() => undefined);
+            await close();
+        }
+    });
+    return new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+    });
+}
+export function isModelHttpAttempt(value) {
+    return 'request' in value && (value.httpVersion === '1.1' || value.httpVersion === '2');
+}
+export function hasErrorCode(error, code) {
+    let current = error;
+    for (let depth = 0; depth < 6 && current !== null && typeof current === 'object'; depth++) {
+        const value = current;
+        if (value.code === code)
+            return true;
+        current = value.cause;
+    }
+    return false;
+}

package/dist/network/product-user-agent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Product transport identity shared by model requests and CLI authentication. Credential headers may
+ * override this value per request.
+ */
+export declare function productUserAgent(): string;

package/dist/network/product-user-agent.js

@@ -0,0 +1,22 @@
+import { readFileSync } from 'node:fs';
+let cachedUserAgent;
+/**
+ * Product transport identity shared by model requests and CLI authentication. Credential headers may
+ * override this value per request.
+ */
+export function productUserAgent() {
+    cachedUserAgent ??= resolveProductUserAgent();
+    return cachedUserAgent;
+}
+function resolveProductUserAgent() {
+    try {
+        const raw = readFileSync(new URL('../../package.json', import.meta.url), 'utf8');
+        const version = JSON.parse(raw).version;
+        if (typeof version === 'string' && version.length > 0 && version.length <= 64)
+            return 'MyAgentRoam/' + version + ' (' + process.platform + '; ' + process.arch + ')';
+    }
+    catch {
+        // Fall through to the identity-preserving fallback below.
+    }
+    return 'MyAgentRoam/unknown (' + process.platform + '; ' + process.arch + ')';
+}

package/dist/network/transport-error.d.ts

@@ -0,0 +1,5 @@
+export declare class TransportFault extends Error {
+    readonly kind: 'connection-timeout' | 'http2-negotiation' | 'invalid-proxy';
+    constructor(kind: 'connection-timeout' | 'http2-negotiation' | 'invalid-proxy', message: string, cause?: unknown);
+}
+export declare function isRetryableTransportError(error: unknown): boolean;

package/dist/network/transport-error.js

@@ -0,0 +1,31 @@
+export class TransportFault extends Error {
+    kind;
+    constructor(kind, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.kind = kind;
+    }
+}
+const RETRYABLE_TRANSPORT_CODES = new Set([
+    'EAI_AGAIN',
+    'ENOTFOUND',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'EHOSTUNREACH',
+    'ENETDOWN',
+    'ENETUNREACH',
+    'EPIPE',
+    'ETIMEDOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_SOCKET'
+]);
+export function isRetryableTransportError(error) {
+    let current = error;
+    for (let depth = 0; depth < 4 && current !== null && typeof current === 'object'; depth++) {
+        const record = current;
+        if (typeof record.code === 'string' && RETRYABLE_TRANSPORT_CODES.has(record.code))
+            return true;
+        current = record.cause;
+    }
+    return false;
+}

package/dist/process/contracts.d.ts

@@ -0,0 +1,26 @@
+import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+export interface LocalProcessSpawnRequest {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd: string;
+    readonly shell?: boolean | string;
+    /** Shell startup for exec only; native processes and workers omit this field. */
+    readonly shellLogin?: boolean;
+    readonly environment: NodeJS.ProcessEnv;
+    /** Explicit per-start values take precedence over execution-bound Host environment. */
+    readonly environmentOverrides?: Readonly<Record<string, string | undefined>>;
+    readonly environmentKeys?: readonly string[];
+    /** Trusted, bounded read-only worker assets; never supplied by model tool input. */
+    readonly runtimeDirectories?: readonly string[];
+    readonly detached: boolean;
+    readonly owner?: {
+        readonly sessionId: string;
+        readonly executionId?: string;
+        readonly operationId?: string;
+        readonly ownerInstanceId?: string;
+    };
+    readonly signal?: AbortSignal;
+}
+export interface LocalProcessExecutor {
+    spawn(request: LocalProcessSpawnRequest): Promise<ChildProcessWithoutNullStreams>;
+}

package/dist/prompts/index.d.ts

@@ -0,0 +1,20 @@
+import type { ExecutionMode } from '../runtime/contracts.js';
+import { type PromptPart } from './prompt-sections.js';
+export declare const MAR_AGENT_PROMPT_VERSION = "1.67";
+interface SystemPromptInput {
+    mode: ExecutionMode;
+    platform: string;
+    architecture?: string;
+    shell?: {
+        readonly name: string;
+        readonly path: string;
+    };
+    guaranteedCommands?: Readonly<Record<string, string>>;
+    workspace: string;
+    tools: readonly string[];
+    directTools?: readonly string[];
+    extension?: string | undefined;
+}
+export declare function buildSystemPrompt(input: SystemPromptInput): string;
+export declare function buildSystemPromptSections(input: SystemPromptInput): readonly PromptPart[];
+export {};

package/dist/prompts/index.js

@@ -0,0 +1,49 @@
+import { renderPromptSections } from './prompt-sections.js';
+import { compactionPrompt } from './compact.js';
+import { environmentPrompt, identityPrompt, instructionPriorityPrompt, workspaceDisciplinePrompt } from './core.js';
+import { modePrompt } from './modes.js';
+import { outputStylePrompt } from './output.js';
+import { subagentPrompt } from './subagent.js';
+import { interactionPrompt, longRunningPrompt, safetyPrompt, toolUsagePrompt, workflowPrompt } from './workflow.js';
+export const MAR_AGENT_PROMPT_VERSION = '1.67';
+export function buildSystemPrompt(input) {
+    return renderPromptSections(buildSystemPromptSections(input));
+}
+export function buildSystemPromptSections(input) {
+    const toolNames = new Set(input.tools);
+    const hasLongRunningCapability = [
+        'exec',
+        'todo_read',
+        'todo_write',
+        'agent_start',
+        'agent_wait',
+        'agent_cancel'
+    ].some((name) => toolNames.has(name));
+    const values = [
+        ['identity', identityPrompt()],
+        ['instruction-priority', instructionPriorityPrompt],
+        ['workspace-discipline', workspaceDisciplinePrompt],
+        ['workflow', workflowPrompt],
+        ['interaction', interactionPrompt],
+        ['safety', safetyPrompt],
+        ['output-style', outputStylePrompt],
+        ['environment-rules', environmentPrompt(input)],
+        ['tools', input.tools.length > 0 ? toolUsagePrompt(input.tools, input.directTools) : ''],
+        ['long-running', hasLongRunningCapability ? longRunningPrompt(input.tools) : ''],
+        [
+            'mode',
+            modePrompt(input.mode, {
+                questionAvailable: toolNames.has('question')
+            })
+        ],
+        ['compaction', input.mode === 'compact' ? compactionPrompt() : ''],
+        ['subagent', toolNames.has('agent_start') ? subagentPrompt : ''],
+        [
+            'caller-instructions',
+            input.extension
+                ? `# Caller, project, and selected Skill instructions\n${input.extension}`
+                : ''
+        ]
+    ];
+    return Object.freeze(values.map(([id, text]) => Object.freeze({ id: `core:${id}`, text: text || null })));
+}

package/dist/prompts/prompt-sections.d.ts

@@ -0,0 +1,6 @@
+export interface PromptPart {
+    readonly id: string;
+    readonly text: string | null;
+    readonly scope?: 'shared' | 'session';
+}
+export declare function renderPromptSections(sections: readonly PromptPart[]): string;

package/dist/prompts/prompt-sections.js

@@ -0,0 +1,6 @@
+export function renderPromptSections(sections) {
+    return sections
+        .map((part) => part.text)
+        .filter(Boolean)
+        .join('\n\n');
+}