@rivet-dev/agentos-core 0.0.0-agentos-dylib-plugin.473700e

package/dist/sidecar/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/sidecar/native-process-client.d.ts

@@ -0,0 +1,2 @@
+export { NATIVE_SIDECAR_FRAME_TIMEOUT_MS, NativeSidecarProcessClient as SidecarProcess, SidecarEventBufferOverflow, SidecarProcessError, SidecarProcessExited, } from "@secure-exec/core/sidecar-client";
+export type { AuthenticatedSession, CreatedVm, ExtEnvelope, GuestFilesystemStat, NativeSidecarSpawnOptions as SidecarSpawnOptions, RootFilesystemEntry, RootFilesystemLowerDescriptor, SidecarEventSelector, SidecarFsPermissionRule, SidecarMountDescriptor, SidecarMountPluginDescriptor, SidecarPatternPermissionRule, SidecarPermissionMode, SidecarPermissionScope, SidecarPermissionsPolicy, SidecarProcessSnapshotEntry, SidecarProjectedModuleDescriptor, SidecarRegisteredHostCallbackDefinition, SidecarRegisteredHostCallbackExample, SidecarRequestFrame, SidecarRequestHandler, SidecarRequestPayload, SidecarResponseFrame, SidecarResponsePayload, SidecarRulePermissions, SidecarSessionState, SidecarSignalHandlerRegistration, SidecarSignalState, SidecarSocketStateEntry, SidecarSoftwareDescriptor, SidecarZombieTimerCount, } from "@secure-exec/core/sidecar-client";

package/dist/sidecar/native-process-client.js

@@ -0,0 +1 @@
+export { NATIVE_SIDECAR_FRAME_TIMEOUT_MS, NativeSidecarProcessClient as SidecarProcess, SidecarEventBufferOverflow, SidecarProcessError, SidecarProcessExited, } from "@secure-exec/core/sidecar-client";

package/dist/sidecar/permissions.d.ts

@@ -0,0 +1,3 @@
+import type { PermissionsPolicy } from "@secure-exec/core/vm-config";
+import type { Permissions } from "../runtime-compat.js";
+export declare function serializePermissionsForSidecar(permissions?: Permissions): PermissionsPolicy;

package/dist/sidecar/permissions.js

@@ -0,0 +1,54 @@
+const ALL_OPERATIONS = ["*"];
+const ALL_RESOURCES = ["**"];
+function serializeFilesystemScope(scope) {
+    return {
+        ...(scope.default === undefined ? {} : { default: scope.default }),
+        rules: scope.rules.map((rule) => ({
+            ...rule,
+            operations: rule.operations ?? ALL_OPERATIONS,
+            paths: rule.paths ?? ALL_RESOURCES,
+        })),
+    };
+}
+function serializePatternScope(scope) {
+    return {
+        ...(scope.default === undefined ? {} : { default: scope.default }),
+        rules: scope.rules.map((rule) => ({
+            ...rule,
+            operations: rule.operations ?? ALL_OPERATIONS,
+            patterns: rule.patterns ?? ALL_RESOURCES,
+        })),
+    };
+}
+export function serializePermissionsForSidecar(permissions) {
+    if (!permissions) {
+        return {
+            fs: "deny",
+            network: "deny",
+            childProcess: "deny",
+            process: "deny",
+            env: "deny",
+            tool: "deny",
+        };
+    }
+    return {
+        fs: typeof permissions.fs === "string" || !permissions.fs
+            ? permissions.fs
+            : serializeFilesystemScope(permissions.fs),
+        network: typeof permissions.network === "string" || !permissions.network
+            ? permissions.network
+            : serializePatternScope(permissions.network),
+        childProcess: typeof permissions.childProcess === "string" || !permissions.childProcess
+            ? permissions.childProcess
+            : serializePatternScope(permissions.childProcess),
+        process: typeof permissions.process === "string" || !permissions.process
+            ? permissions.process
+            : serializePatternScope(permissions.process),
+        env: typeof permissions.env === "string" || !permissions.env
+            ? permissions.env
+            : serializePatternScope(permissions.env),
+        tool: typeof permissions.tool === "string" || !permissions.tool
+            ? permissions.tool
+            : serializePatternScope(permissions.tool),
+    };
+}

package/dist/sidecar/process.d.ts

@@ -0,0 +1,6 @@
+import { SidecarProcess, type SidecarSpawnOptions } from "./native-process-client.js";
+export interface AgentOsSidecarProcessHandle {
+    client: SidecarProcess;
+    dispose(): Promise<void>;
+}
+export declare function spawnAgentOsSidecar(options: SidecarSpawnOptions): AgentOsSidecarProcessHandle;

package/dist/sidecar/process.js

@@ -0,0 +1,8 @@
+import { SidecarProcess, } from "./native-process-client.js";
+export function spawnAgentOsSidecar(options) {
+    const client = SidecarProcess.spawn(options);
+    return {
+        client,
+        dispose: () => client.dispose(),
+    };
+}

package/dist/sidecar/rpc-client.d.ts

@@ -0,0 +1,244 @@
+import type { RootFilesystemConfig as VmConfigRootFilesystemConfig, RootFilesystemEntry as VmConfigRootFilesystemEntry, RootFilesystemLowerDescriptor as VmConfigRootFilesystemLowerDescriptor } from "@secure-exec/core/vm-config";
+import type { NativeMountConfig, PlainMountConfig, RootFilesystemConfig } from "../agent-os.js";
+import type { RootSnapshotExport } from "../layers.js";
+import type { ConnectTerminalOptions, KernelExecOptions, KernelExecResult, KernelSpawnOptions, ManagedProcess, OpenShellOptions, ProcessInfo, ShellHandle, VirtualFileSystem, VirtualStat } from "../runtime-compat.js";
+import type { AuthenticatedSession, CreatedVm, SidecarProcess, SidecarSignalHandlerRegistration } from "./native-process-client.js";
+export declare function toSidecarSignalName(signal: number): string;
+export interface LocalCompatMount {
+    path: string;
+    fs: VirtualFileSystem;
+    readOnly: boolean;
+}
+interface KernelSocketSnapshot {
+    processId: string;
+    host?: string;
+    port?: number;
+    path?: string;
+}
+interface KernelSignalState {
+    handlers: Map<number, {
+        action: SidecarSignalHandlerRegistration["action"];
+        mask: Set<number>;
+        flags: number;
+    }>;
+}
+interface NativeSidecarKernelProxyOptions {
+    client: SidecarProcess;
+    session: AuthenticatedSession;
+    vm: CreatedVm;
+    env: Record<string, string>;
+    cwd: string;
+    defaultExecCwd?: string;
+    localMounts: LocalCompatMount[];
+    commandGuestPaths: ReadonlyMap<string, string>;
+    onWasmCommandResolved?: (command: string) => void;
+    onDispose?: () => Promise<void>;
+}
+export declare class NativeSidecarKernelProxy {
+    readonly env: Record<string, string>;
+    readonly cwd: string;
+    readonly commands: ReadonlyMap<string, string>;
+    readonly vfs: VirtualFileSystem;
+    readonly processes: Map<number, ProcessInfo>;
+    private readonly defaultExecCwd;
+    private readonly client;
+    private readonly session;
+    private readonly vm;
+    private readonly localMounts;
+    private readonly commandDrivers;
+    private readonly onWasmCommandResolved;
+    private readonly onDispose;
+    private readonly trackedProcesses;
+    private readonly trackedProcessesById;
+    private readonly listenerLookups;
+    private readonly boundUdpLookups;
+    private readonly signalStates;
+    private readonly signalRefreshes;
+    private sidecarProcessSnapshot;
+    private processSnapshotRefresh;
+    private readonly observedProcessStartTimes;
+    private readonly rootView;
+    private zombieTimerCountValue;
+    private zombieTimerCountRefresh;
+    private disposed;
+    private pumpError;
+    private nextSyntheticPid;
+    private readonly eventPumpAbortController;
+    private readonly eventPump;
+    constructor(options: NativeSidecarKernelProxyOptions);
+    createRootView(): VirtualFileSystem;
+    get zombieTimerCount(): number;
+    registerCommandGuestPaths(commandGuestPaths: ReadonlyMap<string, string>): void;
+    dispose(): Promise<void>;
+    exec(command: string, options?: KernelExecOptions): Promise<KernelExecResult>;
+    spawn(command: string, args: string[], options?: KernelSpawnOptions): ManagedProcess;
+    openShell(options?: OpenShellOptions): ShellHandle;
+    connectTerminal(options?: ConnectTerminalOptions): Promise<number>;
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    mkdir(path: string, recursive?: boolean): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<VirtualStat>;
+    readdir(path: string): Promise<string[]>;
+    removeFile(path: string): Promise<void>;
+    removeDir(path: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    mountFs(path: string, driver: VirtualFileSystem, options?: {
+        readOnly?: boolean;
+    }): void;
+    unmountFs(path: string): void;
+    snapshotProcesses(): ProcessInfo[];
+    findListener(request: {
+        host?: string;
+        port?: number;
+        path?: string;
+    }): KernelSocketSnapshot | null;
+    findBoundUdp(request: {
+        host?: string;
+        port?: number;
+    }): KernelSocketSnapshot | null;
+    getSignalState(pid: number): KernelSignalState;
+    private refreshSocketLookup;
+    private refreshSignalState;
+    private refreshProcessSnapshot;
+    private refreshZombieTimerCount;
+    private drainTrailingProcessOutput;
+    private startTrackedProcess;
+    private runEventPump;
+    private finishProcess;
+    private waitForTrackedProcess;
+    private signalProcess;
+    private flushPendingStdin;
+    private closeTrackedStdin;
+    private handleBackgroundProcessError;
+    private recordCompletedProcessError;
+    private emitBackgroundProcessError;
+    private createFilesystemView;
+    private buildProcessSnapshot;
+    private dispatchRead;
+    private dispatchNativeRead;
+    private dispatchWrite;
+    private resolveLocalMount;
+    private assertGuestPathWritable;
+    private mountedChildNames;
+    private assertLocalWritable;
+    private updateTrackedProcessSnapshot;
+}
+export type { AuthenticatedSession, CreatedVm, GuestFilesystemStat, SidecarSpawnOptions, RootFilesystemEntry, SidecarEventSelector, SidecarPermissionsPolicy, SidecarRegisteredHostCallbackDefinition, SidecarRequestFrame, SidecarResponsePayload, SidecarSessionState, SidecarSignalHandlerRegistration, SidecarSocketStateEntry, } from "./native-process-client.js";
+export { NATIVE_SIDECAR_FRAME_TIMEOUT_MS, SidecarProcess, SidecarEventBufferOverflow, SidecarProcessError, SidecarProcessExited, } from "./native-process-client.js";
+export type AgentOsSidecarPlacement = {
+    kind: "shared";
+    pool?: string;
+} | {
+    kind: "explicit";
+    sidecarId: string;
+};
+export type AgentOsSidecarSessionState = "connecting" | "ready" | "disposing" | "disposed" | "failed";
+export type AgentOsSidecarVmState = "creating" | "ready" | "disposing" | "disposed" | "failed";
+export interface AgentOsSidecarSessionLifecycle {
+    sessionId: string;
+    placement: AgentOsSidecarPlacement;
+    state: AgentOsSidecarSessionState;
+    createdAt: number;
+    connectedAt?: number;
+    disposedAt?: number;
+    lastError?: string;
+    metadata: Record<string, string>;
+    vmIds: string[];
+}
+export interface AgentOsSidecarVmLifecycle {
+    vmId: string;
+    sessionId: string;
+    state: AgentOsSidecarVmState;
+    createdAt: number;
+    readyAt?: number;
+    disposedAt?: number;
+    lastError?: string;
+    metadata: Record<string, string>;
+}
+export interface AgentOsSidecarSessionOptions {
+    placement?: AgentOsSidecarPlacement;
+    metadata?: Record<string, string>;
+    signal?: AbortSignal;
+}
+export interface AgentOsSidecarVmOptions {
+    metadata?: Record<string, string>;
+}
+export interface AgentOsSidecarSessionBootstrap {
+    sessionId: string;
+    placement: AgentOsSidecarPlacement;
+    metadata: Record<string, string>;
+    signal?: AbortSignal;
+}
+export interface AgentOsSidecarVmBootstrap {
+    vmId: string;
+    sessionId: string;
+    metadata: Record<string, string>;
+}
+export interface AgentOsSidecarTransport {
+    createVm?(bootstrap: AgentOsSidecarVmBootstrap): Promise<void>;
+    disposeVm?(vmId: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+export interface AgentOsSidecarClientOptions {
+    createSessionTransport(bootstrap: AgentOsSidecarSessionBootstrap): Promise<AgentOsSidecarTransport>;
+    createId?: () => string;
+    now?: () => number;
+}
+export declare class AgentOsSidecarVmHandle {
+    private readonly client;
+    readonly sessionId: string;
+    readonly vmId: string;
+    constructor(client: AgentOsSidecarClient, sessionId: string, vmId: string);
+    describe(): AgentOsSidecarVmLifecycle;
+    dispose(): Promise<void>;
+}
+export declare class AgentOsSidecarSessionHandle {
+    private readonly client;
+    readonly sessionId: string;
+    constructor(client: AgentOsSidecarClient, sessionId: string);
+    describe(): AgentOsSidecarSessionLifecycle;
+    listVms(): AgentOsSidecarVmLifecycle[];
+    createVm(options?: AgentOsSidecarVmOptions): Promise<AgentOsSidecarVmHandle>;
+    dispose(): Promise<void>;
+}
+export declare class AgentOsSidecarClient {
+    private readonly createSessionTransport;
+    private readonly createId;
+    private readonly now;
+    private readonly sessions;
+    private disposed;
+    constructor(options: AgentOsSidecarClientOptions);
+    createSession(options?: AgentOsSidecarSessionOptions): Promise<AgentOsSidecarSessionHandle>;
+    listSessions(): AgentOsSidecarSessionLifecycle[];
+    requireSessionLifecycle(sessionId: string): AgentOsSidecarSessionLifecycle;
+    listVms(sessionId: string): AgentOsSidecarVmLifecycle[];
+    requireVmLifecycle(sessionId: string, vmId: string): AgentOsSidecarVmLifecycle;
+    createVm(sessionId: string, options?: AgentOsSidecarVmOptions): Promise<AgentOsSidecarVmHandle>;
+    disposeVm(sessionId: string, vmId: string): Promise<void>;
+    disposeSession(sessionId: string): Promise<void>;
+    dispose(): Promise<void>;
+    private disposeVmEntry;
+    private getSessionEntry;
+    private getVmEntry;
+    private assertActive;
+}
+export declare function createAgentOsSidecarClient(options: AgentOsSidecarClientOptions): AgentOsSidecarClient;
+export type MountConfigJsonValue = string | number | boolean | null | MountConfigJsonObject | MountConfigJsonValue[];
+export interface MountConfigJsonObject {
+    [key: string]: MountConfigJsonValue;
+}
+export interface SidecarMountPluginDescriptor {
+    id: string;
+    config: MountConfigJsonObject;
+}
+export interface SidecarMountDescriptor {
+    guestPath: string;
+    readOnly: boolean;
+    plugin: SidecarMountPluginDescriptor;
+}
+export declare function serializeMountConfigForSidecar(mount: PlainMountConfig | NativeMountConfig): SidecarMountDescriptor;
+export type SidecarRootFilesystemDescriptor = VmConfigRootFilesystemConfig;
+export type SidecarRootFilesystemLowerDescriptor = VmConfigRootFilesystemLowerDescriptor;
+export type SidecarRootFilesystemEntry = VmConfigRootFilesystemEntry;
+export declare function serializeRootFilesystemForSidecar(config?: RootFilesystemConfig, bootstrapLower?: RootSnapshotExport | null): SidecarRootFilesystemDescriptor;