@myagentroam/node 0.1.3 → 0.1.6

package/dist/supervisor.d.ts

@@ -0,0 +1 @@
+export declare function superviseNode(configPath: string, bootstrapEntrypoint: string): Promise<void>;

package/dist/supervisor.js

@@ -0,0 +1,154 @@
+import { spawn } from 'node:child_process';
+import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { loadNodeConfig, nodeDatabasePath } from './config.js';
+import { nodeLog, platformCliInvocation } from './operational.js';
+import { nodeUpgradeRequestPath } from './service/node-upgrade-coordinator.js';
+const UPGRADE_EXIT_CODE = 75;
+const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
+export async function superviseNode(configPath, bootstrapEntrypoint) {
+    const config = await loadNodeConfig(configPath);
+    const dataDirectory = dirname(nodeDatabasePath(config, configPath));
+    const activePath = resolve(dataDirectory, 'node-active-entrypoint');
+    let entrypoint = await readActiveEntrypoint(activePath, bootstrapEntrypoint);
+    for (;;) {
+        const childResult = await runProcess(process.execPath, [entrypoint, 'run', '--config', configPath], true, { ...process.env, MAR_NODE_SUPERVISED: '1' });
+        if (childResult.signalled)
+            return;
+        const code = childResult.code;
+        if (code !== UPGRADE_EXIT_CODE) {
+            if (code === 0)
+                return;
+            nodeLog('node.supervisor.child-exited', { code });
+            await delay(1_000);
+            continue;
+        }
+        const requestPath = nodeUpgradeRequestPath(nodeDatabasePath(config, configPath));
+        let stopping = false;
+        try {
+            const request = JSON.parse(await readFile(requestPath, 'utf8'));
+            const targetVersion = request['targetVersion'];
+            if (request['schemaVersion'] !== 1 ||
+                typeof targetVersion !== 'string' ||
+                !STABLE_VERSION.test(targetVersion))
+                throw new Error('NODE_UPGRADE_REQUEST_INVALID');
+            const prefix = resolve(dataDirectory, 'node-versions', targetVersion);
+            await rm(prefix, { recursive: true, force: true });
+            await mkdir(prefix, { recursive: true, mode: 0o700 });
+            const registry = validatedRegistry(config.upgrade?.registryUrl);
+            const invocation = platformCliInvocation('npm', [
+                'install',
+                '--prefix',
+                prefix,
+                '--ignore-scripts',
+                '--no-audit',
+                '--no-fund',
+                ...(registry === undefined ? [] : ['--registry', registry]),
+                `@myagentroam/node@${targetVersion}`
+            ]);
+            const installResult = await runProcess(invocation.command, invocation.args, false);
+            if (installResult.signalled) {
+                stopping = true;
+                throw new Error('NODE_UPGRADE_INSTALL_INTERRUPTED');
+            }
+            if (installResult.code !== 0)
+                throw new Error('NODE_UPGRADE_INSTALL_FAILED');
+            const rebuild = platformCliInvocation('npm', [
+                'rebuild',
+                '--prefix',
+                prefix,
+                ...(registry === undefined ? [] : ['--registry', registry]),
+                'node-pty'
+            ]);
+            const rebuildResult = await runProcess(rebuild.command, rebuild.args, false);
+            if (rebuildResult.signalled) {
+                stopping = true;
+                throw new Error('NODE_UPGRADE_INSTALL_INTERRUPTED');
+            }
+            if (rebuildResult.code !== 0)
+                throw new Error('NODE_UPGRADE_NATIVE_REBUILD_FAILED');
+            const nextEntrypoint = resolve(prefix, 'node_modules', '@myagentroam', 'node', 'dist', 'main.js');
+            await access(nextEntrypoint);
+            await writeAtomic(activePath, `${nextEntrypoint}\n`);
+            await writeResult(dataDirectory, {
+                state: 'SUCCEEDED',
+                targetVersion,
+                updatedAt: Date.now()
+            });
+            await rm(requestPath, { force: true });
+            entrypoint = nextEntrypoint;
+        }
+        catch (error) {
+            await writeResult(dataDirectory, {
+                state: 'FAILED',
+                errorCode: error instanceof Error ? error.message : 'NODE_UPGRADE_INSTALL_FAILED',
+                updatedAt: Date.now()
+            });
+            await rm(requestPath, { force: true });
+        }
+        if (stopping)
+            return;
+    }
+}
+async function runProcess(command, args, inherit, env = process.env) {
+    return new Promise((resolveProcess) => {
+        const child = spawn(command, args, {
+            windowsHide: true,
+            stdio: inherit ? 'inherit' : 'ignore',
+            env
+        });
+        let settled = false;
+        let signalled = false;
+        const forward = (signal) => {
+            signalled = true;
+            child.kill(signal);
+        };
+        const onSigint = () => forward('SIGINT');
+        const onSigterm = () => forward('SIGTERM');
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            process.off('SIGINT', onSigint);
+            process.off('SIGTERM', onSigterm);
+            resolveProcess({ code, signalled });
+        };
+        process.once('SIGINT', onSigint);
+        process.once('SIGTERM', onSigterm);
+        child.once('error', () => finish(null));
+        child.once('close', finish);
+    });
+}
+async function readActiveEntrypoint(path, fallback) {
+    try {
+        const value = (await readFile(path, 'utf8')).trim();
+        await access(value);
+        return value;
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeResult(directory, result) {
+    await writeAtomic(resolve(directory, 'upgrade-result.json'), `${JSON.stringify(result)}\n`);
+}
+async function writeAtomic(path, contents) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, contents, { mode: 0o600 });
+    await rename(temporary, path);
+}
+function validatedRegistry(value) {
+    if (value === undefined)
+        return undefined;
+    const url = new URL(value);
+    if (url.protocol !== 'https:' &&
+        !(url.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(url.hostname)))
+        throw new Error('NODE_UPGRADE_REGISTRY_INVALID');
+    if (url.username !== '' || url.password !== '' || url.search !== '' || url.hash !== '')
+        throw new Error('NODE_UPGRADE_REGISTRY_INVALID');
+    return url.toString().replace(/\/$/u, '');
+}
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}

package/dist/terminal.d.ts

@@ -98,6 +98,7 @@ export declare class TerminalManager {
         readonly cwd?: unknown;
         /** Resolved by NodeConnector; never trusted from a browser directly. */
         readonly workspaceId?: string | null;
+        readonly environment?: Readonly<Record<string, string>>;
     }): TerminalSummary;
     list(): readonly TerminalSummary[];
     get(terminalId: string): TerminalSummary;

package/dist/terminal.js

@@ -93,7 +93,7 @@ export class TerminalManager {
             cols,
             rows,
             cwd: typeof input.cwd === 'string' ? input.cwd : this.cwd,
-            env: process.env
+            env: { ...process.env, ...input.environment }
         });
         const createdAt = this.now();
         const terminal = {
@@ -414,4 +414,3 @@ function splitFrameData(value) {
     }
     return chunks;
 }
-//# sourceMappingURL=terminal.js.map

package/dist/util/node-operation-parsers.d.ts

@@ -0,0 +1,92 @@
+import type { AgentRunStatus, NodeCapabilities, NodeEnvelope } from '@myagentroam/protocol';
+import type { NodeAgentRun, NodeConversationTurn, NodeMessageAttachmentInput } from '../database.js';
+import type { NativeTranscriptToolCall } from '../native-session-history.js';
+export type RunnerImageAttachment = NodeMessageAttachmentInput & {
+    readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+};
+export declare const DEFAULT_SESSION_PAGE_SIZE = 10;
+export declare const MAX_SESSION_PAGE_SIZE = 100;
+export declare function sessionPage<T extends {
+    readonly id: string;
+    readonly lastActivityAt: number;
+    readonly pinOrder?: number | null;
+    readonly externalDiscovered?: boolean;
+}>(sessions: readonly T[], input: Record<string, unknown>): {
+    readonly sessions: readonly T[];
+    readonly nextCursor: string | null;
+};
+export declare function parseSessionPageCursor(cursor: string): {
+    readonly id: string;
+    readonly lastActivityAt: number;
+    readonly pinOrder: number | null;
+    readonly externalDiscovered: boolean;
+} | undefined;
+export declare function createSessionPageCursor(session: {
+    readonly id: string;
+    readonly lastActivityAt: number;
+    readonly pinOrder?: number | null;
+    readonly externalDiscovered?: boolean;
+}): string;
+export declare function compareSessionPageEntries(left: {
+    readonly id: string;
+    readonly lastActivityAt: number;
+    readonly pinOrder?: number | null;
+    readonly externalDiscovered?: boolean;
+}, right: {
+    readonly id: string;
+    readonly lastActivityAt: number;
+    readonly pinOrder?: number | null;
+    readonly externalDiscovered?: boolean;
+}): number;
+export declare function compactRunnerText(value: string, limit: number): string;
+export declare function compactRunnerValue(value: unknown, limit: number): {
+    readonly text: string;
+    readonly truncated: boolean;
+};
+export declare function codexTimestamp(value: unknown): number | null;
+export declare function nativePageEnd(cursor: string | undefined, sessionId: string, fallback: number): number;
+export declare function extractClaudeText(message: Record<string, unknown>): string;
+export declare function extractClaudeThinkingSummaries(message: Record<string, unknown>): readonly string[];
+export declare function extractClaudeToolUses(message: Record<string, unknown>): readonly {
+    readonly id: string;
+    readonly name: string;
+    readonly input: unknown;
+    readonly command?: string;
+    readonly inputTruncated: boolean;
+}[];
+export declare function extractClaudeToolResults(message: Record<string, unknown>): readonly {
+    readonly toolUseId: string;
+    readonly output: string;
+    readonly failed: boolean;
+    readonly truncated: boolean;
+}[];
+export declare function claudeContentBlocks(message: Record<string, unknown>): readonly Record<string, unknown>[];
+export declare function isClaudeCommandTool(name: string): boolean;
+export declare function nativeClaudeCommand(entry: NativeTranscriptToolCall): string;
+export declare function boundedConversationItemId(prefix: string, value: string): string;
+export declare function validUserAuthorization(value: unknown, envelope: NodeEnvelope, operation: string, nodeId: string | undefined, now?: number): boolean;
+export declare function isTerminalRunStatus(status: AgentRunStatus): boolean;
+export declare function validSessionOption(value: unknown): boolean;
+export declare function validSessionEffort(value: unknown): boolean;
+export declare function validSessionTitle(value: unknown): boolean;
+export declare function sessionTitleFromFirstMessage(content: string): string;
+export declare function parseComposerAttachmentUpload(input: Record<string, unknown>): {
+    readonly id: string;
+    readonly name: string;
+    readonly mime: string;
+} | undefined;
+export declare function parseComposerAttachmentIds(value: unknown): readonly string[];
+export declare function validComposerAttachmentName(name: string): boolean;
+export declare function isUuid(value: string): boolean;
+export declare function parseMessageAttachments(value: unknown): readonly NodeMessageAttachmentInput[];
+export declare function parseRunnerImageAttachments(value: unknown): readonly RunnerImageAttachment[];
+export declare function isRunnerImageAttachment(attachment: NodeMessageAttachmentInput): attachment is RunnerImageAttachment;
+export declare function isImageAttachment(attachment: NodeMessageAttachmentInput): boolean;
+export declare function withNonImageAttachmentPrompt(input: string, paths: readonly string[]): string;
+export declare function isCanonicalBase64(value: string): boolean;
+export declare function validatedCapabilities(value: unknown): NodeCapabilities;
+export declare function nodeConnectEndpoint(serverUrl: string): string;
+export declare function nodeTerminalConnectEndpoint(serverUrl: string): string;
+export declare function isPlainRecord(value: unknown): value is Record<string, unknown>;
+export declare function isNodeAgentRun(value: unknown): value is NodeAgentRun;
+export declare function isNodeConversationTurn(value: unknown): value is NodeConversationTurn;

package/dist/util/node-operation-parsers.js

@@ -0,0 +1,382 @@
+import { nodeCapabilitiesSchema } from '@myagentroam/protocol';
+const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
+const USER_AUTHORIZATION_CLOCK_SKEW_MS = 5_000;
+const NON_IMAGE_ATTACHMENT_PROMPT_PREFIX = '\n\n本轮非图片附件已上传到工作区，请按需读取以下文件：\n';
+const COMPOSER_IMAGE_MIME_TYPES = new Set([
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp'
+]);
+export const DEFAULT_SESSION_PAGE_SIZE = 10;
+export const MAX_SESSION_PAGE_SIZE = 100;
+export function sessionPage(sessions, input) {
+    const limit = typeof input.limit === 'number' &&
+        Number.isInteger(input.limit) &&
+        input.limit >= 1 &&
+        input.limit <= MAX_SESSION_PAGE_SIZE
+        ? input.limit
+        : DEFAULT_SESSION_PAGE_SIZE;
+    const cursor = typeof input.cursor === 'string' ? input.cursor : undefined;
+    const ordered = [...sessions].sort(compareSessionPageEntries);
+    const cursorEntry = cursor === undefined ? undefined : parseSessionPageCursor(cursor);
+    const afterCursor = cursor === undefined
+        ? ordered
+        : cursorEntry === undefined
+            ? []
+            : ordered.filter((session) => compareSessionPageEntries(session, cursorEntry) > 0);
+    const pinned = ordered.filter((session) => session.pinOrder !== null && session.pinOrder !== undefined);
+    const pinnedIndexes = new Map(pinned.map((session, index) => [session.id, index]));
+    const page = afterCursor.slice(0, limit).map((session) => {
+        const pinIndex = pinnedIndexes.get(session.id);
+        if (pinIndex === undefined)
+            return session;
+        return {
+            ...session,
+            canMovePinUp: pinIndex > 0,
+            canMovePinDown: pinIndex < pinned.length - 1
+        };
+    });
+    const last = page.at(-1);
+    return {
+        sessions: page,
+        nextCursor: last !== undefined && afterCursor.length > page.length ? createSessionPageCursor(last) : null
+    };
+}
+export function parseSessionPageCursor(cursor) {
+    try {
+        const value = JSON.parse(decodeURIComponent(cursor));
+        if (!Array.isArray(value) || value.length !== 3)
+            return undefined;
+        const [pinOrder, lastActivityAt, id] = value;
+        if ((pinOrder !== null && (typeof pinOrder !== 'number' || !Number.isFinite(pinOrder))) ||
+            (lastActivityAt !== null &&
+                (typeof lastActivityAt !== 'number' || !Number.isFinite(lastActivityAt))) ||
+            typeof id !== 'string')
+            return undefined;
+        return {
+            id,
+            lastActivityAt: lastActivityAt ?? 0,
+            pinOrder,
+            externalDiscovered: lastActivityAt !== null
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createSessionPageCursor(session) {
+    return encodeURIComponent(JSON.stringify([
+        session.pinOrder ?? null,
+        session.externalDiscovered === false ? null : session.lastActivityAt,
+        session.id
+    ]));
+}
+export function compareSessionPageEntries(left, right) {
+    const leftPinned = left.pinOrder !== null && left.pinOrder !== undefined;
+    const rightPinned = right.pinOrder !== null && right.pinOrder !== undefined;
+    if (leftPinned !== rightPinned)
+        return leftPinned ? -1 : 1;
+    if (leftPinned && rightPinned)
+        return (left.pinOrder - right.pinOrder || left.id.localeCompare(right.id));
+    const leftFound = left.externalDiscovered !== false;
+    const rightFound = right.externalDiscovered !== false;
+    if (leftFound !== rightFound)
+        return leftFound ? -1 : 1;
+    return right.lastActivityAt - left.lastActivityAt || left.id.localeCompare(right.id, 'en');
+}
+export function compactRunnerText(value, limit) {
+    return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 1))}…`;
+}
+export function compactRunnerValue(value, limit) {
+    if (value === undefined || value === null)
+        return { text: '', truncated: false };
+    let text;
+    if (typeof value === 'string')
+        text = value;
+    else {
+        try {
+            text = JSON.stringify(value);
+        }
+        catch {
+            return { text: '（无法显示）', truncated: false };
+        }
+    }
+    return { text: compactRunnerText(text, limit), truncated: text.length > limit };
+}
+export function codexTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value < 10_000_000_000 ? value * 1_000 : value;
+    if (typeof value === 'string') {
+        const timestamp = Date.parse(value);
+        return Number.isNaN(timestamp) ? null : timestamp;
+    }
+    return null;
+}
+export function nativePageEnd(cursor, sessionId, fallback) {
+    if (cursor === undefined)
+        return fallback;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        return value.sessionId === sessionId &&
+            Number.isInteger(value.end) &&
+            value.end >= 0
+            ? Math.min(value.end, fallback)
+            : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export function extractClaudeText(message) {
+    return claudeContentBlocks(message)
+        .flatMap((block) => block.type === 'text' && typeof block.text === 'string' ? [block.text] : [])
+        .join('');
+}
+export function extractClaudeThinkingSummaries(message) {
+    return claudeContentBlocks(message).flatMap((block) => {
+        // `showThinkingSummaries` asks the SDK/API for exactly these public
+        // summaries. Partial raw thinking events are intentionally not read.
+        if (block.type !== 'thinking' || typeof block.thinking !== 'string')
+            return [];
+        const text = compactRunnerText(block.thinking.trim(), 10_000);
+        return text.length === 0 ? [] : [text];
+    });
+}
+export function extractClaudeToolUses(message) {
+    return claudeContentBlocks(message).flatMap((block) => {
+        if (block.type !== 'tool_use' || typeof block.id !== 'string' || typeof block.name !== 'string')
+            return [];
+        const input = block.input;
+        const command = isPlainRecord(input) && typeof input.command === 'string' ? input.command : undefined;
+        return [
+            {
+                id: block.id,
+                name: block.name,
+                input,
+                ...(command === undefined ? {} : { command }),
+                inputTruncated: compactRunnerValue(input, 10_000).truncated
+            }
+        ];
+    });
+}
+export function extractClaudeToolResults(message) {
+    const parentId = typeof message.parent_tool_use_id === 'string' ? message.parent_tool_use_id : null;
+    const direct = compactRunnerValue(message.tool_use_result, 10_000);
+    if (parentId !== null && direct.text.length > 0)
+        return [
+            { toolUseId: parentId, output: direct.text, failed: false, truncated: direct.truncated }
+        ];
+    return claudeContentBlocks(message).flatMap((block) => {
+        if (block.type !== 'tool_result' || typeof block.tool_use_id !== 'string')
+            return [];
+        const result = compactRunnerValue(block.content, 10_000);
+        return [
+            {
+                toolUseId: block.tool_use_id,
+                output: result.text,
+                failed: block.is_error === true,
+                truncated: result.truncated
+            }
+        ];
+    });
+}
+export function claudeContentBlocks(message) {
+    const content = message.message;
+    if (!isPlainRecord(content) || !Array.isArray(content.content))
+        return [];
+    return content.content.filter(isPlainRecord);
+}
+export function isClaudeCommandTool(name) {
+    return name === 'Bash' || name === 'bash' || name === 'Shell';
+}
+export function nativeClaudeCommand(entry) {
+    if (isPlainRecord(entry.input) && typeof entry.input.command === 'string')
+        return compactRunnerText(entry.input.command, 10_000);
+    return entry.inputSummary ?? entry.toolName;
+}
+export function boundedConversationItemId(prefix, value) {
+    const candidate = `${prefix}:${value}`;
+    if (candidate.length <= 88)
+        return candidate;
+    return `${prefix}:${Buffer.from(value)
+        .toString('base64url')
+        .slice(0, 88 - prefix.length - 1)}`;
+}
+export function validUserAuthorization(value, envelope, operation, nodeId, now = Date.now()) {
+    if (typeof value !== 'object' || value === null || nodeId === undefined)
+        return false;
+    const authorization = value;
+    return (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.issuedAt <= now + USER_AUTHORIZATION_CLOCK_SKEW_MS &&
+        authorization.expiresAt >= now - USER_AUTHORIZATION_CLOCK_SKEW_MS &&
+        authorization.expiresAt - authorization.issuedAt <= 15_000);
+}
+export function isTerminalRunStatus(status) {
+    return (status === 'SUCCEEDED' ||
+        status === 'FAILED' ||
+        status === 'CANCELLED' ||
+        status === 'INTERRUPTED');
+}
+export function validSessionOption(value) {
+    return (value === undefined ||
+        (typeof value === 'string' && value.trim().length > 0 && value.length <= 120));
+}
+export function validSessionEffort(value) {
+    return value === undefined || (typeof value === 'string' && value.length <= 120);
+}
+export function validSessionTitle(value) {
+    return (value === undefined ||
+        (typeof value === 'string' && value.trim().length > 0 && value.length <= 160));
+}
+export function sessionTitleFromFirstMessage(content) {
+    return content.trim().replace(/\s+/g, ' ').slice(0, 160);
+}
+export function parseComposerAttachmentUpload(input) {
+    if (input.composerAttachmentId === undefined && input.mime === undefined)
+        return undefined;
+    if (typeof input.composerAttachmentId !== 'string' ||
+        !isUuid(input.composerAttachmentId) ||
+        typeof input.name !== 'string' ||
+        !validComposerAttachmentName(input.name) ||
+        typeof input.mime !== 'string' ||
+        input.mime.length === 0 ||
+        input.mime.length > 120)
+        throw new Error('COMPOSER_ATTACHMENT_INVALID');
+    return { id: input.composerAttachmentId, name: input.name, mime: input.mime };
+}
+export function parseComposerAttachmentIds(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 5 || value.some((id) => typeof id !== 'string'))
+        throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+    const ids = value;
+    if (ids.some((id) => !isUuid(id)) || new Set(ids).size !== ids.length)
+        throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+    return ids;
+}
+export function validComposerAttachmentName(name) {
+    return (name.trim().length > 0 &&
+        name.length <= 255 &&
+        name !== '.' &&
+        name !== '..' &&
+        !name.includes('/') &&
+        !name.includes('\\') &&
+        !Array.from(name).some((character) => {
+            const code = character.charCodeAt(0);
+            return code <= 31 || code === 127 || '<>:"|?*'.includes(character);
+        }));
+}
+export function isUuid(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+export function parseMessageAttachments(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 5)
+        throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+    let totalBytes = 0;
+    return value.map((attachment) => {
+        if (!isPlainRecord(attachment))
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        if (typeof attachment.name !== 'string' ||
+            typeof attachment.mime !== 'string' ||
+            typeof attachment.dataBase64 !== 'string')
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        if (!validComposerAttachmentName(attachment.name) ||
+            attachment.mime.length === 0 ||
+            attachment.mime.length > 120 ||
+            !isCanonicalBase64(attachment.dataBase64))
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        const byteSize = Buffer.byteLength(attachment.dataBase64, 'base64');
+        if (byteSize === 0 || byteSize > MAX_COMPOSER_ATTACHMENT_BYTES)
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        totalBytes += byteSize;
+        if (totalBytes > MAX_COMPOSER_ATTACHMENTS_BYTES)
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        return { name: attachment.name, mime: attachment.mime, dataBase64: attachment.dataBase64 };
+    });
+}
+export function parseRunnerImageAttachments(value) {
+    return parseMessageAttachments(value).map((attachment) => {
+        if (!isRunnerImageAttachment(attachment))
+            throw new Error('MESSAGE_ATTACHMENT_UNSUPPORTED');
+        return attachment;
+    });
+}
+export function isRunnerImageAttachment(attachment) {
+    return COMPOSER_IMAGE_MIME_TYPES.has(attachment.mime);
+}
+export function isImageAttachment(attachment) {
+    return attachment.mime.startsWith('image/');
+}
+export function withNonImageAttachmentPrompt(input, paths) {
+    if (paths.length === 0)
+        return input;
+    return `${input}${NON_IMAGE_ATTACHMENT_PROMPT_PREFIX}${paths
+        .map((path) => `- ${path}`)
+        .join('\n')}`;
+}
+export function isCanonicalBase64(value) {
+    return (value.length > 0 &&
+        value.length % 4 === 0 &&
+        /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value));
+}
+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();
+}
+export function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function isNodeAgentRun(value) {
+    return (isPlainRecord(value) &&
+        typeof value.id === 'string' &&
+        typeof value.sessionId === 'string' &&
+        typeof value.status === 'string');
+}
+export function isNodeConversationTurn(value) {
+    return (isPlainRecord(value) &&
+        typeof value.id === 'string' &&
+        typeof value.sessionId === 'string' &&
+        Array.isArray(value.items));
+}