@secure-exec/core 0.0.0-main.bccb3a2

package/dist/cargo.js

@@ -0,0 +1,142 @@
+import { accessSync, constants as fsConstants, existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const CARGO_BINARY_NAME = process.platform === "win32" ? "cargo.exe" : "cargo";
+function hasPathSeparator(candidate) {
+    return candidate.includes("/") || candidate.includes("\\");
+}
+function isExecutableFile(candidate) {
+    try {
+        if (!statSync(candidate).isFile()) {
+            return false;
+        }
+        accessSync(candidate, fsConstants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveExecutableOnPath(binaryName) {
+    const pathEntries = (process.env.PATH ?? "")
+        .split(path.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    for (const entry of pathEntries) {
+        const candidate = path.join(entry, binaryName);
+        if (isExecutableFile(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function resolveExecutableCandidate(candidate) {
+    if (hasPathSeparator(candidate)) {
+        return isExecutableFile(candidate) ? candidate : null;
+    }
+    return resolveExecutableOnPath(candidate);
+}
+function getToolchainCargoFromRustupHome(rustupHome) {
+    const toolchainsDir = path.join(rustupHome, "toolchains");
+    if (!existsSync(toolchainsDir)) {
+        return null;
+    }
+    const settingsPath = path.join(rustupHome, "settings.toml");
+    const orderedToolchains = [];
+    if (existsSync(settingsPath)) {
+        const defaultToolchain = readFileSync(settingsPath, "utf8")
+            .match(/^default_toolchain\s*=\s*"([^"]+)"/m)?.[1]
+            ?.trim();
+        if (defaultToolchain) {
+            orderedToolchains.push(defaultToolchain);
+        }
+    }
+    for (const entry of readdirSync(toolchainsDir)) {
+        if (!orderedToolchains.includes(entry)) {
+            orderedToolchains.push(entry);
+        }
+    }
+    for (const toolchain of orderedToolchains) {
+        const cargoPath = path.join(toolchainsDir, toolchain, "bin", CARGO_BINARY_NAME);
+        if (existsSync(cargoPath)) {
+            return { cargoPath, rustupHome };
+        }
+    }
+    return null;
+}
+function inferRustupHomesFromPath() {
+    const rustupHomes = new Set();
+    const pathEntries = (process.env.PATH ?? "")
+        .split(path.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    for (const entry of pathEntries) {
+        if (path.basename(entry) !== "bin") {
+            continue;
+        }
+        const parentDir = path.dirname(entry);
+        if (existsSync(path.join(parentDir, "toolchains"))) {
+            rustupHomes.add(parentDir);
+        }
+        const siblingRoot = path.dirname(parentDir);
+        try {
+            for (const sibling of readdirSync(siblingRoot, { withFileTypes: true })) {
+                if (!sibling.isDirectory()) {
+                    continue;
+                }
+                const siblingPath = path.join(siblingRoot, sibling.name);
+                if (existsSync(path.join(siblingPath, "toolchains"))) {
+                    rustupHomes.add(siblingPath);
+                }
+            }
+        }
+        catch { }
+    }
+    return [...rustupHomes];
+}
+function ensureToolchainEnvironment(toolchainCargo) {
+    const toolchainBin = path.dirname(toolchainCargo.cargoPath);
+    const currentPathEntries = (process.env.PATH ?? "")
+        .split(path.delimiter)
+        .filter(Boolean);
+    if (!currentPathEntries.includes(toolchainBin)) {
+        process.env.PATH = [toolchainBin, ...currentPathEntries].join(path.delimiter);
+    }
+    if (!process.env.RUSTUP_HOME) {
+        process.env.RUSTUP_HOME = toolchainCargo.rustupHome;
+    }
+    const toolchainName = path.basename(path.dirname(toolchainBin));
+    if (!process.env.RUSTUP_TOOLCHAIN) {
+        process.env.RUSTUP_TOOLCHAIN = toolchainName;
+    }
+}
+export function findCargoBinary() {
+    const explicitCargo = process.env.CARGO?.trim();
+    const rustupHomes = [
+        process.env.RUSTUP_HOME?.trim(),
+        path.join(homedir(), ".rustup"),
+        ...inferRustupHomesFromPath(),
+    ].filter((candidate) => Boolean(candidate));
+    const toolchainCargoCandidates = rustupHomes
+        .map((rustupHome) => getToolchainCargoFromRustupHome(rustupHome))
+        .filter((candidate) => Boolean(candidate));
+    if (toolchainCargoCandidates.length > 0) {
+        ensureToolchainEnvironment(toolchainCargoCandidates[0]);
+    }
+    const candidates = [
+        explicitCargo,
+        ...toolchainCargoCandidates.map((candidate) => candidate.cargoPath),
+        path.join(homedir(), ".cargo", "bin", CARGO_BINARY_NAME),
+        CARGO_BINARY_NAME,
+    ].filter((candidate) => Boolean(candidate));
+    for (const candidate of candidates) {
+        const resolved = resolveExecutableCandidate(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+}
+export function resolveCargoBinary() {
+    return findCargoBinary() ?? CARGO_BINARY_NAME;
+}

package/dist/correlation.d.ts

@@ -0,0 +1,10 @@
+export declare class PendingResponseRegistry<TResponse> {
+    private readonly pending;
+    waitForResponse(requestId: number, options: {
+        timeoutMs: number;
+        timeoutMessage: () => string;
+    }): Promise<TResponse>;
+    resolve(requestId: number, frame: TResponse): boolean;
+    reject(requestId: number, error: Error): boolean;
+    rejectAll(error: Error): void;
+}

package/dist/correlation.js

@@ -0,0 +1,49 @@
+export class PendingResponseRegistry {
+    pending = new Map();
+    waitForResponse(requestId, options) {
+        if (this.pending.has(requestId)) {
+            throw new Error(`response waiter already registered for request ${requestId}`);
+        }
+        return new Promise((resolve, reject) => {
+            const entry = {
+                resolve: (frame) => {
+                    clearTimeout(entry.timer);
+                    this.pending.delete(requestId);
+                    resolve(frame);
+                },
+                reject: (error) => {
+                    clearTimeout(entry.timer);
+                    this.pending.delete(requestId);
+                    reject(error);
+                },
+                timer: setTimeout(() => {
+                    this.pending.delete(requestId);
+                    reject(new Error(options.timeoutMessage()));
+                }, options.timeoutMs),
+            };
+            this.pending.set(requestId, entry);
+        });
+    }
+    resolve(requestId, frame) {
+        const pending = this.pending.get(requestId);
+        if (!pending) {
+            return false;
+        }
+        pending.resolve(frame);
+        return true;
+    }
+    reject(requestId, error) {
+        const pending = this.pending.get(requestId);
+        if (!pending) {
+            return false;
+        }
+        pending.reject(error);
+        return true;
+    }
+    rejectAll(error) {
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}

package/dist/descriptors.d.ts

@@ -0,0 +1,34 @@
+import type * as protocol from "./generated-protocol.js";
+export type LiveSidecarPlacement = {
+    kind: "shared";
+    pool?: string | null;
+} | {
+    kind: "explicit";
+    sidecar_id: string;
+};
+export type MountConfigJsonPrimitive = string | number | boolean | null;
+export type MountConfigJsonValue = MountConfigJsonPrimitive | MountConfigJsonObject | MountConfigJsonValue[];
+export interface MountConfigJsonObject {
+    [key: string]: MountConfigJsonValue;
+}
+export interface NativeMountPluginDescriptor<TConfig extends MountConfigJsonObject = MountConfigJsonObject> {
+    id: string;
+    config?: TConfig;
+}
+export interface LiveMountDescriptor {
+    guest_path: string;
+    read_only: boolean;
+    plugin: NativeMountPluginDescriptor;
+}
+export interface LiveSoftwareDescriptor {
+    package_name: string;
+    root: string;
+}
+export interface LiveProjectedModuleDescriptor {
+    package_name: string;
+    entrypoint: string;
+}
+export declare function toGeneratedSidecarPlacement(placement: LiveSidecarPlacement): protocol.SidecarPlacement;
+export declare function toGeneratedMountDescriptor(descriptor: LiveMountDescriptor): protocol.MountDescriptor;
+export declare function toGeneratedSoftwareDescriptor(descriptor: LiveSoftwareDescriptor): protocol.SoftwareDescriptor;
+export declare function toGeneratedProjectedModuleDescriptor(descriptor: LiveProjectedModuleDescriptor): protocol.ProjectedModuleDescriptor;

package/dist/descriptors.js

@@ -0,0 +1,37 @@
+import { stringifyJsonUtf8 } from "./json.js";
+export function toGeneratedSidecarPlacement(placement) {
+    switch (placement.kind) {
+        case "shared":
+            return {
+                tag: "SidecarPlacementShared",
+                val: { pool: placement.pool ?? null },
+            };
+        case "explicit":
+            return {
+                tag: "SidecarPlacementExplicit",
+                val: { sidecarId: placement.sidecar_id },
+            };
+    }
+}
+export function toGeneratedMountDescriptor(descriptor) {
+    return {
+        guestPath: descriptor.guest_path,
+        readOnly: descriptor.read_only,
+        plugin: {
+            id: descriptor.plugin.id,
+            config: stringifyJsonUtf8(descriptor.plugin.config ?? {}, "mount plugin config"),
+        },
+    };
+}
+export function toGeneratedSoftwareDescriptor(descriptor) {
+    return {
+        packageName: descriptor.package_name,
+        root: descriptor.root,
+    };
+}
+export function toGeneratedProjectedModuleDescriptor(descriptor) {
+    return {
+        packageName: descriptor.package_name,
+        entrypoint: descriptor.entrypoint,
+    };
+}

package/dist/event-buffer.d.ts

@@ -0,0 +1,90 @@
+import { type LiveExtEnvelope } from "./ext.js";
+import type * as protocol from "./generated-protocol.js";
+import { type LiveOwnershipScope } from "./ownership.js";
+export declare const ANY_BUFFERED_EVENT_KEY = "*";
+export type { LiveOwnershipScope } from "./ownership.js";
+export type LiveSidecarEventPayload = {
+    type: "vm_lifecycle";
+    state: "creating" | "ready" | "disposing" | "disposed" | "failed";
+} | {
+    type: "process_output";
+    process_id: string;
+    channel: "stdout" | "stderr";
+    chunk: Uint8Array;
+} | {
+    type: "process_exited";
+    process_id: string;
+    exit_code: number;
+} | {
+    type: "structured";
+    name: string;
+    detail: Record<string, string>;
+} | {
+    type: "ext";
+    envelope: LiveExtEnvelope;
+};
+export interface LiveSidecarEventFrame {
+    ownership: LiveOwnershipScope;
+    payload: LiveSidecarEventPayload;
+}
+export type LiveSidecarEventSelector = {
+    any: true;
+} | {
+    type: "vm_lifecycle";
+    ownership?: LiveOwnershipScope;
+    state?: Extract<LiveSidecarEventPayload, {
+        type: "vm_lifecycle";
+    }>["state"];
+} | {
+    type: "process_output";
+    ownership?: LiveOwnershipScope;
+    processId?: string;
+    channel?: Extract<LiveSidecarEventPayload, {
+        type: "process_output";
+    }>["channel"];
+} | {
+    type: "process_exited";
+    ownership?: LiveOwnershipScope;
+    processId?: string;
+} | {
+    type: "structured";
+    ownership?: LiveOwnershipScope;
+    name?: string;
+    detail?: Record<string, string>;
+};
+export type LiveSidecarBufferedEventRecord<TEvent extends LiveSidecarEventFrame> = {
+    event: TEvent;
+    keys: readonly string[];
+};
+export type LiveSidecarEventWaitMatcher<TEvent extends LiveSidecarEventFrame> = {
+    matches: (event: TEvent) => boolean;
+    bufferKey: string | null;
+};
+export declare class SidecarEventBufferOverflow extends Error {
+    readonly capacity: number;
+    readonly bufferedEvents: number;
+    readonly eventType: LiveSidecarEventPayload["type"];
+    constructor(options: {
+        capacity: number;
+        bufferedEvents: number;
+        eventType: LiveSidecarEventPayload["type"];
+    });
+}
+export declare class SidecarEventBuffer<TEvent extends LiveSidecarEventFrame> {
+    private readonly capacity;
+    private readonly bufferedEvents;
+    private readonly bufferedEventQueues;
+    private nextBufferedEventId;
+    constructor(capacity: number);
+    get size(): number;
+    buffer(event: TEvent): SidecarEventBufferOverflow | null;
+    take(matcher: LiveSidecarEventWaitMatcher<TEvent>): TEvent | null;
+    private takeFromKey;
+    private remove;
+}
+export declare function sidecarSelectorMatchesEvent<TEvent extends LiveSidecarEventFrame>(selector: LiveSidecarEventSelector, event: TEvent): boolean;
+export declare function sidecarSelectorBufferKey(selector: LiveSidecarEventSelector): string | null;
+export declare function normalizeSidecarEventMatcher<TEvent extends LiveSidecarEventFrame>(selector: LiveSidecarEventSelector | ((event: TEvent) => boolean)): LiveSidecarEventWaitMatcher<TEvent>;
+export declare function fromGeneratedEventPayload(payload: protocol.EventPayload): LiveSidecarEventPayload;
+export declare function sidecarEventWaitAbortError(reason: unknown): Error;
+export declare function sidecarEventBufferKeys<TEvent extends LiveSidecarEventFrame>(event: TEvent): string[];

package/dist/event-buffer.js

@@ -0,0 +1,313 @@
+import { fromGeneratedExtEnvelope, } from "./ext.js";
+import { ownershipMatchesSelector, ownershipSelectorKey, } from "./ownership.js";
+import { fromGeneratedStreamChannel, fromGeneratedVmLifecycleState, } from "./protocol-maps.js";
+export const ANY_BUFFERED_EVENT_KEY = "*";
+export class SidecarEventBufferOverflow extends Error {
+    capacity;
+    bufferedEvents;
+    eventType;
+    constructor(options) {
+        super(`sidecar event buffer overflow after ${options.bufferedEvents} queued events (capacity ${options.capacity}) while buffering ${options.eventType}`);
+        this.name = "SidecarEventBufferOverflow";
+        this.capacity = options.capacity;
+        this.bufferedEvents = options.bufferedEvents;
+        this.eventType = options.eventType;
+    }
+}
+export class SidecarEventBuffer {
+    capacity;
+    bufferedEvents = new Map();
+    bufferedEventQueues = new Map();
+    nextBufferedEventId = 1;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    get size() {
+        return this.bufferedEvents.size;
+    }
+    buffer(event) {
+        if (this.bufferedEvents.size >= this.capacity) {
+            return new SidecarEventBufferOverflow({
+                capacity: this.capacity,
+                bufferedEvents: this.bufferedEvents.size,
+                eventType: event.payload.type,
+            });
+        }
+        const eventId = this.nextBufferedEventId++;
+        const keys = sidecarEventBufferKeys(event);
+        this.bufferedEvents.set(eventId, {
+            event,
+            keys,
+        });
+        for (const key of keys) {
+            const queue = this.bufferedEventQueues.get(key);
+            if (queue) {
+                queue.add(eventId);
+                continue;
+            }
+            this.bufferedEventQueues.set(key, new Set([eventId]));
+        }
+        return null;
+    }
+    take(matcher) {
+        if (matcher.bufferKey !== null) {
+            return this.takeFromKey(matcher.bufferKey);
+        }
+        const queue = this.bufferedEventQueues.get(ANY_BUFFERED_EVENT_KEY);
+        if (!queue) {
+            return null;
+        }
+        for (const eventId of queue) {
+            const record = this.bufferedEvents.get(eventId);
+            if (!record) {
+                continue;
+            }
+            if (!matcher.matches(record.event)) {
+                continue;
+            }
+            return this.remove(eventId);
+        }
+        return null;
+    }
+    takeFromKey(key) {
+        const queue = this.bufferedEventQueues.get(key);
+        if (!queue) {
+            return null;
+        }
+        for (const eventId of queue) {
+            const record = this.bufferedEvents.get(eventId);
+            if (!record) {
+                queue.delete(eventId);
+                continue;
+            }
+            return this.remove(eventId);
+        }
+        return null;
+    }
+    remove(eventId) {
+        const record = this.bufferedEvents.get(eventId);
+        if (!record) {
+            return null;
+        }
+        this.bufferedEvents.delete(eventId);
+        for (const key of record.keys) {
+            const queue = this.bufferedEventQueues.get(key);
+            if (!queue) {
+                continue;
+            }
+            queue.delete(eventId);
+            if (queue.size === 0) {
+                this.bufferedEventQueues.delete(key);
+            }
+        }
+        return record.event;
+    }
+}
+function buildBufferKey(type, options) {
+    const parts = [`type:${type}`];
+    if (options?.ownership) {
+        parts.push(`ownership:${ownershipSelectorKey(options.ownership)}`);
+    }
+    if (options?.state) {
+        parts.push(`state:${options.state}`);
+    }
+    if (options?.processId) {
+        parts.push(`process:${options.processId}`);
+    }
+    if (options?.channel) {
+        parts.push(`channel:${options.channel}`);
+    }
+    if (options?.name) {
+        parts.push(`name:${options.name}`);
+    }
+    return parts.join("|");
+}
+export function sidecarSelectorMatchesEvent(selector, event) {
+    if ("any" in selector) {
+        return true;
+    }
+    if (event.payload.type !== selector.type) {
+        return false;
+    }
+    if (!ownershipMatchesSelector(selector.ownership, event.ownership)) {
+        return false;
+    }
+    switch (selector.type) {
+        case "vm_lifecycle": {
+            const payload = event.payload;
+            return selector.state === undefined || payload.state === selector.state;
+        }
+        case "process_output": {
+            const payload = event.payload;
+            return ((selector.processId === undefined ||
+                payload.process_id === selector.processId) &&
+                (selector.channel === undefined || payload.channel === selector.channel));
+        }
+        case "process_exited": {
+            const payload = event.payload;
+            return (selector.processId === undefined ||
+                payload.process_id === selector.processId);
+        }
+        case "structured": {
+            const payload = event.payload;
+            if (selector.name !== undefined && payload.name !== selector.name) {
+                return false;
+            }
+            if (!selector.detail) {
+                return true;
+            }
+            for (const [key, value] of Object.entries(selector.detail)) {
+                if (payload.detail[key] !== value) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}
+export function sidecarSelectorBufferKey(selector) {
+    if ("any" in selector) {
+        return ANY_BUFFERED_EVENT_KEY;
+    }
+    switch (selector.type) {
+        case "vm_lifecycle":
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                state: selector.state,
+            });
+        case "process_output":
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                processId: selector.processId,
+                channel: selector.channel,
+            });
+        case "process_exited":
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                processId: selector.processId,
+            });
+        case "structured":
+            if (selector.detail) {
+                return null;
+            }
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                name: selector.name,
+            });
+    }
+}
+export function normalizeSidecarEventMatcher(selector) {
+    if (typeof selector === "function") {
+        return {
+            matches: selector,
+            bufferKey: null,
+        };
+    }
+    return {
+        matches: (event) => sidecarSelectorMatchesEvent(selector, event),
+        bufferKey: sidecarSelectorBufferKey(selector),
+    };
+}
+export function fromGeneratedEventPayload(payload) {
+    switch (payload.tag) {
+        case "VmLifecycleEvent":
+            return {
+                type: "vm_lifecycle",
+                state: fromGeneratedVmLifecycleState(payload.val.state),
+            };
+        case "ProcessOutputEvent":
+            return {
+                type: "process_output",
+                process_id: payload.val.processId,
+                channel: fromGeneratedStreamChannel(payload.val.channel),
+                chunk: Buffer.from(payload.val.chunk),
+            };
+        case "ProcessExitedEvent":
+            return {
+                type: "process_exited",
+                process_id: payload.val.processId,
+                exit_code: payload.val.exitCode,
+            };
+        case "StructuredEvent":
+            return {
+                type: "structured",
+                name: payload.val.name,
+                detail: Object.fromEntries(payload.val.detail),
+            };
+        case "ExtEnvelope":
+            return {
+                type: "ext",
+                envelope: fromGeneratedExtEnvelope(payload.val),
+            };
+    }
+}
+export function sidecarEventWaitAbortError(reason) {
+    return reason instanceof Error
+        ? reason
+        : new Error(reason ? String(reason) : "sidecar event wait aborted");
+}
+export function sidecarEventBufferKeys(event) {
+    const owner = event.ownership;
+    const keys = new Set([
+        ANY_BUFFERED_EVENT_KEY,
+        buildBufferKey(event.payload.type),
+        buildBufferKey(event.payload.type, { ownership: owner }),
+    ]);
+    switch (event.payload.type) {
+        case "vm_lifecycle":
+            keys.add(buildBufferKey(event.payload.type, {
+                state: event.payload.state,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                state: event.payload.state,
+            }));
+            break;
+        case "process_output":
+            keys.add(buildBufferKey(event.payload.type, {
+                processId: event.payload.process_id,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                channel: event.payload.channel,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                processId: event.payload.process_id,
+                channel: event.payload.channel,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                processId: event.payload.process_id,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                channel: event.payload.channel,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                processId: event.payload.process_id,
+                channel: event.payload.channel,
+            }));
+            break;
+        case "process_exited":
+            keys.add(buildBufferKey(event.payload.type, {
+                processId: event.payload.process_id,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                processId: event.payload.process_id,
+            }));
+            break;
+        case "structured":
+            keys.add(buildBufferKey(event.payload.type, {
+                name: event.payload.name,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                name: event.payload.name,
+            }));
+            break;
+        case "ext":
+            break;
+    }
+    return [...keys];
+}

package/dist/ext.d.ts

@@ -0,0 +1,7 @@
+import type * as sidecarProtocol from "./generated-protocol.js";
+export interface LiveExtEnvelope {
+    namespace: string;
+    payload: Uint8Array;
+}
+export declare function toGeneratedExtEnvelope(envelope: LiveExtEnvelope): sidecarProtocol.ExtEnvelope;
+export declare function fromGeneratedExtEnvelope(envelope: sidecarProtocol.ExtEnvelope): LiveExtEnvelope;