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

package/dist/request-payloads.js

@@ -0,0 +1,241 @@
+import { toExactArrayBuffer } from "./bytes.js";
+import { toGeneratedMountDescriptor, toGeneratedProjectedModuleDescriptor, toGeneratedSidecarPlacement, toGeneratedSoftwareDescriptor, } from "./descriptors.js";
+import { toGeneratedExtEnvelope } from "./ext.js";
+import { toGeneratedRootFilesystemEntry, } from "./filesystem.js";
+import { stringifyJsonUtf8 } from "./json.js";
+import { toGeneratedPermissionsPolicy, } from "./permissions.js";
+import { toGeneratedDisposeReason, toGeneratedFilesystemOperation, toGeneratedGuestFilesystemOperation, toGeneratedGuestRuntimeKind, toGeneratedRootFilesystemEntryEncoding, toGeneratedRootFilesystemMode, toGeneratedWasmPermissionTier, } from "./protocol-maps.js";
+export function toGeneratedRequestPayload(payload) {
+    switch (payload.type) {
+        case "authenticate":
+            return {
+                tag: "AuthenticateRequest",
+                val: {
+                    clientName: payload.client_name,
+                    authToken: payload.auth_token,
+                    protocolVersion: payload.protocol_version,
+                    bridgeVersion: payload.bridge_version,
+                },
+            };
+        case "open_session":
+            return {
+                tag: "OpenSessionRequest",
+                val: {
+                    placement: toGeneratedSidecarPlacement(payload.placement),
+                    metadata: new Map(Object.entries(payload.metadata ?? {})),
+                },
+            };
+        case "create_vm":
+            return {
+                tag: "CreateVmRequest",
+                val: {
+                    runtime: toGeneratedGuestRuntimeKind(payload.runtime),
+                    config: stringifyJsonUtf8(payload.config, "create VM config"),
+                },
+            };
+        case "dispose_vm":
+            return {
+                tag: "DisposeVmRequest",
+                val: { reason: toGeneratedDisposeReason(payload.reason) },
+            };
+        case "bootstrap_root_filesystem":
+            return {
+                tag: "BootstrapRootFilesystemRequest",
+                val: { entries: payload.entries.map(toGeneratedRootFilesystemEntry) },
+            };
+        case "configure_vm":
+            return {
+                tag: "ConfigureVmRequest",
+                val: {
+                    mounts: (payload.mounts ?? []).map(toGeneratedMountDescriptor),
+                    software: (payload.software ?? []).map(toGeneratedSoftwareDescriptor),
+                    permissions: toGeneratedPermissionsPolicy(payload.permissions),
+                    moduleAccessCwd: payload.module_access_cwd ?? null,
+                    instructions: payload.instructions ?? [],
+                    projectedModules: (payload.projected_modules ?? []).map(toGeneratedProjectedModuleDescriptor),
+                    commandPermissions: new Map(Object.entries(payload.command_permissions ?? {}).map(([name, tier]) => [name, toGeneratedWasmPermissionTier(tier)])),
+                    loopbackExemptPorts: new Uint16Array(payload.loopback_exempt_ports ?? []),
+                },
+            };
+        case "register_host_callbacks":
+            return {
+                tag: "RegisterHostCallbacksRequest",
+                val: {
+                    name: payload.name,
+                    description: payload.description,
+                    commandAliases: payload.command_aliases ?? [],
+                    registryCommandAliases: payload.registry_command_aliases ?? [],
+                    callbacks: new Map(Object.entries(payload.callbacks).map(([name, callback]) => [
+                        name,
+                        {
+                            description: callback.description,
+                            inputSchema: stringifyJsonUtf8(callback.input_schema, "register_host_callbacks.callback.input_schema"),
+                            timeoutMs: callback.timeout_ms === undefined
+                                ? null
+                                : BigInt(callback.timeout_ms),
+                            examples: (callback.examples ?? []).map((example) => ({
+                                description: example.description,
+                                input: stringifyJsonUtf8(example.input, "register_host_callbacks.callback.example.input"),
+                            })),
+                        },
+                    ])),
+                },
+            };
+        case "create_layer":
+            return { tag: "CreateLayerRequest", val: null };
+        case "seal_layer":
+            return { tag: "SealLayerRequest", val: { layerId: payload.layer_id } };
+        case "import_snapshot":
+            return {
+                tag: "ImportSnapshotRequest",
+                val: { entries: payload.entries.map(toGeneratedRootFilesystemEntry) },
+            };
+        case "export_snapshot":
+            return {
+                tag: "ExportSnapshotRequest",
+                val: { layerId: payload.layer_id },
+            };
+        case "create_overlay":
+            return {
+                tag: "CreateOverlayRequest",
+                val: {
+                    mode: toGeneratedRootFilesystemMode(payload.mode ?? "ephemeral"),
+                    upperLayerId: payload.upper_layer_id ?? null,
+                    lowerLayerIds: payload.lower_layer_ids ?? [],
+                },
+            };
+        case "guest_filesystem_call":
+            return {
+                tag: "GuestFilesystemCallRequest",
+                val: {
+                    operation: toGeneratedGuestFilesystemOperation(payload.operation),
+                    path: payload.path,
+                    destinationPath: payload.destination_path ?? null,
+                    target: payload.target ?? null,
+                    content: payload.content ?? null,
+                    encoding: payload.encoding === undefined
+                        ? null
+                        : toGeneratedRootFilesystemEntryEncoding(payload.encoding),
+                    recursive: payload.recursive ?? false,
+                    mode: payload.mode ?? null,
+                    uid: payload.uid ?? null,
+                    gid: payload.gid ?? null,
+                    atimeMs: toGeneratedOptionalU64(payload.atime_ms),
+                    mtimeMs: toGeneratedOptionalU64(payload.mtime_ms),
+                    len: toGeneratedOptionalU64(payload.len),
+                    offset: toGeneratedOptionalU64(payload.offset),
+                },
+            };
+        case "guest_kernel_call":
+            return {
+                tag: "GuestKernelCallRequest",
+                val: {
+                    executionId: payload.execution_id,
+                    operation: payload.operation,
+                    payload: payload.payload,
+                },
+            };
+        case "snapshot_root_filesystem":
+            return { tag: "SnapshotRootFilesystemRequest", val: null };
+        case "execute":
+            return {
+                tag: "ExecuteRequest",
+                val: {
+                    processId: payload.process_id,
+                    command: payload.command ?? null,
+                    runtime: payload.runtime === undefined
+                        ? null
+                        : toGeneratedGuestRuntimeKind(payload.runtime),
+                    entrypoint: payload.entrypoint ?? null,
+                    args: payload.args ?? [],
+                    env: new Map(Object.entries(payload.env ?? {})),
+                    cwd: payload.cwd ?? null,
+                    wasmPermissionTier: payload.wasm_permission_tier === undefined
+                        ? null
+                        : toGeneratedWasmPermissionTier(payload.wasm_permission_tier),
+                },
+            };
+        case "write_stdin":
+            return {
+                tag: "WriteStdinRequest",
+                val: {
+                    processId: payload.process_id,
+                    chunk: toExactArrayBuffer(payload.chunk),
+                },
+            };
+        case "close_stdin":
+            return {
+                tag: "CloseStdinRequest",
+                val: { processId: payload.process_id },
+            };
+        case "kill_process":
+            return {
+                tag: "KillProcessRequest",
+                val: { processId: payload.process_id, signal: payload.signal },
+            };
+        case "get_process_snapshot":
+            return { tag: "GetProcessSnapshotRequest", val: null };
+        case "find_listener":
+            return {
+                tag: "FindListenerRequest",
+                val: {
+                    host: payload.host ?? null,
+                    port: payload.port ?? null,
+                    path: payload.path ?? null,
+                },
+            };
+        case "find_bound_udp":
+            return {
+                tag: "FindBoundUdpRequest",
+                val: { host: payload.host ?? null, port: payload.port ?? null },
+            };
+        case "vm_fetch":
+            return {
+                tag: "VmFetchRequest",
+                val: {
+                    port: payload.port,
+                    method: payload.method,
+                    path: payload.path,
+                    headersJson: payload.headers_json,
+                    body: payload.body ?? null,
+                },
+            };
+        case "get_signal_state":
+            return {
+                tag: "GetSignalStateRequest",
+                val: { processId: payload.process_id },
+            };
+        case "get_zombie_timer_count":
+            return { tag: "GetZombieTimerCountRequest", val: null };
+        case "host_filesystem_call":
+            return {
+                tag: "HostFilesystemCallRequest",
+                val: {
+                    operation: toGeneratedFilesystemOperation(payload.operation),
+                    path: payload.path,
+                    payloadSizeBytes: BigInt(payload.payload_size_bytes),
+                },
+            };
+        case "persistence_load":
+            return {
+                tag: "PersistenceLoadRequest",
+                val: { key: payload.key },
+            };
+        case "persistence_flush":
+            return {
+                tag: "PersistenceFlushRequest",
+                val: {
+                    key: payload.key,
+                    payloadSizeBytes: BigInt(payload.payload_size_bytes),
+                },
+            };
+        case "ext":
+            return {
+                tag: "ExtEnvelope",
+                val: toGeneratedExtEnvelope(payload.envelope),
+            };
+    }
+}
+function toGeneratedOptionalU64(value) {
+    return value === undefined ? null : BigInt(value);
+}

package/dist/response-payloads.d.ts

@@ -0,0 +1,124 @@
+import { type LiveRootFilesystemEntry, type LiveRootFilesystemEntryEncoding } from "./filesystem.js";
+import { type LiveExtEnvelope } from "./ext.js";
+import type * as protocol from "./generated-protocol.js";
+import { type LiveFilesystemOperation, type LiveGuestFilesystemOperation, type LiveSignalDispositionAction } from "./protocol-maps.js";
+import { type LiveGuestFilesystemStat, type LiveProcessSnapshotEntry, type LiveSocketStateEntry } from "./state.js";
+export interface LiveSignalHandlerRegistration {
+    action: LiveSignalDispositionAction;
+    mask: number[];
+    flags: number;
+}
+export type LiveResponsePayload = {
+    type: "authenticated";
+    sidecar_id: string;
+    connection_id: string;
+    max_frame_bytes: number;
+} | {
+    type: "session_opened";
+    session_id: string;
+    owner_connection_id: string;
+} | {
+    type: "vm_created";
+    vm_id: string;
+} | {
+    type: "vm_configured";
+    applied_mounts: number;
+    applied_software: number;
+} | {
+    type: "host_callbacks_registered";
+    registration: string;
+    command_count: number;
+} | {
+    type: "layer_created";
+    layer_id: string;
+} | {
+    type: "layer_sealed";
+    layer_id: string;
+} | {
+    type: "snapshot_imported";
+    layer_id: string;
+} | {
+    type: "snapshot_exported";
+    layer_id: string;
+    entries: LiveRootFilesystemEntry[];
+} | {
+    type: "overlay_created";
+    layer_id: string;
+} | {
+    type: "root_filesystem_bootstrapped";
+    entry_count: number;
+} | {
+    type: "guest_filesystem_result";
+    operation: LiveGuestFilesystemOperation;
+    path: string;
+    content?: string;
+    encoding?: LiveRootFilesystemEntryEncoding;
+    entries?: string[];
+    stat?: LiveGuestFilesystemStat;
+    exists?: boolean;
+    target?: string;
+} | {
+    type: "guest_kernel_result";
+    payload: ArrayBuffer;
+} | {
+    type: "root_filesystem_snapshot";
+    entries: LiveRootFilesystemEntry[];
+} | {
+    type: "vm_disposed";
+    vm_id: string;
+} | {
+    type: "process_started";
+    process_id: string;
+    pid?: number;
+} | {
+    type: "stdin_written";
+    process_id: string;
+    accepted_bytes: number;
+} | {
+    type: "stdin_closed";
+    process_id: string;
+} | {
+    type: "process_killed";
+    process_id: string;
+} | {
+    type: "process_snapshot";
+    processes: LiveProcessSnapshotEntry[];
+} | {
+    type: "listener_snapshot";
+    listener?: LiveSocketStateEntry;
+} | {
+    type: "bound_udp_snapshot";
+    socket?: LiveSocketStateEntry;
+} | {
+    type: "vm_fetch_result";
+    response_json: string;
+} | {
+    type: "signal_state";
+    process_id: string;
+    handlers: Record<string, LiveSignalHandlerRegistration>;
+} | {
+    type: "zombie_timer_count";
+    count: number;
+} | {
+    type: "filesystem_result";
+    operation: LiveFilesystemOperation;
+    status: string;
+    payload_size_bytes: number;
+} | {
+    type: "persistence_state";
+    key: string;
+    found: boolean;
+    payload_size_bytes: number;
+} | {
+    type: "persistence_flushed";
+    key: string;
+    committed_bytes: number;
+} | {
+    type: "rejected";
+    code: string;
+    message: string;
+} | {
+    type: "ext_result";
+    envelope: LiveExtEnvelope;
+};
+export declare function fromGeneratedResponsePayload(payload: protocol.ResponsePayload): LiveResponsePayload;

package/dist/response-payloads.js

@@ -0,0 +1,180 @@
+import { fromGeneratedRootFilesystemEntry, } from "./filesystem.js";
+import { fromGeneratedExtEnvelope } from "./ext.js";
+import { bigIntToSafeNumber } from "./numbers.js";
+import { fromGeneratedFilesystemOperation, fromGeneratedGuestFilesystemOperation, fromGeneratedRootFilesystemEntryEncoding, fromGeneratedSignalDispositionAction, } from "./protocol-maps.js";
+import { fromGeneratedGuestFilesystemStat, fromGeneratedProcessSnapshotEntry, fromGeneratedSocketStateEntry, } from "./state.js";
+export function fromGeneratedResponsePayload(payload) {
+    switch (payload.tag) {
+        case "AuthenticatedResponse":
+            return {
+                type: "authenticated",
+                sidecar_id: payload.val.sidecarId,
+                connection_id: payload.val.connectionId,
+                max_frame_bytes: payload.val.maxFrameBytes,
+            };
+        case "SessionOpenedResponse":
+            return {
+                type: "session_opened",
+                session_id: payload.val.sessionId,
+                owner_connection_id: payload.val.ownerConnectionId,
+            };
+        case "VmCreatedResponse":
+            return { type: "vm_created", vm_id: payload.val.vmId };
+        case "VmDisposedResponse":
+            return { type: "vm_disposed", vm_id: payload.val.vmId };
+        case "RootFilesystemBootstrappedResponse":
+            return {
+                type: "root_filesystem_bootstrapped",
+                entry_count: payload.val.entryCount,
+            };
+        case "VmConfiguredResponse":
+            return {
+                type: "vm_configured",
+                applied_mounts: payload.val.appliedMounts,
+                applied_software: payload.val.appliedSoftware,
+            };
+        case "HostCallbacksRegisteredResponse":
+            return {
+                type: "host_callbacks_registered",
+                registration: payload.val.registration,
+                command_count: payload.val.commandCount,
+            };
+        case "LayerCreatedResponse":
+            return { type: "layer_created", layer_id: payload.val.layerId };
+        case "LayerSealedResponse":
+            return { type: "layer_sealed", layer_id: payload.val.layerId };
+        case "SnapshotImportedResponse":
+            return { type: "snapshot_imported", layer_id: payload.val.layerId };
+        case "SnapshotExportedResponse":
+            return {
+                type: "snapshot_exported",
+                layer_id: payload.val.layerId,
+                entries: payload.val.entries.map(fromGeneratedRootFilesystemEntry),
+            };
+        case "OverlayCreatedResponse":
+            return { type: "overlay_created", layer_id: payload.val.layerId };
+        case "GuestFilesystemResultResponse":
+            return {
+                type: "guest_filesystem_result",
+                operation: fromGeneratedGuestFilesystemOperation(payload.val.operation),
+                path: payload.val.path,
+                ...(payload.val.content !== null
+                    ? { content: payload.val.content }
+                    : {}),
+                ...(payload.val.encoding !== null
+                    ? {
+                        encoding: fromGeneratedRootFilesystemEntryEncoding(payload.val.encoding),
+                    }
+                    : {}),
+                ...(payload.val.entries !== null
+                    ? { entries: [...payload.val.entries] }
+                    : {}),
+                ...(payload.val.stat !== null
+                    ? { stat: fromGeneratedGuestFilesystemStat(payload.val.stat) }
+                    : {}),
+                ...(payload.val.exists !== null ? { exists: payload.val.exists } : {}),
+                ...(payload.val.target !== null ? { target: payload.val.target } : {}),
+            };
+        case "GuestKernelResultResponse":
+            return {
+                type: "guest_kernel_result",
+                payload: payload.val.payload,
+            };
+        case "RootFilesystemSnapshotResponse":
+            return {
+                type: "root_filesystem_snapshot",
+                entries: payload.val.entries.map(fromGeneratedRootFilesystemEntry),
+            };
+        case "ProcessStartedResponse":
+            return {
+                type: "process_started",
+                process_id: payload.val.processId,
+                ...(payload.val.pid !== null ? { pid: payload.val.pid } : {}),
+            };
+        case "StdinWrittenResponse":
+            return {
+                type: "stdin_written",
+                process_id: payload.val.processId,
+                accepted_bytes: bigIntToSafeNumber(payload.val.acceptedBytes, "stdin_written.accepted_bytes"),
+            };
+        case "StdinClosedResponse":
+            return { type: "stdin_closed", process_id: payload.val.processId };
+        case "ProcessKilledResponse":
+            return { type: "process_killed", process_id: payload.val.processId };
+        case "ProcessSnapshotResponse":
+            return {
+                type: "process_snapshot",
+                processes: payload.val.processes.map(fromGeneratedProcessSnapshotEntry),
+            };
+        case "ListenerSnapshotResponse":
+            return {
+                type: "listener_snapshot",
+                ...(payload.val.listener !== null
+                    ? { listener: fromGeneratedSocketStateEntry(payload.val.listener) }
+                    : {}),
+            };
+        case "BoundUdpSnapshotResponse":
+            return {
+                type: "bound_udp_snapshot",
+                ...(payload.val.socket !== null
+                    ? { socket: fromGeneratedSocketStateEntry(payload.val.socket) }
+                    : {}),
+            };
+        case "SignalStateResponse":
+            return {
+                type: "signal_state",
+                process_id: payload.val.processId,
+                handlers: Object.fromEntries([...payload.val.handlers].map(([signal, registration]) => [
+                    String(signal),
+                    {
+                        action: fromGeneratedSignalDispositionAction(registration.action),
+                        mask: Array.from(registration.mask),
+                        flags: registration.flags,
+                    },
+                ])),
+            };
+        case "ZombieTimerCountResponse":
+            return {
+                type: "zombie_timer_count",
+                count: bigIntToSafeNumber(payload.val.count, "zombie_timer_count.count"),
+            };
+        case "FilesystemResultResponse":
+            return {
+                type: "filesystem_result",
+                operation: fromGeneratedFilesystemOperation(payload.val.operation),
+                status: payload.val.status,
+                payload_size_bytes: bigIntToSafeNumber(payload.val.payloadSizeBytes, "filesystem_result.payload_size_bytes"),
+            };
+        case "PermissionDecisionResponse":
+            throw new Error("unsupported bare response payload tag: permission_decision");
+        case "PersistenceStateResponse":
+            return {
+                type: "persistence_state",
+                key: payload.val.key,
+                found: payload.val.found,
+                payload_size_bytes: bigIntToSafeNumber(payload.val.payloadSizeBytes, "persistence_state.payload_size_bytes"),
+            };
+        case "PersistenceFlushedResponse":
+            return {
+                type: "persistence_flushed",
+                key: payload.val.key,
+                committed_bytes: bigIntToSafeNumber(payload.val.committedBytes, "persistence_flushed.committed_bytes"),
+            };
+        case "RejectedResponse":
+            return {
+                type: "rejected",
+                code: payload.val.code,
+                message: payload.val.message,
+            };
+        case "VmFetchResponse":
+            return {
+                type: "vm_fetch_result",
+                response_json: payload.val.responseJson,
+            };
+        case "ExtEnvelope":
+            return {
+                type: "ext_result",
+                envelope: fromGeneratedExtEnvelope(payload.val),
+            };
+    }
+}

package/dist/sidecar-client.d.ts

@@ -0,0 +1,17 @@
+import type { LiveSidecarEventSelector } from "./event-buffer.js";
+import type { LiveOwnershipScope } from "./ownership.js";
+import type { LiveEventFrame, LiveResponseFrame, LiveSidecarRequestHandler } from "./protocol-frames.js";
+import type { LiveRequestPayload } from "./request-payloads.js";
+export interface SidecarProcessTransport {
+    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>;
+    failPermanently(error: Error): void;
+    dispose(): Promise<void>;
+}

package/dist/sidecar-client.js

@@ -0,0 +1 @@
+export {};

package/dist/sidecar-errors.d.ts

@@ -0,0 +1,15 @@
+export declare class SidecarProcessExited extends Error {
+    readonly exitCode: number | null;
+    readonly signal: string | null;
+    readonly stderr: string;
+    constructor(options: {
+        exitCode: number | null;
+        signal: string | null;
+        stderr: string;
+    });
+}
+export declare class SidecarProcessError extends Error {
+    readonly childError: Error;
+    readonly stderr: string;
+    constructor(error: Error, stderr: string);
+}

package/dist/sidecar-errors.js

@@ -0,0 +1,30 @@
+function formatSidecarStderrSuffix(stderr) {
+    return stderr ? `\nstderr:\n${stderr}` : "";
+}
+export class SidecarProcessExited extends Error {
+    exitCode;
+    signal;
+    stderr;
+    constructor(options) {
+        const reason = options.signal !== null
+            ? `signal ${options.signal}`
+            : options.exitCode !== null
+                ? `code ${options.exitCode}`
+                : "disconnect";
+        super(`sidecar process exited with ${reason}${formatSidecarStderrSuffix(options.stderr)}`);
+        this.name = "SidecarProcessExited";
+        this.exitCode = options.exitCode;
+        this.signal = options.signal;
+        this.stderr = options.stderr;
+    }
+}
+export class SidecarProcessError extends Error {
+    childError;
+    stderr;
+    constructor(error, stderr) {
+        super(`sidecar process error: ${error.message}${formatSidecarStderrSuffix(stderr)}`);
+        this.name = "SidecarProcessError";
+        this.childError = error;
+        this.stderr = stderr;
+    }
+}