@secure-exec/core 0.0.0-agentos-dylib-base.edaa4a4

package/dist/message-frame-transport.d.ts

@@ -0,0 +1,29 @@
+import type { FrameTransport } from "./frame-stream.js";
+export interface MessageFrameEndpoint {
+    postMessage(message: unknown, transfer?: readonly unknown[]): void;
+}
+export interface MessageFrameTransportOptions<TReadFrame, TWriteFrame> {
+    endpoint: MessageFrameEndpoint;
+    listen(handler: (message: unknown) => void): () => void;
+    encodeFrame: (frame: TWriteFrame) => Uint8Array;
+    decodeFrame: (payload: Uint8Array) => TReadFrame;
+    transfer?: (payload: Uint8Array) => readonly unknown[];
+}
+export declare class MessageFrameTransport<TReadFrame, TWriteFrame = TReadFrame> implements FrameTransport<TReadFrame, TWriteFrame> {
+    private readonly endpoint;
+    private readonly encodeFrame;
+    private readonly decodeFrame;
+    private readonly transfer?;
+    private readonly frameListeners;
+    private readonly errorListeners;
+    private readonly endListeners;
+    private readonly stopListening;
+    constructor(options: MessageFrameTransportOptions<TReadFrame, TWriteFrame>);
+    onFrame(handler: (frame: TReadFrame) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    onEnd(handler: () => void): () => void;
+    writeFrame(frame: TWriteFrame): Promise<void>;
+    dispose(): void;
+    private readonly handleMessage;
+    private handleError;
+}

package/dist/message-frame-transport.js

@@ -0,0 +1,81 @@
+export class MessageFrameTransport {
+    endpoint;
+    encodeFrame;
+    decodeFrame;
+    transfer;
+    frameListeners = new Set();
+    errorListeners = new Set();
+    endListeners = new Set();
+    stopListening;
+    constructor(options) {
+        this.endpoint = options.endpoint;
+        this.encodeFrame = options.encodeFrame;
+        this.decodeFrame = options.decodeFrame;
+        this.transfer = options.transfer;
+        this.stopListening = options.listen(this.handleMessage);
+    }
+    onFrame(handler) {
+        this.frameListeners.add(handler);
+        return () => {
+            this.frameListeners.delete(handler);
+        };
+    }
+    onError(handler) {
+        this.errorListeners.add(handler);
+        return () => {
+            this.errorListeners.delete(handler);
+        };
+    }
+    onEnd(handler) {
+        this.endListeners.add(handler);
+        return () => {
+            this.endListeners.delete(handler);
+        };
+    }
+    async writeFrame(frame) {
+        const payload = this.encodeFrame(frame);
+        this.endpoint.postMessage(payload, this.transfer?.(payload));
+    }
+    dispose() {
+        this.stopListening();
+        this.frameListeners.clear();
+        this.errorListeners.clear();
+        this.endListeners.clear();
+    }
+    handleMessage = (message) => {
+        const payload = toByteArray(message);
+        if (!payload) {
+            this.handleError(new Error("message frame transport received non-byte message"));
+            return;
+        }
+        let frame;
+        try {
+            frame = this.decodeFrame(payload);
+        }
+        catch (error) {
+            this.handleError(error);
+            return;
+        }
+        for (const listener of this.frameListeners) {
+            listener(frame);
+        }
+    };
+    handleError(error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        for (const listener of this.errorListeners) {
+            listener(normalized);
+        }
+    }
+}
+function toByteArray(message) {
+    if (message instanceof Uint8Array) {
+        return new Uint8Array(message.buffer, message.byteOffset, message.byteLength);
+    }
+    if (message instanceof ArrayBuffer) {
+        return new Uint8Array(message);
+    }
+    if (ArrayBuffer.isView(message)) {
+        return new Uint8Array(message.buffer, message.byteOffset, message.byteLength);
+    }
+    return null;
+}

package/dist/native-client.d.ts

@@ -0,0 +1,42 @@
+import { StdioSidecarProcess } from "./process.js";
+import type { SidecarProcessTransport } from "./sidecar-client.js";
+import type { LiveEventFrame, LiveResponseFrame, LiveSidecarRequestHandler, ProtocolFramePayloadCodec } from "./protocol-frames.js";
+import type { LiveOwnershipScope } from "./ownership.js";
+import type { LiveRequestPayload } from "./request-payloads.js";
+import type { LiveSidecarEventSelector } from "./event-buffer.js";
+export declare const DEFAULT_SIDECAR_FRAME_TIMEOUT_MS = 120000;
+export declare const DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY = 4096;
+export declare const DEFAULT_SIDECAR_GRACEFUL_EXIT_MS = 5000;
+export declare const DEFAULT_SIDECAR_FORCE_EXIT_MS = 2000;
+export interface StdioSidecarProtocolClientSpawnOptions {
+    cwd?: string;
+    command?: string;
+    args?: string[];
+    frameTimeoutMs?: number;
+    eventBufferCapacity?: number;
+    gracefulExitMs?: number;
+    forceExitMs?: number;
+    disposedErrorMessage?: string;
+    payloadCodec?: ProtocolFramePayloadCodec;
+}
+export declare class StdioSidecarProtocolClient implements SidecarProcessTransport {
+    readonly child: StdioSidecarProcess["child"];
+    private readonly sidecarProcess;
+    private readonly protocolClient;
+    private readonly gracefulExitMs;
+    private readonly forceExitMs;
+    private readonly disposedErrorMessage;
+    private constructor();
+    static spawn(options?: StdioSidecarProtocolClientSpawnOptions): StdioSidecarProtocolClient;
+    setSidecarRequestHandler(handler: LiveSidecarRequestHandler | null): void;
+    onEvent(handler: (event: LiveEventFrame) => void): () => void;
+    sendRequest(input: {
+        ownership: LiveOwnershipScope;
+        payload: LiveRequestPayload;
+    }): Promise<LiveResponseFrame>;
+    waitForEvent(matcher: LiveSidecarEventSelector | ((event: LiveEventFrame) => boolean), timeoutMs?: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<LiveEventFrame>;
+    dispose(): Promise<void>;
+    failPermanently(error: Error): void;
+}

package/dist/native-client.js

@@ -0,0 +1,126 @@
+import { resolvePublishedSidecarBinary } from "./binary.js";
+import { SidecarProcessExited, StdioSidecarProcess, } from "./process.js";
+import { SidecarProtocolClient } from "./protocol-client.js";
+import { registerSidecarProcessSpawnFactory } from "./sidecar-process.js";
+export const DEFAULT_SIDECAR_FRAME_TIMEOUT_MS = 120_000;
+export const DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY = 4_096;
+export const DEFAULT_SIDECAR_GRACEFUL_EXIT_MS = 5_000;
+export const DEFAULT_SIDECAR_FORCE_EXIT_MS = 2_000;
+export class StdioSidecarProtocolClient {
+    child;
+    sidecarProcess;
+    protocolClient;
+    gracefulExitMs;
+    forceExitMs;
+    disposedErrorMessage;
+    constructor(sidecarProcess, options) {
+        this.sidecarProcess = sidecarProcess;
+        this.child = sidecarProcess.child;
+        this.gracefulExitMs = options.gracefulExitMs;
+        this.forceExitMs = options.forceExitMs;
+        this.disposedErrorMessage = options.disposedErrorMessage;
+        this.protocolClient = new SidecarProtocolClient({
+            stdin: this.child.stdin,
+            stdout: this.child.stdout,
+            frameTimeoutMs: options.frameTimeoutMs,
+            eventBufferCapacity: options.eventBufferCapacity,
+            payloadCodec: options.payloadCodec,
+            stderrText: () => this.sidecarProcess.stderrText(),
+            streamEndedError: () => this.sidecarProcess.currentExitError() ??
+                new SidecarProcessExited({
+                    exitCode: this.child.exitCode,
+                    signal: this.child.signalCode,
+                    stderr: this.sidecarProcess.stderrText(),
+                }),
+            frameError: (error) => this.sidecarProcess.currentExitError() ?? error,
+        });
+        this.sidecarProcess.onExit((error) => {
+            this.failPermanently(error);
+        });
+        this.sidecarProcess.onError((error) => {
+            this.failPermanently(error);
+        });
+    }
+    static spawn(options = {}) {
+        return new StdioSidecarProtocolClient(StdioSidecarProcess.spawn({
+            command: options.command ?? resolvePublishedSidecarBinary(),
+            args: options.args ?? [],
+            cwd: options.cwd,
+        }), {
+            frameTimeoutMs: options.frameTimeoutMs ?? DEFAULT_SIDECAR_FRAME_TIMEOUT_MS,
+            eventBufferCapacity: options.eventBufferCapacity ??
+                DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY,
+            gracefulExitMs: options.gracefulExitMs ?? DEFAULT_SIDECAR_GRACEFUL_EXIT_MS,
+            forceExitMs: options.forceExitMs ?? DEFAULT_SIDECAR_FORCE_EXIT_MS,
+            disposedErrorMessage: options.disposedErrorMessage ?? "sidecar client disposed",
+            payloadCodec: options.payloadCodec ?? "bare",
+        });
+    }
+    setSidecarRequestHandler(handler) {
+        this.protocolClient.setSidecarRequestHandler(handler);
+    }
+    onEvent(handler) {
+        return this.protocolClient.onEvent(handler);
+    }
+    async sendRequest(input) {
+        return await this.protocolClient.sendRequest(input);
+    }
+    async waitForEvent(matcher, timeoutMs, options) {
+        return await this.protocolClient.waitForEvent(matcher, timeoutMs, options);
+    }
+    async dispose() {
+        this.protocolClient.failPermanently(new Error(this.disposedErrorMessage));
+        if (!this.child.stdin.destroyed) {
+            try {
+                this.child.stdin.end();
+            }
+            catch {
+                // Stdin may already be closing. The child exit watcher will catch up.
+            }
+        }
+        const exitCode = await this.sidecarProcess.waitForExit(this.gracefulExitMs);
+        if (exitCode === null) {
+            try {
+                this.child.kill("SIGKILL");
+            }
+            catch {
+                // The child may have exited between the timeout and the kill attempt.
+            }
+            await this.sidecarProcess.waitForExit(this.forceExitMs);
+        }
+        this.protocolClient.dispose();
+        try {
+            this.child.stdin.destroy();
+        }
+        catch {
+            // Best effort. The child is gone so the descriptor will close on its own.
+        }
+        try {
+            this.child.stdout.destroy();
+        }
+        catch {
+            // Best effort. The child is gone so the descriptor will close on its own.
+        }
+        try {
+            this.child.stderr.destroy();
+        }
+        catch {
+            // Best effort. The child is gone so the descriptor will close on its own.
+        }
+        if (exitCode !== null &&
+            exitCode !== 0 &&
+            this.child.signalCode === null) {
+            throw new Error(`sidecar exited with code ${exitCode}\nstderr:\n${this.sidecarProcess.stderrText()}`);
+        }
+    }
+    failPermanently(error) {
+        this.protocolClient.failPermanently(error, {
+            replaceExisting: (current, next) => current instanceof SidecarProcessExited &&
+                current.exitCode === null &&
+                current.signal === null &&
+                next instanceof SidecarProcessExited &&
+                (next.exitCode !== null || next.signal !== null),
+        });
+    }
+}
+registerSidecarProcessSpawnFactory((options) => StdioSidecarProtocolClient.spawn(options));