tirtc-devtools-cli 0.0.6 → 0.0.8

package/vendor/app-server/dist/host/HostServer.js

@@ -64,6 +64,39 @@ function resolveLocalAssetsDir(source) {
     }
     return assetsDir;
 }
+function normalizeCommandPayload(payload) {
+    if (typeof payload === 'string') {
+        return {
+            payloadEncoding: 'utf8',
+            payload,
+        };
+    }
+    if (payload instanceof Uint8Array) {
+        return {
+            payloadEncoding: 'base64',
+            payload: Buffer.from(payload).toString('base64'),
+        };
+    }
+    if (Array.isArray(payload) && payload.every((value) => typeof value === 'number')) {
+        return {
+            payloadEncoding: 'base64',
+            payload: Buffer.from(payload).toString('base64'),
+        };
+    }
+    if (typeof payload === 'object' && payload !== null && 'type' in payload && payload.type === 'Buffer') {
+        const data = payload.data;
+        if (Array.isArray(data) && data.every((value) => typeof value === 'number')) {
+            return {
+                payloadEncoding: 'base64',
+                payload: Buffer.from(data).toString('base64'),
+            };
+        }
+    }
+    return {
+        payloadEncoding: 'utf8',
+        payload: '',
+    };
+}
 class HostServer {
     state;
     artifactManager;
@@ -175,6 +208,19 @@ class HostServer {
         if (family !== 'runtime') {
             return;
         }
+        if (kind === 'connection.accepted') {
+            this.noteIncomingConnection(payload);
+            this.activatePendingStreamsOnConnected();
+            return;
+        }
+        if (kind === 'connection.disconnected') {
+            this.handleIncomingConnectionDisconnected(payload);
+            return;
+        }
+        if (kind === 'command.remote.requested') {
+            this.handleInboundRemoteCommandRequest(payload);
+            return;
+        }
         if (kind === 'transport.remote.request_audio' ||
             kind === 'transport.remote.request_video' ||
             kind === 'transport.remote.request_iframe') {
@@ -187,6 +233,53 @@ class HostServer {
             this.maybeAutoStartStreamFromRemoteDemand(streamId, media, payload);
         }
     }
+    snapshotPendingConnectionSummary() {
+        return {
+            state: this.state.connection.state,
+            direction: this.state.connection.direction,
+            peerId: this.state.connection.peerId,
+        };
+    }
+    handleInboundRemoteCommandRequest(payload) {
+        const remoteRequestId = Number(payload.remoteRequestId);
+        const commandId = Number(payload.commandId);
+        if (!Number.isInteger(remoteRequestId) || remoteRequestId <= 0 || !Number.isInteger(commandId)) {
+            return;
+        }
+        this.noteIncomingConnection(payload);
+        const normalizedPayload = normalizeCommandPayload(payload.payload);
+        const entry = {
+            remoteRequestId,
+            commandId,
+            payloadEncoding: normalizedPayload.payloadEncoding,
+            payload: normalizedPayload.payload,
+            receivedAt: new Date().toISOString(),
+            connection: this.snapshotPendingConnectionSummary(),
+        };
+        this.state.pendingRemoteCommands.set(remoteRequestId, entry);
+        this.writeEvent('command', 'command.remote.requested', {
+            ...entry,
+        });
+    }
+    clearPendingRemoteCommands(reason) {
+        if (this.state.pendingRemoteCommands.size === 0) {
+            return;
+        }
+        const clearedAt = new Date().toISOString();
+        for (const entry of this.state.pendingRemoteCommands.values()) {
+            this.writeEvent('command', 'command.remote.cleared', {
+                remoteRequestId: entry.remoteRequestId,
+                commandId: entry.commandId,
+                payloadEncoding: entry.payloadEncoding,
+                payload: entry.payload,
+                receivedAt: entry.receivedAt,
+                connection: entry.connection,
+                reason,
+                clearedAt,
+            });
+        }
+        this.state.pendingRemoteCommands.clear();
+    }
     noteIncomingConnection(payload) {
         if (this.state.connection.state === 'connected') {
             return;
@@ -198,6 +291,39 @@ class HostServer {
             connectedAt: new Date().toISOString(),
         };
     }
+    handleIncomingConnectionDisconnected(payload) {
+        if (this.state.connection.state === 'idle' || this.state.connection.state === 'disconnected') {
+            return;
+        }
+        this.clearPendingRemoteCommands('connection_disconnect');
+        const disconnectedAt = new Date().toISOString();
+        this.state.connection = {
+            state: 'disconnected',
+            direction: 'incoming',
+            peerId: this.state.connection.peerId,
+            connectedAt: this.state.connection.connectedAt,
+            disconnectedAt,
+            reasonCode: typeof payload.reasonCode === 'string' && payload.reasonCode.length > 0
+                ? payload.reasonCode
+                : undefined,
+        };
+        for (const stream of this.state.streams.values()) {
+            if (stream.direction !== 'send') {
+                continue;
+            }
+            if (stream.state !== 'active') {
+                continue;
+            }
+            stream.state = 'pending_on_connection';
+            stream.updatedAt = disconnectedAt;
+            this.writeEvent('stream', 'state.pending_on_reconnect', {
+                streamId: stream.streamId,
+                media: stream.media,
+                direction: stream.direction,
+                at: disconnectedAt,
+            });
+        }
+    }
     maybeAutoStartStreamFromRemoteDemand(streamId, media, payload) {
         const key = streamBindingKey(streamId, media);
         const bound = this.state.streamSourceBindings.get(key);
@@ -270,8 +396,13 @@ class HostServer {
                 return this.handleOutputAttach((0, HostProtocol_1.parseOutputAttachParams)(params));
             case 'output/detach':
                 return this.handleOutputDetach((0, HostProtocol_1.parseOutputDetachParams)(params));
+            case 'command/request':
             case 'command/send':
                 return this.handleCommandSend((0, HostProtocol_1.parseCommandSendParams)(params));
+            case 'command/reply':
+                return this.handleCommandReply((0, HostProtocol_1.parseCommandReplyParams)(params));
+            case 'command/pending/list':
+                return this.handleCommandPendingList();
             case 'events/subscribe':
                 return this.handleEventsSubscribe((0, HostProtocol_1.parseEventsSubscribeParams)(params));
             case 'artifact/readReport':
@@ -311,6 +442,7 @@ class HostServer {
         };
     }
     async handleHostShutdown() {
+        this.clearPendingRemoteCommands('host_shutdown');
         return {
             acceptedAt: new Date().toISOString(),
             service: this.state.service,
@@ -381,6 +513,7 @@ class HostServer {
             };
         }
         await this.runtimeAdapter.stopService();
+        this.clearPendingRemoteCommands('service_stop');
         this.state.service.state = 'stopped';
         this.state.service.stoppedAt = new Date().toISOString();
         return {
@@ -507,6 +640,7 @@ class HostServer {
             };
         }
         await this.runtimeAdapter.disconnect();
+        this.clearPendingRemoteCommands('connection_disconnect');
         this.state.connection.state = 'disconnected';
         this.state.connection.disconnectedAt = new Date().toISOString();
         return {
@@ -631,15 +765,51 @@ class HostServer {
         };
     }
     async handleCommandSend(params) {
-        const response = await this.runtimeAdapter.sendCommand(params.commandId, params.kind, params.payloadEncoding, params.payload, params.replyToSequenceNumber, params.awaitResponse, params.timeoutMs);
+        const response = await this.runtimeAdapter.sendCommand(params.commandId, params.payloadEncoding, params.payload, params.timeoutMs);
         return {
             sequenceNumber: this.commandSequence++,
             commandId: params.commandId,
-            kind: params.kind,
             acceptedAt: new Date().toISOString(),
             response,
         };
     }
+    async handleCommandReply(params) {
+        const entry = this.state.pendingRemoteCommands.get(params.remoteRequestId);
+        if (!entry) {
+            throw new HostProtocol_1.HostProtocolError('invalid_request', `remoteRequestId ${params.remoteRequestId} is not pending`, false);
+        }
+        if (entry.commandId !== params.commandId) {
+            throw new HostProtocol_1.HostProtocolError('invalid_request', 'commandId does not match pending entry', false);
+        }
+        if (this.state.connection.state !== 'connected') {
+            throw new HostProtocol_1.HostProtocolError('connection_not_ready', 'connection is not established', true);
+        }
+        await this.runtimeAdapter.replyRemoteCommand(params.remoteRequestId, params.commandId, params.payloadEncoding, params.payload);
+        this.state.pendingRemoteCommands.delete(params.remoteRequestId);
+        const repliedAt = new Date().toISOString();
+        this.writeEvent('command', 'command.remote.replied', {
+            remoteRequestId: params.remoteRequestId,
+            commandId: params.commandId,
+            payloadEncoding: entry.payloadEncoding,
+            payload: entry.payload,
+            receivedAt: entry.receivedAt,
+            connection: entry.connection,
+            repliedAt,
+        });
+        return {
+            remoteRequestId: params.remoteRequestId,
+            commandId: params.commandId,
+            repliedAt,
+        };
+    }
+    async handleCommandPendingList() {
+        const items = Array.from(this.state.pendingRemoteCommands.values())
+            .sort((left, right) => left.receivedAt.localeCompare(right.receivedAt));
+        return {
+            items,
+            listedAt: new Date().toISOString(),
+        };
+    }
     async handleEventsSubscribe(params) {
         const families = params.families ?? [];
         for (const family of families) {

package/vendor/app-server/dist/host/HostState.d.ts

@@ -35,6 +35,19 @@ export interface StreamSourceBinding {
     source: StreamSource;
     updatedAt: string;
 }
+export interface CommandPendingConnectionSummary {
+    state: 'idle' | 'connecting' | 'accepting' | 'connected' | 'disconnecting' | 'disconnected' | 'failed' | 'missed';
+    direction?: 'incoming' | 'outgoing';
+    peerId?: string;
+}
+export interface CommandPendingEntry {
+    remoteRequestId: number;
+    commandId: number;
+    payloadEncoding: 'utf8' | 'base64';
+    payload: string;
+    receivedAt: string;
+    connection: CommandPendingConnectionSummary;
+}
 export declare class HostState {
     service: ServiceSnapshot;
     connection: ConnectionSnapshot;
@@ -42,6 +55,7 @@ export declare class HostState {
     subscriptions: Set<string>;
     internalConnections: Set<string>;
     streamSourceBindings: Map<string, StreamSourceBinding>;
+    pendingRemoteCommands: Map<number, CommandPendingEntry>;
     protocolVersion: string;
     serverVersion: string;
     runtimeTarget: string;

package/vendor/app-server/dist/host/HostState.js

@@ -8,6 +8,7 @@ class HostState {
     subscriptions = new Set();
     internalConnections = new Set();
     streamSourceBindings = new Map();
+    pendingRemoteCommands = new Map();
     protocolVersion = '1.0.0';
     serverVersion = '1.0.0';
     runtimeTarget = 'runtime-backed/unknown';

package/vendor/app-server/dist/host/RuntimeAdapter.d.ts

@@ -39,7 +39,8 @@ export interface RuntimeAdapter {
     stopReceiveStream(streamId: number): Promise<void>;
     attachOutput(streamId: number, consumer: string, mediaView: string, format: string, delivery: string, targetPath?: string, maxFiles?: number): Promise<OutputAttachResult>;
     detachOutput(outputId: string): Promise<void>;
-    sendCommand(commandId: number, kind: string, payloadEncoding: string, payload: string, replyToSequenceNumber?: number, awaitResponse?: boolean, timeoutMs?: number): Promise<RuntimeCommandResponse | undefined>;
+    sendCommand(commandId: number, payloadEncoding: string, payload: string, timeoutMs?: number): Promise<RuntimeCommandResponse | undefined>;
+    replyRemoteCommand(remoteRequestId: number, commandId: number, payloadEncoding: string, payload: string): Promise<void>;
 }
 type RuntimeBackedAdapterOptions = {
     runtimeBundleRoot: string;
@@ -88,6 +89,7 @@ export declare class RuntimeBackedAdapter implements RuntimeAdapter {
     stopReceiveStream(streamId: number): Promise<void>;
     attachOutput(streamId: number, consumer: string, mediaView: string, format: string, delivery: string, targetPath?: string, maxFiles?: number): Promise<OutputAttachResult>;
     detachOutput(outputId: string): Promise<void>;
-    sendCommand(commandId: number, kind: string, payloadEncoding: string, payload: string, replyToSequenceNumber?: number, awaitResponse?: boolean, timeoutMs?: number): Promise<RuntimeCommandResponse | undefined>;
+    sendCommand(commandId: number, payloadEncoding: string, payload: string, timeoutMs?: number): Promise<RuntimeCommandResponse | undefined>;
+    replyRemoteCommand(remoteRequestId: number, commandId: number, payloadEncoding: string, payload: string): Promise<void>;
 }
 export {};

package/vendor/app-server/dist/host/RuntimeAdapter.js

@@ -133,6 +133,26 @@ function resolveStreamAssetsDir(source) {
     }
     return assetsDir;
 }
+function decodePayload(payloadEncoding, payload) {
+    if (payloadEncoding === 'base64') {
+        return Uint8Array.from(Buffer.from(payload, 'base64'));
+    }
+    return Uint8Array.from(Buffer.from(payload, 'utf8'));
+}
+function encodePayload(payload) {
+    const buffer = Buffer.from(payload);
+    const utf8Text = buffer.toString('utf8');
+    if (Buffer.from(utf8Text, 'utf8').equals(buffer)) {
+        return {
+            payloadEncoding: 'utf8',
+            payload: utf8Text,
+        };
+    }
+    return {
+        payloadEncoding: 'base64',
+        payload: buffer.toString('base64'),
+    };
+}
 class RuntimeBackedAdapter {
     runtimeTarget;
     hostEndpoint = 'stdio://runtime-backed';
@@ -163,6 +183,15 @@ class RuntimeBackedAdapter {
             onLogLine: (payload) => {
                 this.emit('logs', 'runtime.line', payload);
             },
+            onRuntimeEvent: (kind, payload) => {
+                if (kind === 'connection.accepted') {
+                    this.connected = true;
+                }
+                else if (kind === 'connection.disconnected') {
+                    this.connected = false;
+                }
+                this.emit('runtime', kind, payload);
+            },
         });
         this.receiveWorker = new RuntimeReceiveWorker_1.RuntimeReceiveWorkerManager({
             repoRoot: this.repoRoot,
@@ -262,6 +291,7 @@ class RuntimeBackedAdapter {
     async startService(serviceEntry, license, timeoutMs) {
         this.assertRuntimeBundleReady();
         const resolvedServiceEntry = this.resolveServiceEntry(serviceEntry);
+        const keepaliveSession = await this.sendWorker.ensureServiceSession(resolvedServiceEntry, license);
         this.activeService = {
             serviceEntry: resolvedServiceEntry,
             license,
@@ -271,7 +301,8 @@ class RuntimeBackedAdapter {
             serviceEntry: resolvedServiceEntry,
             licensePresent: license.length > 0,
             timeoutMs,
-            senderBootstrapStarted: false,
+            senderBootstrapStarted: keepaliveSession.started,
+            workerPid: keepaliveSession.pid,
             at: nowIsoString(),
         });
         return resolvedServiceEntry;
@@ -404,6 +435,7 @@ class RuntimeBackedAdapter {
         if (!this.connected) {
             throw new Error('connection is not established');
         }
+        await this.sendWorker.sendStreamMessage(streamId, decodePayload('utf8', payload));
         this.emit('stream', 'message.runtime.send', {
             streamId,
             payloadPreview: payload.slice(0, 120),
@@ -567,32 +599,38 @@ class RuntimeBackedAdapter {
         await this.refreshReceiveWorker();
         this.emit('stream', 'output.detach.requested', { outputId, at: nowIsoString() });
     }
-    async sendCommand(commandId, kind, payloadEncoding, payload, replyToSequenceNumber, awaitResponse, timeoutMs) {
+    async sendCommand(commandId, payloadEncoding, payload, timeoutMs) {
         if (!this.connected) {
             throw new Error('connection is not established');
         }
         this.emit('command', 'send.requested', {
             commandId,
-            kind,
             payloadEncoding,
-            replyToSequenceNumber,
-            awaitResponse: Boolean(awaitResponse),
             timeoutMs,
             at: nowIsoString(),
         });
-        if (!awaitResponse) {
-            return undefined;
-        }
         const sequenceNumber = this.commandSequence;
         this.commandSequence += 1;
+        const response = await this.sendWorker.requestCommand(commandId, decodePayload(payloadEncoding, payload), timeoutMs ?? 15000);
+        const encodedResponse = encodePayload(response.payload);
         return {
             sequenceNumber,
-            payloadEncoding: 'runtime-evidence',
-            payload: JSON.stringify({
-                evidence: 'runtime-backed-callbacks',
-                commandRxCount: 1,
-            }),
+            payloadEncoding: encodedResponse.payloadEncoding,
+            payload: encodedResponse.payload,
         };
     }
+    async replyRemoteCommand(remoteRequestId, commandId, payloadEncoding, payload) {
+        if (!this.connected) {
+            throw new Error('connection is not established');
+        }
+        this.emit('command', 'reply.requested', {
+            remoteRequestId,
+            commandId,
+            payloadEncoding,
+            payloadLength: payload.length,
+            at: nowIsoString(),
+        });
+        await this.sendWorker.replyRemoteCommand(remoteRequestId, commandId, decodePayload(payloadEncoding, payload));
+    }
 }
 exports.RuntimeBackedAdapter = RuntimeBackedAdapter;

package/vendor/app-server/dist/host/RuntimeSendWorker.d.ts

@@ -7,6 +7,7 @@ type SendWorkerManagerOptions = {
         line: string;
         pid?: number;
     }) => void;
+    onRuntimeEvent?: (kind: string, payload: Record<string, unknown>) => void;
 };
 type SendWorkerStartOptions = {
     key: string;
@@ -20,9 +21,14 @@ export declare class RuntimeSendWorkerManager {
     private readonly repoRoot;
     private readonly bindings;
     private readonly onLogLine?;
+    private readonly onRuntimeEvent?;
     private readonly bridge;
     private sharedSession?;
+    private nextCommandRequestId;
+    private readonly pendingCommandRequests;
     constructor(options: SendWorkerManagerOptions);
+    private handleNativeEvent;
+    private rejectPendingCommandRequests;
     private emitLog;
     private resolveFixtureAssetsDir;
     private buildDesiredConfig;
@@ -42,5 +48,11 @@ export declare class RuntimeSendWorkerManager {
     }>;
     stopStream(key: string): Promise<void>;
     stopAll(): Promise<void>;
+    sendStreamMessage(streamId: number, payload: Uint8Array): Promise<void>;
+    requestCommand(commandId: number, payload: Uint8Array, timeoutMs: number): Promise<{
+        commandId: number;
+        payload: Uint8Array;
+    }>;
+    replyRemoteCommand(remoteRequestId: number, commandId: number, payload: Uint8Array): Promise<void>;
 }
 export {};

package/vendor/app-server/dist/host/RuntimeSendWorker.js

@@ -43,6 +43,25 @@ function pathExists(filePath) {
 function nowIsoString() {
     return new Date().toISOString();
 }
+function toSafeInteger(value) {
+    if (typeof value === 'number' && Number.isSafeInteger(value)) {
+        return value;
+    }
+    if (typeof value === 'bigint') {
+        const normalized = Number(value);
+        if (Number.isSafeInteger(normalized)) {
+            return normalized;
+        }
+        return undefined;
+    }
+    if (typeof value === 'string' && value.trim().length > 0) {
+        const normalized = Number(value);
+        if (Number.isSafeInteger(normalized)) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
 function ensureValidAssetsDir(assetsDir) {
     const resolved = path.resolve(assetsDir);
     let stats;
@@ -125,15 +144,90 @@ class RuntimeSendWorkerManager {
     repoRoot;
     bindings = new Map();
     onLogLine;
+    onRuntimeEvent;
     bridge;
     sharedSession;
+    nextCommandRequestId = 1;
+    pendingCommandRequests = new Map();
     constructor(options) {
         this.repoRoot = options.repoRoot;
         this.onLogLine = options.onLogLine;
+        this.onRuntimeEvent = options.onRuntimeEvent;
         this.bridge = new RuntimeHostBridge_1.RuntimeHostBridge({
             repoRoot: options.repoRoot,
             platform: options.platform,
         });
+        this.bridge.setUplinkEventHandler((event) => {
+            this.handleNativeEvent(event);
+        });
+    }
+    handleNativeEvent(event) {
+        this.emitLog('stdout', '[runtime-backed sender] native event kind=' + event.kind +
+            ' requestId=' + String(event.requestId ?? '') +
+            ' remoteRequestId=' + String(event.remoteRequestId ?? '') +
+            ' commandId=' + String(event.commandId ?? '') +
+            ' errorCode=' + String(event.errorCode ?? '') +
+            ' reasonCode=' + String(event.reasonCode ?? '') +
+            ' payloadLength=' + String(event.payload?.byteLength ?? 0));
+        if (event.kind === 'command.response') {
+            const requestId = Number(event.requestId);
+            if (!Number.isInteger(requestId)) {
+                return;
+            }
+            const pending = this.pendingCommandRequests.get(requestId);
+            if (!pending) {
+                return;
+            }
+            this.pendingCommandRequests.delete(requestId);
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+            if ((event.errorCode ?? 0) !== 0) {
+                pending.reject(new Error(`uplink command request failed error=${String(event.errorCode ?? -1)}`));
+                return;
+            }
+            pending.resolve({
+                commandId: Number.isInteger(event.commandId) ? Number(event.commandId) : pending.commandId,
+                payload: event.payload ?? new Uint8Array(),
+            });
+            return;
+        }
+        if (!this.onRuntimeEvent) {
+            return;
+        }
+        if (event.kind === 'connection.accepted') {
+            this.onRuntimeEvent(event.kind, { at: nowIsoString() });
+            return;
+        }
+        if (event.kind === 'connection.disconnected') {
+            this.onRuntimeEvent(event.kind, {
+                at: nowIsoString(),
+                reasonCode: String(event.reasonCode ?? 0),
+            });
+            return;
+        }
+        if (event.kind === 'command.remote.requested') {
+            const remoteRequestId = toSafeInteger(event.remoteRequestId);
+            const commandId = toSafeInteger(event.commandId);
+            this.onRuntimeEvent(event.kind, {
+                at: nowIsoString(),
+                remoteRequestId: remoteRequestId ?? String(event.remoteRequestId ?? ''),
+                commandId: commandId ?? event.commandId,
+                payload: event.payload,
+            });
+        }
+    }
+    rejectPendingCommandRequests(message) {
+        if (this.pendingCommandRequests.size === 0) {
+            return;
+        }
+        for (const [requestId, pending] of this.pendingCommandRequests.entries()) {
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+            pending.reject(new Error(`${message} requestId=${requestId}`));
+        }
+        this.pendingCommandRequests.clear();
     }
     emitLog(stream, line) {
         const normalized = line.trim();
@@ -201,6 +295,7 @@ class RuntimeSendWorkerManager {
         }
         this.bridge.stopUplink();
         this.sharedSession = undefined;
+        this.rejectPendingCommandRequests('uplink session stopped');
         this.emitLog('stdout', '[runtime-backed sender] session stopped');
     }
     async ensureSharedSession(serviceEntry, license, keepAliveWhenNoStreams) {
@@ -287,5 +382,57 @@ class RuntimeSendWorkerManager {
         this.bindings.clear();
         await this.stopSharedSession();
     }
+    async sendStreamMessage(streamId, payload) {
+        if (!this.sharedSession) {
+            throw new Error('uplink session is not started');
+        }
+        try {
+            this.bridge.sendUplinkStreamMessage(streamId, payload);
+            this.emitLog('stdout', '[runtime-backed sender] send_stream_message accepted streamId=' +
+                String(streamId) + ' payloadLength=' + String(payload.byteLength));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.emitLog('stderr', '[runtime-backed sender] send_stream_message failed streamId=' +
+                String(streamId) + ' payloadLength=' + String(payload.byteLength) + ' error=' + message);
+            throw error;
+        }
+    }
+    async requestCommand(commandId, payload, timeoutMs) {
+        if (!this.sharedSession) {
+            throw new Error('uplink session is not started');
+        }
+        const requestId = this.nextCommandRequestId++;
+        return await new Promise((resolve, reject) => {
+            const pending = {
+                commandId,
+                resolve,
+                reject,
+            };
+            pending.timer = setTimeout(() => {
+                if (!this.pendingCommandRequests.delete(requestId)) {
+                    return;
+                }
+                reject(new Error(`uplink command response timeout requestId=${requestId}`));
+            }, Math.max(timeoutMs * 2, timeoutMs + 2000));
+            this.pendingCommandRequests.set(requestId, pending);
+            try {
+                this.bridge.requestUplinkCommand(requestId, commandId, payload, timeoutMs);
+            }
+            catch (error) {
+                this.pendingCommandRequests.delete(requestId);
+                if (pending.timer) {
+                    clearTimeout(pending.timer);
+                }
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    async replyRemoteCommand(remoteRequestId, commandId, payload) {
+        if (!this.sharedSession) {
+            throw new Error('uplink session is not started');
+        }
+        this.bridge.replyUplinkRemoteCommand(remoteRequestId, commandId, payload);
+    }
 }
 exports.RuntimeSendWorkerManager = RuntimeSendWorkerManager;

package/vendor/app-server/dist/host/native/RuntimeHostBridge.d.ts

@@ -1,3 +1,12 @@
+export type UplinkNativeEvent = {
+    kind: string;
+    requestId?: number;
+    remoteRequestId?: number;
+    commandId?: number;
+    errorCode?: number;
+    reasonCode?: number;
+    payload?: Uint8Array;
+};
 type RuntimeHostBridgeOptions = {
     repoRoot: string;
     platform: string;
@@ -13,6 +22,10 @@ export declare class RuntimeHostBridge {
     private ensureBinding;
     startUplink(args: string[]): number;
     stopUplink(): void;
+    setUplinkEventHandler(handler: ((event: UplinkNativeEvent) => void) | undefined): void;
+    sendUplinkStreamMessage(streamId: number, payload: Uint8Array): void;
+    requestUplinkCommand(requestId: number, commandId: number, payload: Uint8Array, timeoutMs: number): void;
+    replyUplinkRemoteCommand(remoteRequestId: number, commandId: number, payload: Uint8Array): void;
     startDownlink(args: string[]): number;
     stopDownlink(): void;
 }