@myagentroam/node 0.9.67 → 0.9.69

package/dist/capabilities.js

@@ -10,6 +10,14 @@ const runtimeCredentialCapability = () => ({
     websocket: true,
     httpVersions: ['1.1', '2']
 });
+const workspaceDirectTransferCapability = () => ({
+    apiVersion: 1,
+    probe: true,
+    upload: true,
+    download: true,
+    gitCommitBlob: true,
+    maxChunkBytes: 256 * 1024
+});
 export function reportedPlatform(platform = process.platform) {
     if (platform === 'win32')
         return 'windows';
@@ -37,7 +45,8 @@ export function unavailableCapabilities() {
         claudeCode: { available: false },
         openCode: { available: false },
         marAgent: { available: true, version: nodeAppVersion },
-        marAgentRuntimeCredentials: runtimeCredentialCapability()
+        marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        workspaceDirectTransfer: workspaceDirectTransferCapability()
     };
 }
 export function detectCapabilities(commands = {}) {
@@ -69,7 +78,8 @@ export function detectCapabilities(commands = {}) {
             ...(openCode.version === undefined ? {} : { version: openCode.version })
         },
         marAgent: { available: true, version: nodeAppVersion },
-        marAgentRuntimeCredentials: runtimeCredentialCapability()
+        marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        workspaceDirectTransfer: workspaceDirectTransferCapability()
     };
 }
 export async function detectCapabilitiesAsync(commands = {}) {
@@ -105,6 +115,7 @@ export async function detectCapabilitiesAsync(commands = {}) {
             ...(openCode.version === undefined ? {} : { version: openCode.version })
         },
         marAgent: { available: true, version: nodeAppVersion },
-        marAgentRuntimeCredentials: runtimeCredentialCapability()
+        marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        workspaceDirectTransfer: workspaceDirectTransferCapability()
     };
 }

package/dist/config.js

@@ -26,6 +26,7 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         ? input['allowedRoots']
         : defaultAllowedRoots();
     const conversationHosting = parseConversationHosting(input['conversationHosting']);
+    const directTransfer = parseDirectTransfer(input['directTransfer']);
     return {
         serverUrl: parsed.serverUrl,
         allowedRoots,
@@ -33,7 +34,15 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         ...(credential === undefined ? {} : { credential }),
         ...(registrationToken === undefined ? {} : { registrationToken }),
         ...(dataDirectory === undefined ? {} : { dataDirectory }),
-        ...(conversationHosting === undefined ? {} : { conversationHosting })
+        ...(conversationHosting === undefined ? {} : { conversationHosting }),
+        ...(directTransfer === undefined ? {} : { directTransfer })
+    };
+}
+export function directTransferUdpPortRange(config) {
+    const directTransfer = config?.directTransfer;
+    return {
+        begin: directTransfer?.udpPortRangeBegin ?? 49_152,
+        end: directTransfer?.udpPortRangeEnd ?? 49_215
     };
 }
 /** Uses the Node service account's scope when no Workspace roots are configured. */
@@ -97,6 +106,29 @@ function parseConversationHosting(value) {
         inactiveRetentionDays: inactiveRetentionDays
     };
 }
+function parseDirectTransfer(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'object' ||
+        value === null ||
+        Array.isArray(value) ||
+        Object.keys(value).some((key) => key !== 'udpPortRangeBegin' && key !== 'udpPortRangeEnd'))
+        throw new Error('NODE_CONFIG_INVALID');
+    const input = value;
+    const begin = input['udpPortRangeBegin'];
+    const end = input['udpPortRangeEnd'];
+    if (!Number.isInteger(begin) ||
+        !Number.isInteger(end) ||
+        begin < 1_024 ||
+        end > 65_535 ||
+        begin > end ||
+        end - begin + 1 > 256)
+        throw new Error('NODE_CONFIG_INVALID');
+    return {
+        udpPortRangeBegin: begin,
+        udpPortRangeEnd: end
+    };
+}
 function validStoreDirectory(value) {
     if (typeof value !== 'string' || value.trim() !== value || value.length === 0)
         return false;

package/dist/connector.js

@@ -1,6 +1,6 @@
 import { dirname, resolve } from 'node:path';
-import { createEnvelope } from '@myagentroam/protocol';
-import { hostedConversationStorePath, loadNodeConfig, nodeDataDirectory, nodeDatabasePath } from './config.js';
+import { createEnvelope, directNodeCommandSchema } from '@myagentroam/protocol';
+import { hostedConversationStorePath, loadNodeConfig, directTransferUdpPortRange, nodeDataDirectory, nodeDatabasePath } from './config.js';
 import { NodeMetrics, nodeLog } from './operational.js';
 import { assertLocalSqlitePath } from './storage.js';
 import { detectCapabilitiesAsync, unavailableCapabilities } from './capabilities.js';
@@ -32,6 +32,7 @@ import { WorkspaceService } from './service/workspace-service.js';
 import { WorkspaceWatchService } from './service/workspace-watch-service.js';
 import { WorkspaceFileService } from './service/workspace-file-service.js';
 import { WorkspaceUploadService } from './service/workspace-upload-service.js';
+import { DirectTransferService } from './service/direct-transfer-service.js';
 import { WorkspaceChangeService } from './service/workspace-change-service.js';
 import { WorkspaceSessionService } from './service/workspace-session-service.js';
 import { WorkbenchEventService } from './service/workbench-event-service.js';
@@ -271,6 +272,7 @@ export class NodeConnector {
         this.workspaceFileService.dispose(workspaceId);
         this.workspaceCoordinator.invalidate(workspaceId);
     });
+    directTransferService;
     workspaceChangeService = new WorkspaceChangeService(this.workspaceState);
     workspaceWorkbenchService;
     database;
@@ -668,11 +670,13 @@ export class NodeConnector {
                     return;
                 const updated = this.missionRuntime.recordTurn(input.sessionId);
                 const session = this.runtime.getAgentSession(input.sessionId);
-                if (updated !== undefined && session !== undefined)
-                    this.publishMissionState(session, updated);
+                const run = this.runtime.getRun(input.runId);
                 await this.enqueueMissionContinuation({
                     sessionId: input.sessionId,
                     mission: { id: mission.id, revision: mission.revision },
+                    ...(run?.initiatedByUserId === undefined
+                        ? {}
+                        : { initiatedByUserId: run.initiatedByUserId }),
                     secretEnvironment: input.secretEnvironment,
                     ...(input.personalInstructions === undefined
                         ? {}
@@ -683,6 +687,17 @@ export class NodeConnector {
                         ? {}
                         : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
                 });
+                if (updated !== undefined && session !== undefined)
+                    this.publishMissionState(session, updated);
+            },
+            afterExecutionStartFailed: (input, error) => {
+                nodeLog('mission.execution-start.failed', {
+                    sessionId: input.sessionId,
+                    runId: input.runId,
+                    missionId: input.mission?.id,
+                    revision: input.mission?.revision,
+                    code: safeErrorCode(error, 'MISSION_EXECUTION_START_FAILED')
+                });
             },
             missionMcp: async (input) => {
                 if (input.mission === undefined)
@@ -1049,6 +1064,7 @@ export class NodeConnector {
             onReconnectScheduled: () => this.metrics.reconnectScheduled(),
             onMessage: (raw) => this.handleMessage(raw),
             onClose: (code, reason) => {
+                this.directTransferService?.close();
                 this.runtimeCredentials.disconnected();
                 this.terminalChannel.disconnect();
                 if (code === 4000 && reason === 'NODE_CONNECTION_REPLACED')
@@ -1067,6 +1083,7 @@ export class NodeConnector {
             inspectWorkspace: (envelope) => this.workspaceCoordinator.inspect(envelope),
             handleNodeRequest: (envelope) => this.nodeRequests.handle(envelope),
             handleRuntimeCredentialResponse: (envelope) => this.runtimeCredentials.handle(envelope),
+            handleDirectTransfer: (envelope) => this.handleDirectTransfer(envelope),
             reconcileRuns: (envelope) => this.runEventBridge.reconcile(envelope),
             runners: this.runners,
             deliverSessionChannelMessage: (envelope) => this.runnerChannelMessages.handle(envelope),
@@ -1134,6 +1151,7 @@ export class NodeConnector {
         this.runnerService = new RunnerService(requireDatabase, () => this.capabilities, this.runners, this.runnerUsageReader);
         this.workbenchManifestService = new WorkbenchManifestService({
             capabilities: () => this.capabilities,
+            nodeGeneration: () => this.nodeGeneration,
             runners: this.runnerService,
             terminals: this.terminalManager
         });
@@ -1366,9 +1384,72 @@ export class NodeConnector {
         this.database ??= new NodeDatabase(nodeDatabasePath(this.config, this.configPath), () => this.config?.nodeId ?? 'unregistered');
         this.database.closeRunningTerminalSessions();
         await this.initializeConversationHosting();
+        this.directTransferService ??= this.createDirectTransferService();
         this.connectionLifecycle.start();
         this.controlChannel.connect();
     }
+    createDirectTransferService() {
+        try {
+            return new DirectTransferService({
+                nodeGeneration: () => this.nodeGeneration,
+                send: (type, payload) => this.send(type, payload),
+                udpPortRange: () => directTransferUdpPortRange(this.config),
+                openUpload: async (descriptor) => {
+                    if (descriptor.resource.kind !== 'WORKSPACE_FILE')
+                        throw new Error('DIRECT_RESOURCE_UNSUPPORTED');
+                    const workspace = this.workspaceCoordinator.require(descriptor.resource.workspaceId);
+                    const upload = await this.workspaceUploadService.createDirect(workspace, {
+                        path: descriptor.resource.path,
+                        size: descriptor.size,
+                        sha256: descriptor.sha256,
+                        overwrite: descriptor.overwrite === true,
+                        ...(descriptor.composerAttachment === undefined
+                            ? {}
+                            : { composerAttachment: descriptor.composerAttachment })
+                    });
+                    return {
+                        offset: upload.receivedBytes,
+                        write: (bytes) => this.workspaceUploadService.writeDirect(upload.uploadId, bytes),
+                        complete: (size, sha256) => this.workspaceUploadService.completeDirect(upload.uploadId, size, sha256),
+                        cancel: () => this.workspaceUploadService.cancel(upload.uploadId)
+                    };
+                },
+                openDownload: async (descriptor) => {
+                    if (this.workspaceWorkbenchService === undefined)
+                        throw new Error('DIRECT_RESOURCE_UNAVAILABLE');
+                    return this.workspaceWorkbenchService.directDownload(descriptor);
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error) || error.message !== 'DIRECT_UDP_PORT_UNAVAILABLE')
+                throw error;
+            const range = directTransferUdpPortRange(this.config);
+            nodeLog('direct-transfer.udp-unavailable', {
+                portRangeBegin: range.begin,
+                portRangeEnd: range.end
+            });
+            return undefined;
+        }
+    }
+    handleDirectTransfer(envelope) {
+        const command = {
+            type: envelope.type,
+            ...(typeof envelope.payload === 'object' && envelope.payload !== null ? envelope.payload : {})
+        };
+        if (this.directTransferService !== undefined)
+            return this.directTransferService.handle(command);
+        const parsed = directNodeCommandSchema.safeParse(command);
+        if (!parsed.success)
+            return false;
+        this.send('direct.error', {
+            type: 'direct.error',
+            directSessionId: parsed.data.directSessionId,
+            code: 'DIRECT_UDP_PORT_UNAVAILABLE',
+            message: 'The configured direct-transfer UDP port range is unavailable.'
+        });
+        return true;
+    }
     clearMissionRetry(sessionId) {
         const retry = this.missionRetryTimers.get(sessionId);
         if (retry !== undefined)
@@ -1386,6 +1467,9 @@ export class NodeConnector {
                 content: this.missionRuntime.prompt(input.sessionId, 'continue'),
                 deliveryIntent: 'QUEUE',
                 mission: input.mission,
+                ...(input.initiatedByUserId === undefined
+                    ? {}
+                    : { initiatedByUserId: input.initiatedByUserId }),
                 secretEnvironment: input.secretEnvironment,
                 ...(input.personalInstructions === undefined
                     ? {}
@@ -1407,8 +1491,16 @@ export class NodeConnector {
             }
             this.clearMissionRetry(input.sessionId);
         }
-        catch {
+        catch (error) {
             const current = this.missionRuntime.get(input.sessionId);
+            const failedAttempts = (input.failedAttempts ?? 0) + 1;
+            nodeLog('mission.continuation.enqueue.failed', {
+                sessionId: input.sessionId,
+                missionId: input.mission.id,
+                revision: input.mission.revision,
+                attempt: failedAttempts,
+                code: safeErrorCode(error, 'MISSION_CONTINUATION_ENQUEUE_FAILED')
+            });
             if (current?.status !== 'active' ||
                 current.id !== input.mission.id ||
                 current.revision !== input.mission.revision) {
@@ -1416,7 +1508,6 @@ export class NodeConnector {
                     this.missionContinuationPending.delete(input.sessionId);
                 return;
             }
-            const failedAttempts = (input.failedAttempts ?? 0) + 1;
             const session = this.runtime.getAgentSession(input.sessionId);
             if (failedAttempts > 3 || session === undefined) {
                 this.clearMissionRetry(input.sessionId);
@@ -1537,6 +1628,8 @@ export class NodeConnector {
         const terminalDrain = this.terminalManager.shutdown();
         this.terminalChannel.stop();
         this.runtimeCredentials.close();
+        this.directTransferService?.dispose();
+        this.directTransferService = undefined;
         this.controlChannel.stop();
         const database = this.database;
         this.database = undefined;

package/dist/runner/mar-agent/history-projection.js

@@ -1,4 +1,5 @@
 import { MarAgentConversationNormalizer } from './conversation-normalizer.js';
+import { publicMissionHistoryText } from '../../service/mission-runtime.js';
 export function projectMarAgentHistory(session, entries, options = {}) {
     const turns = new Map();
     const normalizer = new MarAgentConversationNormalizer();
@@ -42,7 +43,7 @@ export function projectMarAgentHistory(session, entries, options = {}) {
             const registeredImages = images === undefined ? [] : (options.registerInputImages?.(entry) ?? []);
             replace(turn, historyItem(session, turn, id, 'user_message', 'COMPLETED', {
                 clientMessageId: entry.clientMessageId ?? null,
-                text: entry.text,
+                text: publicMissionHistoryText(entry.text),
                 contexts: [],
                 delivery: 'ACCEPTED',
                 ...(images?.length

package/dist/service/continuous-run-coordinator.js

@@ -321,7 +321,7 @@ export class ContinuousRunCoordinator {
         this.startedExecutions.add(executionId);
         void this.options
             .afterExecutionStarted?.(pending)
-            .catch(() => undefined);
+            .catch((error) => this.options.afterExecutionStartFailed?.(pending, error));
     }
     hasExecutionStarted(executionId) {
         return this.startedExecutions.has(executionId);

package/dist/service/direct-transfer-service.js

@@ -0,0 +1,479 @@
+import { directDataControlFrameSchema, directNodeCommandSchema } from '@myagentroam/protocol';
+import { IceUdpMuxListener as NativeIceUdpMuxListener } from 'node-datachannel';
+import { RTCPeerConnection } from 'node-datachannel/polyfill';
+const MAX_HOST_CANDIDATES = 32;
+const MAX_ACTIVE_SESSIONS = 32;
+const DATA_CHANNEL_HIGH_WATER_BYTES = 4 * 1024 * 1024;
+const DATA_CHANNEL_LOW_WATER_BYTES = 1024 * 1024;
+const LEASE_GRACE_MS = 30_000;
+const LEASE_CHECK_MS = 5_000;
+export class DirectTransferService {
+    options;
+    sessions = new Map();
+    now;
+    createPeerConnection;
+    iceUdpMuxListener;
+    peerConfiguration;
+    leaseGraceMs;
+    leaseCheckMs;
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        const range = options.udpPortRange?.() ?? { begin: 49_152, end: 49_215 };
+        const createIceUdpMuxListener = options.createIceUdpMuxListener ?? ((port) => new NativeIceUdpMuxListener(port));
+        this.iceUdpMuxListener = bindIceUdpMuxListener(range, createIceUdpMuxListener);
+        const udpPort = this.iceUdpMuxListener.port();
+        this.peerConfiguration = {
+            iceServers: [],
+            enableIceUdpMux: true,
+            portRangeBegin: udpPort,
+            portRangeEnd: udpPort
+        };
+        this.createPeerConnection =
+            options.createPeerConnection ??
+                ((configuration) => new RTCPeerConnection(configuration));
+        this.leaseGraceMs = options.leaseGraceMs ?? LEASE_GRACE_MS;
+        this.leaseCheckMs = options.leaseCheckMs ?? LEASE_CHECK_MS;
+    }
+    handle(value) {
+        const parsed = directNodeCommandSchema.safeParse(value);
+        if (!parsed.success)
+            return false;
+        void this.dispatch(parsed.data).catch((error) => {
+            const directSessionId = typeof value === 'object' &&
+                value !== null &&
+                'directSessionId' in value &&
+                typeof value.directSessionId === 'string'
+                ? value.directSessionId
+                : undefined;
+            if (directSessionId !== undefined)
+                this.fail(directSessionId, errorCode(error), errorMessage(error));
+        });
+        return true;
+    }
+    close() {
+        for (const session of [...this.sessions.values()])
+            void this.remove(session, 'DIRECT_NODE_STOPPED');
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.close();
+        this.iceUdpMuxListener.stop();
+    }
+    async dispatch(command) {
+        if (command.type === 'direct.prepare') {
+            this.prepare(command);
+            return;
+        }
+        const session = this.sessions.get(command.directSessionId);
+        if (session === undefined)
+            throw new Error('DIRECT_SESSION_INVALID');
+        if (command.type === 'direct.signal') {
+            await this.signal(session, command.signal);
+            return;
+        }
+        if (command.type === 'direct.grant') {
+            if (command.browserFingerprint !== fingerprint(session.peer.remoteDescription?.sdp) ||
+                command.nodeFingerprint !== fingerprint(session.peer.localDescription?.sdp) ||
+                command.openExpiresAt <= this.now() ||
+                command.expiresAt > session.command.expiresAt)
+                throw new Error('DIRECT_GRANT_INVALID');
+            session.grant = command;
+            return;
+        }
+        if (command.type === 'direct.heartbeat') {
+            if (session.command.expiresAt <= this.now())
+                await this.remove(session, 'DIRECT_SESSION_EXPIRED');
+            else
+                session.lastLeaseAliveAt = this.now();
+            return;
+        }
+        await this.remove(session, command.code);
+    }
+    prepare(command) {
+        if (command.nodeGeneration !== this.options.nodeGeneration())
+            throw new Error('DIRECT_NODE_GENERATION_MISMATCH');
+        if (this.sessions.has(command.directSessionId))
+            throw new Error('DIRECT_SESSION_CONFLICT');
+        if (this.sessions.size >= MAX_ACTIVE_SESSIONS)
+            throw new Error('DIRECT_SESSION_LIMIT_REACHED');
+        const peer = this.createPeerConnection(this.peerConfiguration);
+        const session = {
+            command,
+            peer,
+            opened: false,
+            uploadCommitted: false,
+            processing: Promise.resolve(),
+            sentCandidateKeys: new Set()
+        };
+        this.sessions.set(command.directSessionId, session);
+        peer.onicecandidate = (event) => {
+            const candidate = event.candidate;
+            if (candidate === null) {
+                this.emit(command.directSessionId, {
+                    type: 'direct.signal',
+                    directSessionId: command.directSessionId,
+                    signal: { kind: 'END_OF_CANDIDATES' }
+                });
+                return;
+            }
+            const json = candidate.toJSON();
+            if (typeof json.candidate !== 'string' ||
+                !acceptHostCandidate(json.candidate, session.sentCandidateKeys))
+                return;
+            this.emit(command.directSessionId, {
+                type: 'direct.signal',
+                directSessionId: command.directSessionId,
+                signal: {
+                    kind: 'CANDIDATE',
+                    candidate: {
+                        candidate: json.candidate,
+                        sdpMid: json.sdpMid ?? null,
+                        sdpMLineIndex: json.sdpMLineIndex ?? null
+                    }
+                }
+            });
+        };
+        peer.ondatachannel = (event) => this.attachChannel(session, event.channel);
+        peer.onconnectionstatechange = () => {
+            if (peer.connectionState === 'connected')
+                this.emit(session.command.directSessionId, {
+                    type: 'direct.connected',
+                    directSessionId: session.command.directSessionId
+                });
+            if (peer.connectionState === 'failed' || peer.connectionState === 'closed')
+                void this.remove(session, 'DIRECT_CONNECTION_FAILED');
+        };
+    }
+    async signal(session, signal) {
+        if (signal.kind === 'CANDIDATE') {
+            if (!safeHostCandidate(signal.candidate.candidate))
+                throw new Error('DIRECT_CANDIDATE_REJECTED');
+            await session.peer.addIceCandidate(signal.candidate);
+            return;
+        }
+        if (signal.kind === 'END_OF_CANDIDATES') {
+            await session.peer.addIceCandidate(null);
+            return;
+        }
+        if (!hostOnlySdp(signal.sdp))
+            throw new Error('DIRECT_CANDIDATE_REJECTED');
+        await session.peer.setRemoteDescription({
+            type: signal.kind === 'OFFER' ? 'offer' : 'answer',
+            sdp: signal.sdp
+        });
+        if (signal.kind !== 'OFFER')
+            return;
+        const answer = await session.peer.createAnswer();
+        await session.peer.setLocalDescription(answer);
+        const localSdp = session.peer.localDescription?.sdp;
+        const filtered = filterIceCandidates(localSdp, session.sentCandidateKeys);
+        const sdp = filtered.sdp;
+        const localFingerprint = fingerprint(localSdp);
+        if (sdp === undefined || localFingerprint === undefined)
+            throw new Error('DIRECT_FINGERPRINT_MISSING');
+        this.emit(session.command.directSessionId, {
+            type: 'direct.signal',
+            directSessionId: session.command.directSessionId,
+            signal: { kind: 'ANSWER', sdp, fingerprint: localFingerprint }
+        });
+    }
+    attachChannel(session, channel) {
+        session.channel = channel;
+        channel.binaryType = 'arraybuffer';
+        channel.onmessage = (event) => {
+            session.processing = session.processing
+                .then(() => this.channelMessage(session, event.data))
+                .catch((error) => this.fail(session.command.directSessionId, errorCode(error), errorMessage(error)));
+        };
+        channel.onclose = () => {
+            if (this.sessions.get(session.command.directSessionId) === session)
+                void this.remove(session, 'DIRECT_CHANNEL_CLOSED');
+        };
+    }
+    async channelMessage(session, data) {
+        if (!session.opened) {
+            if (typeof data !== 'string')
+                throw new Error('DIRECT_OPEN_REQUIRED');
+            const parsed = directDataControlFrameSchema.parse(JSON.parse(data));
+            if (parsed.type !== 'OPEN')
+                throw new Error('DIRECT_OPEN_REQUIRED');
+            const grant = session.grant;
+            if (grant === undefined ||
+                parsed.directSessionId !== session.command.directSessionId ||
+                parsed.grant !== grant.grant ||
+                grant.openExpiresAt <= this.now() ||
+                grant.expiresAt <= this.now())
+                throw new Error('DIRECT_GRANT_INVALID');
+            session.opened = true;
+            if (session.command.purpose === 'TRANSFER')
+                this.startLeaseWatch(session);
+            await this.open(session);
+            return;
+        }
+        if (session.command.purpose !== 'TRANSFER' || session.command.transfer === undefined)
+            throw new Error('DIRECT_FRAME_INVALID');
+        if (session.command.transfer.direction === 'DOWNLOAD') {
+            if (typeof data !== 'string')
+                throw new Error('DIRECT_FRAME_INVALID');
+            const control = directDataControlFrameSchema.parse(JSON.parse(data));
+            if (control.type !== 'ACK' || control.offset !== session.command.transfer.size)
+                throw new Error('DIRECT_FRAME_INVALID');
+            this.emit(session.command.directSessionId, {
+                type: 'direct.complete',
+                directSessionId: session.command.directSessionId,
+                size: session.command.transfer.size,
+                sha256: session.command.transfer.sha256
+            });
+            await this.remove(session);
+            return;
+        }
+        if (typeof data === 'string') {
+            const control = directDataControlFrameSchema.parse(JSON.parse(data));
+            if (control.type !== 'COMPLETE' || session.upload === undefined)
+                throw new Error('DIRECT_FRAME_INVALID');
+            if (control.size !== session.command.transfer.size ||
+                control.sha256 !== session.command.transfer.sha256)
+                throw new Error('DIRECT_INTEGRITY_FAILED');
+            await session.upload.complete(control.size, control.sha256);
+            session.uploadCommitted = true;
+            this.emit(session.command.directSessionId, {
+                type: 'direct.complete',
+                directSessionId: session.command.directSessionId,
+                size: control.size,
+                sha256: control.sha256
+            });
+            await this.remove(session);
+            return;
+        }
+        const bytes = toBytes(data);
+        if (bytes.byteLength === 0 || bytes.byteLength > 256 * 1024 || session.upload === undefined)
+            throw new Error('DIRECT_CHUNK_INVALID');
+        const offset = await session.upload.write(bytes);
+        session.channel?.send(JSON.stringify({ type: 'ACK', offset }));
+    }
+    async open(session) {
+        if (session.command.purpose === 'PROBE') {
+            session.channel?.send(JSON.stringify({ type: 'ACK', offset: 0 }));
+            this.emit(session.command.directSessionId, {
+                type: 'direct.probe-result',
+                directSessionId: session.command.directSessionId,
+                result: 'DIRECT_AVAILABLE'
+            });
+            await this.remove(session);
+            return;
+        }
+        const descriptor = session.command.transfer;
+        if (descriptor === undefined)
+            throw new Error('DIRECT_TRANSFER_INVALID');
+        if (descriptor.direction === 'UPLOAD') {
+            if (this.options.openUpload === undefined)
+                throw new Error('DIRECT_UPLOAD_UNAVAILABLE');
+            session.upload = await this.options.openUpload(descriptor);
+            session.channel?.send(JSON.stringify({ type: 'ACK', offset: session.upload.offset }));
+            this.emit(session.command.directSessionId, {
+                type: 'direct.opened',
+                directSessionId: session.command.directSessionId,
+                offset: session.upload.offset
+            });
+            return;
+        }
+        if (this.options.openDownload === undefined)
+            throw new Error('DIRECT_DOWNLOAD_UNAVAILABLE');
+        const source = await this.options.openDownload(descriptor);
+        session.channel?.send(JSON.stringify({ type: 'ACK', offset: source.offset }));
+        this.emit(session.command.directSessionId, {
+            type: 'direct.opened',
+            directSessionId: session.command.directSessionId,
+            offset: source.offset
+        });
+        for await (const chunk of source.chunks) {
+            for (let offset = 0; offset < chunk.byteLength; offset += 256 * 1024) {
+                if (this.sessions.get(session.command.directSessionId) !== session)
+                    return;
+                const channel = session.channel;
+                if (channel === undefined)
+                    throw new Error('DIRECT_CHANNEL_CLOSED');
+                await this.waitForSendCapacity(session, channel);
+                const end = Math.min(chunk.byteLength, offset + 256 * 1024);
+                channel.send(chunk.buffer.slice(chunk.byteOffset + offset, chunk.byteOffset + end));
+            }
+        }
+        session.channel?.send(JSON.stringify({
+            type: 'COMPLETE',
+            size: descriptor.size,
+            sha256: descriptor.sha256
+        }));
+    }
+    async waitForSendCapacity(session, channel) {
+        if (channel.readyState !== 'open')
+            throw new Error('DIRECT_CHANNEL_CLOSED');
+        if (channel.bufferedAmount <= DATA_CHANNEL_HIGH_WATER_BYTES)
+            return;
+        channel.bufferedAmountLowThreshold = DATA_CHANNEL_LOW_WATER_BYTES;
+        await new Promise((resolve, reject) => {
+            const complete = (error) => {
+                channel.removeEventListener('bufferedamountlow', available);
+                channel.removeEventListener('close', closed);
+                if (error === undefined)
+                    resolve();
+                else
+                    reject(error);
+            };
+            const available = () => complete();
+            const closed = () => complete(new Error('DIRECT_CHANNEL_CLOSED'));
+            channel.addEventListener('bufferedamountlow', available, { once: true });
+            channel.addEventListener('close', closed, { once: true });
+            if (this.sessions.get(session.command.directSessionId) !== session ||
+                channel.readyState !== 'open')
+                closed();
+            else if (channel.bufferedAmount <= DATA_CHANNEL_LOW_WATER_BYTES)
+                available();
+        });
+    }
+    startLeaseWatch(session) {
+        session.lastLeaseAliveAt = this.now();
+        session.leaseTimer = setInterval(() => {
+            const now = this.now();
+            if (session.command.expiresAt <= now) {
+                void this.remove(session, 'DIRECT_SESSION_EXPIRED');
+                return;
+            }
+            if (now - (session.lastLeaseAliveAt ?? now) > this.leaseGraceMs)
+                void this.remove(session, 'DIRECT_LEASE_EXPIRED');
+        }, this.leaseCheckMs);
+    }
+    emit(directSessionId, event) {
+        if (this.sessions.has(directSessionId))
+            this.options.send(event.type, event);
+    }
+    fail(directSessionId, code, message) {
+        const session = this.sessions.get(directSessionId);
+        this.options.send('direct.error', { type: 'direct.error', directSessionId, code, message });
+        if (session !== undefined)
+            void this.remove(session);
+    }
+    async remove(session, code) {
+        if (!this.sessions.delete(session.command.directSessionId))
+            return;
+        if (session.leaseTimer !== undefined)
+            clearInterval(session.leaseTimer);
+        if (!session.uploadCommitted)
+            await session.upload?.cancel().catch(() => undefined);
+        session.channel?.close();
+        session.peer.close();
+        if (code !== undefined)
+            this.options.send('direct.error', {
+                type: 'direct.error',
+                directSessionId: session.command.directSessionId,
+                code,
+                message: directErrorMessage(code)
+            });
+    }
+}
+function bindIceUdpMuxListener(range, create) {
+    let lastError;
+    for (let port = range.begin; port <= range.end; port += 1) {
+        try {
+            return create(port);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw new Error('DIRECT_UDP_PORT_UNAVAILABLE', { cause: lastError });
+}
+export function fingerprint(sdp) {
+    const match = sdp?.match(/^a=fingerprint:(sha-256 [A-F0-9:]+)\r?$/imu);
+    return match?.[1];
+}
+function safeHostCandidate(candidate) {
+    if (!/\styp host(?:\s|$)/u.test(candidate))
+        return false;
+    const address = candidate.trim().split(/\s+/u)[4];
+    if (address === undefined)
+        return false;
+    return address.length > 0;
+}
+function hostOnlySdp(sdp) {
+    return sdp
+        .split(/\r?\n/u)
+        .filter((line) => line.startsWith('a=candidate:'))
+        .every((line) => safeHostCandidate(line.slice(2)));
+}
+function candidateKey(candidate) {
+    const fields = candidate.trim().split(/\s+/u);
+    const component = fields[1];
+    const protocol = fields[2]?.toLowerCase();
+    const address = fields[4]?.toLowerCase();
+    if (component === undefined || protocol === undefined || address === undefined)
+        return undefined;
+    return `${component}:${protocol}:${address}`;
+}
+function acceptHostCandidate(candidate, accepted) {
+    if (!safeHostCandidate(candidate))
+        return false;
+    const key = candidateKey(candidate);
+    if (key === undefined || accepted.has(key) || accepted.size >= MAX_HOST_CANDIDATES)
+        return false;
+    accepted.add(key);
+    return true;
+}
+function filterIceCandidates(sdp, accepted) {
+    if (sdp === undefined)
+        return { sdp: undefined };
+    const included = new Set();
+    const lines = sdp.split(/\r?\n/u).filter((line) => {
+        if (!line.startsWith('a=candidate:'))
+            return true;
+        const candidate = line.slice(2);
+        if (!safeHostCandidate(candidate))
+            return false;
+        const key = candidateKey(candidate);
+        if (key === undefined || included.has(key))
+            return false;
+        if (!accepted.has(key) && accepted.size >= MAX_HOST_CANDIDATES)
+            return false;
+        accepted.add(key);
+        included.add(key);
+        return true;
+    });
+    return { sdp: lines.join('\r\n') };
+}
+function toBytes(value) {
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (ArrayBuffer.isView(value))
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    throw new Error('DIRECT_CHUNK_INVALID');
+}
+function errorCode(error) {
+    return error instanceof Error && /^[A-Z][A-Z0-9_]{0,127}$/u.test(error.message)
+        ? error.message
+        : 'DIRECT_INTERNAL_ERROR';
+}
+function errorMessage(error) {
+    const code = errorCode(error);
+    return code === 'DIRECT_INTERNAL_ERROR'
+        ? 'The Node could not complete the direct transfer operation.'
+        : directErrorMessage(code);
+}
+function directErrorMessage(code) {
+    const messages = {
+        DIRECT_NODE_GENERATION_MISMATCH: 'The Node connection generation changed.',
+        DIRECT_SESSION_INVALID: 'The direct transfer session is unavailable.',
+        DIRECT_SESSION_CONFLICT: 'The direct transfer session already exists.',
+        DIRECT_SESSION_LIMIT_REACHED: 'The direct transfer session limit has been reached.',
+        DIRECT_CANDIDATE_REJECTED: 'The direct transfer candidate is not a host candidate.',
+        DIRECT_GRANT_INVALID: 'The direct transfer grant is invalid or expired.',
+        DIRECT_CONNECTION_FAILED: 'The direct connection failed.',
+        DIRECT_CHANNEL_CLOSED: 'The direct data channel closed.',
+        DIRECT_SESSION_EXPIRED: 'The direct transfer session expired.',
+        DIRECT_LEASE_EXPIRED: 'The Server authorization lease expired.',
+        DIRECT_NODE_STOPPED: 'The Node stopped the direct transfer service.'
+    };
+    return messages[code] ?? 'The direct transfer operation failed.';
+}

package/dist/service/mission-runtime.js

@@ -14,6 +14,16 @@ export function stripMissionStartPrompt(text) {
     const close = text.indexOf(START_CLOSE);
     return close === -1 ? '' : text.slice(close + START_CLOSE.length).trimStart();
 }
+export function publicMissionHistoryText(text) {
+    if (!text.startsWith(START_OPEN))
+        return text;
+    const stripped = stripMissionStartPrompt(text);
+    if (stripped.length > 0)
+        return stripped;
+    const close = text.indexOf(START_CLOSE);
+    const prompt = close === -1 ? text : text.slice(0, close);
+    return prompt.includes('Continue the active Mission.') ? 'Mission Continue' : 'Mission Start';
+}
 export class MissionRuntime {
     changed;
     missions = new Map();

package/dist/service/node-connection-lifecycle-service.js

@@ -37,6 +37,7 @@ export class NodeConnectionLifecycleService {
             ...(config.conversationHosting === undefined
                 ? {}
                 : { conversationHosting: config.conversationHosting }),
+            ...(config.directTransfer === undefined ? {} : { directTransfer: config.directTransfer }),
             nodeId,
             credential
         };

package/dist/service/node-control-message-service.js

@@ -35,6 +35,9 @@ export class NodeControlMessageService {
         }
         if (this.options.handleRuntimeCredentialResponse(envelope))
             return;
+        if (envelope.type.startsWith('direct.') &&
+            this.options.handleDirectTransfer?.(envelope) === true)
+            return;
         if (envelope.type === 'ack')
             return;
         if (envelope.type === 'runs.reconcile') {

package/dist/service/session-message-service.js

@@ -25,6 +25,9 @@ export class SessionMessageService {
             content: input.kind === 'start' ? 'Mission Start' : 'Mission Continue',
             __runnerContent: input.content,
             __missionRef: input.mission,
+            ...(input.initiatedByUserId === undefined
+                ? {}
+                : { __requestUserId: input.initiatedByUserId }),
             deliveryIntent: input.deliveryIntent,
             secretEnvironment: input.secretEnvironment,
             personalInstructions: input.personalInstructions,

package/dist/service/workbench-manifest-service.js

@@ -23,6 +23,7 @@ export class WorkbenchManifestService {
             manifestVersion: 1,
             revision: revisionFor(capabilities),
             observedAt: Date.now(),
+            nodeGeneration: this.options.nodeGeneration(),
             platform: capabilities.platform,
             architecture: capabilities.architecture,
             conversation: {
@@ -45,6 +46,7 @@ export class WorkbenchManifestService {
                 maxReadBytes: 512 * 1024,
                 maxSearchResults: 200
             },
+            directTransfer: capabilities.workspaceDirectTransfer,
             git: {
                 available: true,
                 reasonCode: null,

package/dist/service/workspace-file-service.js

@@ -1,4 +1,5 @@
 import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { isAbsolute, win32 } from 'node:path';
 import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAllowedFileContentRange, readWorkspaceFileContentRange, readAllowedTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
 const INDEX_CACHE_LIMIT = 8;
@@ -58,6 +59,54 @@ export class WorkspaceFileService {
             ? readAllowedFileContentRange(path, this.previewRoots(), offset, limit)
             : readWorkspaceFileContentRange(workspacePath, path, offset, limit);
     }
+    readDirect(workspace, input, workspacePath = workspace.path) {
+        const service = this;
+        return (async function* () {
+            const hash = createHash('sha256');
+            let offset = 0;
+            while (true) {
+                const range = (await service.readContent(workspace, {
+                    path: input.path,
+                    offset,
+                    limit: 512 * 1024
+                }, workspacePath));
+                if (range.size !== input.size)
+                    throw new Error('DIRECT_FILE_REVISION_CHANGED');
+                const bytes = Buffer.from(range.contentBase64, 'base64');
+                hash.update(bytes);
+                offset += bytes.length;
+                if (bytes.length > 0)
+                    yield bytes;
+                if (range.nextOffset === null)
+                    break;
+                if (range.nextOffset !== offset)
+                    throw new Error('DIRECT_FILE_REVISION_CHANGED');
+            }
+            if (offset !== input.size || hash.digest('hex') !== input.sha256)
+                throw new Error('DIRECT_FILE_REVISION_CHANGED');
+        })();
+    }
+    async directMetadata(workspace, input, workspacePath = workspace.path) {
+        const hash = createHash('sha256');
+        let offset = 0;
+        let size;
+        while (true) {
+            const range = (await this.readContent(workspace, { ...input, offset, limit: 512 * 1024 }, workspacePath));
+            size ??= range.size;
+            if (range.size !== size)
+                throw new Error('DIRECT_FILE_REVISION_CHANGED');
+            const bytes = Buffer.from(range.contentBase64, 'base64');
+            hash.update(bytes);
+            offset += bytes.length;
+            if (range.nextOffset === null)
+                break;
+            if (range.nextOffset !== offset)
+                throw new Error('DIRECT_FILE_REVISION_CHANGED');
+        }
+        if (size === undefined || offset !== size)
+            throw new Error('DIRECT_FILE_REVISION_CHANGED');
+        return { size, sha256: hash.digest('hex') };
+    }
     async write(workspace, input) {
         if (typeof input.path !== 'string' ||
             typeof input.content !== 'string' ||

package/dist/service/workspace-upload-service.js

@@ -1,6 +1,7 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
 import { lstat, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, posix, resolve } from 'node:path';
 import { parseComposerAttachmentUpload, validComposerAttachmentName } from '../util/node-operation-parsers.js';
 import { preflightWorkspaceUpload, workspaceUploadTemporaryName } from '../workspace.js';
 const CHUNK_BYTES = 512 * 1024;
@@ -9,6 +10,7 @@ const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 export class WorkspaceUploadService {
     state;
     onCompleted;
+    directHashes = new Map();
     constructor(state, onCompleted) {
         this.state = state;
         this.onCompleted = onCompleted;
@@ -99,6 +101,44 @@ export class WorkspaceUploadService {
         upload.receivedBytes += bytes.length;
         return this.status(upload.id);
     }
+    async createDirect(workspace, input) {
+        const normalized = input.path.replaceAll('\\', '/');
+        const status = await this.create(workspace, {
+            name: posix.basename(normalized),
+            size: input.size,
+            overwrite: input.overwrite,
+            ...(input.composerAttachment === undefined
+                ? { directory: posix.dirname(normalized) }
+                : {
+                    composerAttachmentId: input.composerAttachment.id,
+                    mime: input.composerAttachment.mime
+                })
+        });
+        this.directHashes.set(status.uploadId, input.sha256);
+        return status;
+    }
+    async writeDirect(uploadId, bytes) {
+        const status = await this.write({
+            uploadId,
+            offset: this.status(uploadId).receivedBytes,
+            dataBase64: Buffer.from(bytes).toString('base64')
+        });
+        return status.receivedBytes;
+    }
+    async completeDirect(uploadId, size, sha256) {
+        const upload = this.require(uploadId);
+        const expected = this.directHashes.get(uploadId);
+        if (size !== upload.size || sha256 !== expected)
+            throw new Error('UPLOAD_HASH_INVALID');
+        await upload.handle.sync();
+        const actual = await fileSha256(upload.temporaryPath);
+        if (actual !== expected) {
+            await this.cancel(uploadId);
+            throw new Error('UPLOAD_HASH_INVALID');
+        }
+        await this.complete(uploadId);
+        this.directHashes.delete(uploadId);
+    }
     status(uploadId) {
         const upload = this.require(uploadId);
         return {
@@ -163,8 +203,10 @@ export class WorkspaceUploadService {
         if (typeof uploadId !== 'string')
             throw new Error('UPLOAD_NOT_FOUND');
         const active = this.state.uploads.get(uploadId);
-        if (active !== undefined)
+        if (active !== undefined) {
+            this.directHashes.delete(active.id);
             return this.remove(active);
+        }
         const attachment = this.state.composerAttachments.get(uploadId);
         if (attachment === undefined)
             throw new Error('UPLOAD_NOT_FOUND');
@@ -204,6 +246,7 @@ export class WorkspaceUploadService {
         for (const attachment of this.state.composerAttachments.values())
             await this.removeCompleted(attachment);
         this.state.composerAttachments.clear();
+        this.directHashes.clear();
     }
     require(id) {
         if (typeof id !== 'string')
@@ -215,6 +258,7 @@ export class WorkspaceUploadService {
     }
     async remove(upload) {
         this.state.uploads.delete(upload.id);
+        this.directHashes.delete(upload.id);
         clearTimeout(upload.timer);
         await upload.handle.close().catch(() => undefined);
         await rm(upload.temporaryPath, { force: true }).catch(() => undefined);
@@ -252,6 +296,12 @@ export class WorkspaceUploadService {
         };
     }
 }
+async function fileSha256(path) {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(path))
+        hash.update(chunk);
+    return hash.digest('hex');
+}
 async function safeDirectory(path) {
     const value = await lstat(path);
     if (!value.isDirectory() || value.isSymbolicLink())

package/dist/service/workspace-workbench-service.js

@@ -1,4 +1,5 @@
-import { listGitHistoryRefs, readGitHistory, readGitHistoryFileDiff, readGitHistoryFileContentRange, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, resolveGitRepositoryTarget, restoreCurrentChange } from '../workspace.js';
+import { createHash } from 'node:crypto';
+import { listGitHistoryRefs, openGitHistoryFileContent, readGitHistory, readGitHistoryFileDiff, readGitHistoryFileContentRange, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, resolveGitRepositoryTarget, restoreCurrentChange } from '../workspace.js';
 import { WorkspaceContentSearchService } from './workspace-content-search-service.js';
 import { WorkspaceWatchController } from './workspace-watch-controller.js';
 import { WorkspaceWatchSnapshotService } from './workspace-watch-snapshot-service.js';
@@ -25,6 +26,7 @@ export class WorkspaceWorkbenchService {
             'workspace.file.read': (data) => this.readFile(record(data)),
             'workspace.file.write': (data) => this.writeFile(record(data)),
             'workspace.file.content.read': (data) => this.readFileContent(record(data)),
+            'workspace.file.direct.metadata': (data) => this.directFileMetadata(record(data)),
             'workspace.files.search': (data) => this.searchFiles(record(data)),
             'workspace.files.mutate': (data) => this.mutateFile(record(data)),
             'workspace.content.search': (data) => this.searchContent(record(data)),
@@ -44,6 +46,7 @@ export class WorkspaceWorkbenchService {
             'workspace.git.commit.files': (data) => this.gitCommitFiles(record(data)),
             'workspace.git.commit.file.diff': (data) => this.gitCommitFileDiff(record(data)),
             'workspace.git.commit.file.content.read': (data) => this.gitCommitFileContent(record(data)),
+            'workspace.git.commit.file.direct.metadata': (data) => this.gitCommitFileDirectMetadata(record(data)),
             'workspace.diff': (data) => this.diff(record(data))
         };
     }
@@ -123,6 +126,15 @@ export class WorkspaceWorkbenchService {
             file: await this.options.files.readContent(workspace, input, repository)
         };
     }
+    async directFileMetadata(input) {
+        if (typeof input.workspaceId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        const repository = await this.fileRepository(workspace, input);
+        return {
+            file: await this.options.files.directMetadata(workspace, input, repository)
+        };
+    }
     async changeDiff(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.path !== 'string' ||
@@ -217,6 +229,76 @@ export class WorkspaceWorkbenchService {
             file: await readGitHistoryFileContentRange(await this.gitRepository(input), input.commit, input.path, input.offset, input.limit, this.refs(input))
         };
     }
+    async gitCommitFileDirectMetadata(input) {
+        return {
+            file: await this.gitDirectMetadata(input)
+        };
+    }
+    async directDownload(descriptor) {
+        const workspace = this.options.requireWorkspace(descriptor.resource.workspaceId);
+        if (descriptor.resource.kind === 'WORKSPACE_FILE') {
+            const input = {
+                workspaceId: workspace.id,
+                path: descriptor.resource.path,
+                ...(descriptor.resource.worktreePath === undefined
+                    ? {}
+                    : { worktreePath: descriptor.resource.worktreePath })
+            };
+            return {
+                offset: descriptor.resumeOffset ?? 0,
+                chunks: this.options.files.readDirect(workspace, {
+                    path: descriptor.resource.path,
+                    size: descriptor.size,
+                    sha256: descriptor.sha256
+                }, await this.fileRepository(workspace, input))
+            };
+        }
+        const input = {
+            workspaceId: workspace.id,
+            path: descriptor.resource.path,
+            commit: descriptor.resource.commit,
+            ...(descriptor.resource.repositoryPath === undefined
+                ? {}
+                : { repositoryPath: descriptor.resource.repositoryPath }),
+            ...(descriptor.resource.worktreePath === undefined
+                ? {}
+                : { worktreePath: descriptor.resource.worktreePath })
+        };
+        const repository = await this.gitRepository(input);
+        const content = await openGitHistoryFileContent(repository, descriptor.resource.commit, descriptor.resource.path, this.refs(input));
+        if (content.size !== descriptor.size)
+            throw new Error('DIRECT_FILE_REVISION_CHANGED');
+        return {
+            offset: descriptor.resumeOffset ?? 0,
+            chunks: (async function* () {
+                const hash = createHash('sha256');
+                let offset = 0;
+                for await (const bytes of content.chunks) {
+                    hash.update(bytes);
+                    offset += bytes.length;
+                    if (bytes.length > 0)
+                        yield bytes;
+                }
+                if (offset !== descriptor.size || hash.digest('hex') !== descriptor.sha256)
+                    throw new Error('DIRECT_FILE_REVISION_CHANGED');
+            })()
+        };
+    }
+    async gitDirectMetadata(input) {
+        const repository = await this.gitRepository(input);
+        if (typeof input.commit !== 'string' || typeof input.path !== 'string')
+            throw new Error('GIT_HISTORY_COMMIT_INVALID');
+        const content = await openGitHistoryFileContent(repository, input.commit, input.path, this.refs(input));
+        const hash = createHash('sha256');
+        let offset = 0;
+        for await (const bytes of content.chunks) {
+            hash.update(bytes);
+            offset += bytes.length;
+        }
+        if (offset !== content.size)
+            throw new Error('DIRECT_FILE_REVISION_CHANGED');
+        return { size: content.size, sha256: hash.digest('hex') };
+    }
     async diff(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.fromRef !== 'string' ||

package/dist/workspace.js

@@ -1510,6 +1510,67 @@ export async function readGitHistoryFileContentRange(repository, commit, request
         nextOffset: nextOffset < size ? nextOffset : null
     };
 }
+export async function openGitHistoryFileContent(repository, commit, requestedPath, refs) {
+    await assertHistoryCommitReachable(repository, commit, refs);
+    const path = safeGitWorkspacePath(requestedPath);
+    const object = `${commit}:${path}`;
+    const sizeResult = await runReadOnlyGit(repository, ['cat-file', '-s', object]);
+    const size = Number(sizeResult.text.trim());
+    if (!Number.isSafeInteger(size) || size < 0)
+        throw new Error('FILE_RANGE_INVALID');
+    return {
+        path,
+        size,
+        chunks: (async function* () {
+            const child = spawn('git', ['cat-file', 'blob', object], {
+                cwd: repository,
+                shell: false,
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: {
+                    ...process.env,
+                    ...gitOperationEnvironment.getStore(),
+                    GIT_OPTIONAL_LOCKS: '0'
+                }
+            });
+            const errors = [];
+            let errorSize = 0;
+            let closed = false;
+            const exit = new Promise((resolveExit) => {
+                child.stderr.on('data', (chunk) => {
+                    const remaining = Math.max(0, 4096 - errorSize);
+                    if (remaining === 0)
+                        return;
+                    const retained = chunk.subarray(0, remaining);
+                    errors.push(retained);
+                    errorSize += retained.length;
+                });
+                child.once('error', (error) => {
+                    closed = true;
+                    resolveExit({ code: 1, stderr: error.message });
+                });
+                child.once('close', (code) => {
+                    closed = true;
+                    resolveExit({
+                        code: code ?? 1,
+                        stderr: Buffer.concat(errors).toString('utf8')
+                    });
+                });
+            });
+            try {
+                for await (const chunk of child.stdout)
+                    yield new Uint8Array(chunk);
+                const result = await exit;
+                if (result.code !== 0)
+                    throw new GitCommandError(result.code, result.stderr);
+            }
+            finally {
+                if (!closed)
+                    child.kill('SIGKILL');
+            }
+        })()
+    };
+}
 export async function readCurrentChanges(workspacePath) {
     return (await readCurrentChangesSummary(workspacePath)).changes;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.67",
+  "version": "0.9.69",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0",
   "type": "module",
@@ -24,11 +24,12 @@
     "@modelcontextprotocol/sdk": "1.30.0",
     "@opencode-ai/sdk": "1.18.20",
     "minimatch": "^10.2.6",
+    "node-datachannel": "0.33.4",
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.67",
-    "@myagentroam/protocol": "0.9.67"
+    "@myagentroam/agent": "0.9.69",
+    "@myagentroam/protocol": "0.9.69"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"