@rivet-dev/agentos-core 0.0.0-integrate-dylib-into-main.815fcda → 0.0.0-main.29b0797

package/dist/packages.js

@@ -1,335 +1,48 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, join, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-/**
- * Resolve a package directory by walking up the directory tree.
- * Supports both nested (pnpm) and flat (npm) node_modules layouts.
- */
-export function resolvePackageDir(startDir, packageName) {
-    const localPkgJson = join(startDir, "package.json");
-    if (existsSync(localPkgJson)) {
-        try {
-            const localPkg = JSON.parse(readFileSync(localPkgJson, "utf-8"));
-            if (localPkg.name === packageName) {
-                return realpathSync(startDir);
-            }
-        }
-        catch {
-            // Ignore malformed local package metadata and continue walking.
-        }
-    }
-    let searchDir = startDir;
-    while (true) {
-        const candidate = join(searchDir, "node_modules", packageName);
-        if (existsSync(join(candidate, "package.json"))) {
-            return realpathSync(candidate);
-        }
-        const parent = dirname(searchDir);
-        if (parent === searchDir)
-            break;
-        searchDir = parent;
-    }
-    throw new Error(`Package "${packageName}" not found starting from ${startDir}. ` +
-        `Ensure it is installed.`);
-}
-const LOCAL_REGISTRY_COMMAND_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../../..", "registry/native/target/wasm32-wasip1/release/commands");
-function readPackageName(packageDir) {
-    const pkg = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8"));
-    if (typeof pkg.name !== "string" || pkg.name.length === 0) {
-        throw new Error(`Package at ${packageDir} is missing a valid name`);
-    }
-    return pkg.name;
-}
-function pushSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath) {
-    if (seenVmPaths.has(vmPath)) {
-        return;
-    }
-    seenVmPaths.add(vmPath);
-    softwareRoots.push({ hostPath, vmPath });
-}
-function findPnpmStoreRoot(hostPath) {
-    const marker = `${sep}node_modules${sep}.pnpm${sep}`;
-    const markerIndex = hostPath.indexOf(marker);
-    if (markerIndex === -1) {
-        return null;
-    }
-    const nodeModulesRoot = `${hostPath.slice(0, markerIndex)}${sep}node_modules`;
-    const pnpmStoreRoot = join(nodeModulesRoot, ".pnpm");
-    return existsSync(pnpmStoreRoot) ? pnpmStoreRoot : null;
-}
-function pushPackageSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath) {
-    pushSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath);
-    const pnpmStoreRoot = findPnpmStoreRoot(hostPath);
-    if (!pnpmStoreRoot) {
-        return;
-    }
-    pushSoftwareRoot(softwareRoots, seenVmPaths, pnpmStoreRoot, "/root/node_modules/.pnpm");
-}
-/**
- * Create a SoftwareContext for a software descriptor.
- * Resolves npm package paths relative to the descriptor's packageDir.
- */
-function createSoftwareContext(packageDir, requires) {
-    // Pre-resolve all required packages to host paths
-    const resolvedPackages = new Map();
-    for (const reqPkg of requires) {
-        const hostDir = resolvePackageDir(packageDir, reqPkg);
-        const pkg = JSON.parse(readFileSync(join(hostDir, "package.json"), "utf-8"));
-        const vmDir = `/root/node_modules/${reqPkg}`;
-        resolvedPackages.set(reqPkg, { hostDir, vmDir, pkg });
-    }
-    return {
-        resolveBin(packageName, binName) {
-            const resolved = resolvedPackages.get(packageName);
-            if (!resolved) {
-                throw new Error(`Package "${packageName}" is not in the requires list. ` +
-                    `Available: ${[...resolvedPackages.keys()].join(", ")}`);
-            }
-            const { pkg, vmDir } = resolved;
-            let binEntry;
-            const effectiveBinName = binName ?? packageName;
-            if (typeof pkg.bin === "string") {
-                binEntry = pkg.bin;
-            }
-            else if (typeof pkg.bin === "object" && pkg.bin !== null) {
-                const binMap = pkg.bin;
-                binEntry = binMap[effectiveBinName] ?? Object.values(binMap)[0];
-            }
-            if (!binEntry) {
-                throw new Error(`No bin entry "${effectiveBinName}" found in ${packageName}/package.json`);
-            }
-            return `${vmDir}/${binEntry}`;
-        },
-        resolvePackage(packageName) {
-            const resolved = resolvedPackages.get(packageName);
-            if (!resolved) {
-                throw new Error(`Package "${packageName}" is not in the requires list. ` +
-                    `Available: ${[...resolvedPackages.keys()].join(", ")}`);
-            }
-            return resolved.vmDir;
-        },
-    };
-}
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { tryReadAgentosPackageManifest } from "./agentos-package.js";
 // ── defineSoftware ───────────────────────────────────────────────────
 /**
- * Define a software descriptor. This is a type-safe identity function that
- * validates the descriptor shape at compile time.
+ * Define a software descriptor. A type-safe identity function that validates the
+ * package-dir reference at compile time. The sidecar materializes the package into
+ * the `/opt/agentos` projection.
  */
 export function defineSoftware(desc) {
     return desc;
 }
-/** Check if a descriptor is a typed software descriptor (has a `type` field). */
-function isTypedDescriptor(desc) {
-    return ("type" in desc && typeof desc.type === "string");
-}
-const VALID_PERMISSION_TIERS = new Set([
-    "full",
-    "read-write",
-    "read-only",
-    "isolated",
-]);
-function isPermissionTier(value) {
-    return (typeof value === "string" &&
-        VALID_PERMISSION_TIERS.has(value));
-}
-function registerPermission(commandPermissions, commandName, tier) {
-    if (commandName in commandPermissions)
-        return;
-    commandPermissions[commandName] = tier;
-}
-function appendDeclaredCommand(declaredCommands, seen, commandName) {
-    if (typeof commandName !== "string" || seen.has(commandName)) {
-        return;
-    }
-    seen.add(commandName);
-    declaredCommands.push(commandName);
-}
-function collectCommandMetadata(pkg) {
-    const declaredCommands = [];
-    const seen = new Set();
-    const aliases = {};
-    if ("aliases" in pkg && pkg.aliases) {
-        for (const [aliasName, targetName] of Object.entries(pkg.aliases)) {
-            if (typeof targetName !== "string") {
-                continue;
-            }
-            aliases[aliasName] = targetName;
-            appendDeclaredCommand(declaredCommands, seen, aliasName);
-            appendDeclaredCommand(declaredCommands, seen, targetName);
-        }
-    }
-    const rawCommands = pkg.commands;
-    if (Array.isArray(rawCommands)) {
-        for (const rawCommand of rawCommands) {
-            if (typeof rawCommand !== "object" || rawCommand === null) {
-                continue;
-            }
-            const name = rawCommand.name;
-            const aliasOf = rawCommand.aliasOf;
-            appendDeclaredCommand(declaredCommands, seen, name);
-            appendDeclaredCommand(declaredCommands, seen, aliasOf);
-            if (typeof name === "string" && typeof aliasOf === "string") {
-                aliases[name] = aliasOf;
-            }
-        }
-    }
-    const permissions = pkg.permissions;
-    if (permissions) {
-        for (const commandName of permissions.full ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-        for (const commandName of permissions.readWrite ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-        if (Array.isArray(permissions.readOnly)) {
-            for (const commandName of permissions.readOnly) {
-                appendDeclaredCommand(declaredCommands, seen, commandName);
-            }
-        }
-        for (const commandName of permissions.isolated ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-    }
-    const commandDir = resolveLocalCommandDirFallback(pkg.commandDir, declaredCommands);
-    return {
-        commandDir,
-        declaredCommands,
-        aliases,
-    };
-}
-function hasUsableCommandDir(commandDir, declaredCommands) {
-    if (!existsSync(commandDir)) {
-        return false;
-    }
-    return declaredCommands.every((commandName) => existsSync(join(commandDir, commandName)));
-}
-function resolveLocalCommandDirFallback(commandDir, declaredCommands) {
-    if (declaredCommands.length === 0 ||
-        hasUsableCommandDir(commandDir, declaredCommands) ||
-        !hasUsableCommandDir(LOCAL_REGISTRY_COMMAND_DIR, declaredCommands)) {
-        return commandDir;
-    }
-    return LOCAL_REGISTRY_COMMAND_DIR;
-}
-function collectRegistryPackagePermissions(commandPermissions, pkg) {
-    const rawCommands = pkg.commands;
-    if (!Array.isArray(rawCommands))
-        return;
-    for (const rawCommand of rawCommands) {
-        if (typeof rawCommand !== "object" ||
-            rawCommand === null ||
-            !Object.hasOwn(rawCommand, "name") ||
-            !Object.hasOwn(rawCommand, "permissionTier")) {
+/**
+ * Resolve the agent-SDK snapshot bundle (an esbuild IIFE at
+ * `<dir>/dist/sdk-snapshot.js`) for the first snapshot-enabled agent package in
+ * the software set. Returns its source so it can be evaluated once into the
+ * per-sidecar V8 startup snapshot (`jsRuntime.snapshotUserlandCode`) and reused
+ * across sessions. Returns `undefined` when no agent opts in (`agent.snapshot`)
+ * or the bundle is absent -- the runtime then keeps the per-session import path.
+ */
+export function resolveAgentSnapshotBundle(software) {
+    const descriptors = software.flat();
+    for (const entry of descriptors) {
+        // Only transition package DIRS are readable host-side (their
+        // agentos-package.json is the toolchain-input manifest). Packed
+        // `.aospkg` refs carry the bundle inside the mount tar; the sidecar
+        // reads it from the packed vbare manifest's snapshotBundlePath.
+        const path = entry.packagePath;
+        if (path === undefined || !statIsDirectory(path))
             continue;
-        }
-        const name = rawCommand.name;
-        const permissionTier = rawCommand
-            .permissionTier;
-        if (typeof name !== "string" || !isPermissionTier(permissionTier))
+        const manifest = tryReadAgentosPackageManifest(path);
+        if (!manifest?.agent?.snapshot)
             continue;
-        registerPermission(commandPermissions, name, permissionTier);
-    }
-}
-function collectTypedDescriptorPermissions(commandPermissions, pkg) {
-    const permissions = pkg.permissions;
-    if (!permissions)
-        return;
-    for (const commandName of permissions.full ?? []) {
-        registerPermission(commandPermissions, commandName, "full");
-    }
-    for (const commandName of permissions.readWrite ?? []) {
-        registerPermission(commandPermissions, commandName, "read-write");
-    }
-    if (Array.isArray(permissions.readOnly)) {
-        for (const commandName of permissions.readOnly) {
-            registerPermission(commandPermissions, commandName, "read-only");
+        const bundlePath = join(path, "dist", "sdk-snapshot.js");
+        if (existsSync(bundlePath)) {
+            return readFileSync(bundlePath, "utf-8");
         }
     }
-    for (const commandName of permissions.isolated ?? []) {
-        registerPermission(commandPermissions, commandName, "isolated");
-    }
+    return undefined;
 }
-/**
- * Process an array of software descriptors at boot time.
- * Collects WASM command dirs, module access roots, and agent configurations.
- *
- * Any object with a `commandDir` property (e.g., registry packages) is treated
- * as a WASM command source. Typed descriptors with `type: "agent"` or `type: "tool"`
- * are processed for module mounting and agent registration.
- */
-export function processSoftware(software) {
-    const commandDirs = [];
-    const commandPackages = [];
-    const commandPermissions = {};
-    const softwareRoots = [];
-    const seenSoftwareVmPaths = new Set();
-    const agentConfigs = new Map();
-    // Flatten nested arrays (meta-packages export arrays of sub-packages).
-    const flat = software.flat();
-    for (const pkg of flat) {
-        if (!isTypedDescriptor(pkg)) {
-            // Duck-typed: any object with commandDir is a WASM command source.
-            const commandMetadata = collectCommandMetadata(pkg);
-            commandDirs.push(commandMetadata.commandDir);
-            commandPackages.push(commandMetadata);
-            collectRegistryPackagePermissions(commandPermissions, pkg);
-            continue;
-        }
-        switch (pkg.type) {
-            case "wasm-commands": {
-                const commandMetadata = collectCommandMetadata(pkg);
-                commandDirs.push(commandMetadata.commandDir);
-                commandPackages.push(commandMetadata);
-                collectTypedDescriptorPermissions(commandPermissions, pkg);
-                break;
-            }
-            case "agent": {
-                // Collect module roots for all required npm packages.
-                // Walks up directory tree to support flat (npm) and nested (pnpm) layouts.
-                const ctx = createSoftwareContext(pkg.packageDir, pkg.requires);
-                const declaringPackageName = readPackageName(pkg.packageDir);
-                pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, pkg.packageDir, `/root/node_modules/${declaringPackageName}`);
-                for (const reqPkg of pkg.requires) {
-                    const hostDir = resolvePackageDir(pkg.packageDir, reqPkg);
-                    const vmDir = `/root/node_modules/${reqPkg}`;
-                    pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, hostDir, vmDir);
-                }
-                // Compute static + dynamic env vars.
-                const staticEnv = pkg.agent.staticEnv ?? {};
-                const dynamicEnv = pkg.agent.env ? pkg.agent.env(ctx) : {};
-                const combinedEnv = { ...staticEnv, ...dynamicEnv };
-                // Register agent config.
-                const agentConfig = {
-                    acpAdapter: pkg.agent.acpAdapter,
-                    agentPackage: pkg.agent.agentPackage,
-                    declaringPackageDir: pkg.packageDir,
-                    launchArgs: pkg.agent.launchArgs,
-                    defaultEnv: Object.keys(combinedEnv).length > 0 ? combinedEnv : undefined,
-                };
-                agentConfigs.set(pkg.agent.id, agentConfig);
-                break;
-            }
-            case "tool": {
-                // Collect module roots for all required npm packages.
-                // Walks up directory tree to support flat (npm) and nested (pnpm) layouts.
-                const declaringPackageName = readPackageName(pkg.packageDir);
-                pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, pkg.packageDir, `/root/node_modules/${declaringPackageName}`);
-                for (const reqPkg of pkg.requires) {
-                    const hostDir = resolvePackageDir(pkg.packageDir, reqPkg);
-                    const vmDir = `/root/node_modules/${reqPkg}`;
-                    pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, hostDir, vmDir);
-                }
-                // Tool bin registration is handled by the caller (AgentOs.create)
-                // since it requires kernel access.
-                break;
-            }
-        }
+function statIsDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
     }
-    return {
-        commandDirs,
-        commandPackages,
-        commandPermissions,
-        softwareRoots,
-        agentConfigs,
-    };
 }

package/dist/runtime-compat.d.ts

@@ -1,3 +1,4 @@
+import type { NodeModulesMountConfig } from "./host-dir-mount.js";
 export declare const AF_INET = 2;
 export declare const AF_UNIX = 1;
 export declare const SOCK_STREAM = 1;
@@ -15,6 +16,7 @@ export interface VirtualDirEntry {
 export interface VirtualStat {
     mode: number;
     size: number;
+    sizeExact?: bigint;
     blocks: number;
     dev: number;
     rdev: number;
@@ -25,7 +27,9 @@ export interface VirtualStat {
     ctimeMs: number;
     birthtimeMs: number;
     ino: number;
+    inoExact?: bigint;
     nlink: number;
+    nlinkExact?: bigint;
     uid: number;
     gid: number;
 }
@@ -50,7 +54,9 @@ export interface VirtualFileSystem {
     lstat(path: string): Promise<VirtualStat>;
     link(oldPath: string, newPath: string): Promise<void>;
     chmod(path: string, mode: number): Promise<void>;
-    chown(path: string, uid: number, gid: number): Promise<void>;
+    chown(path: string, uid: number, gid: number, options?: {
+        followSymlinks?: boolean;
+    }): Promise<void>;
     utimes(path: string, atime: number, mtime: number): Promise<void>;
     truncate(path: string, length: number): Promise<void>;
     pread(path: string, offset: number, length: number): Promise<Uint8Array>;
@@ -81,7 +87,7 @@ export type NetworkPermissions = PermissionMode | RulePermissions<PatternPermiss
 export type ChildProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type ProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type EnvPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
-export type ToolPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type BindingPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export interface ProcessInfo {
     pid: number;
     ppid: number;
@@ -98,15 +104,16 @@ export interface ProcessInfo {
 }
 export interface ManagedProcess {
     pid: number;
-    writeStdin(data: Uint8Array | string): void;
-    closeStdin(): void;
+    writeStdin(data: Uint8Array | string): Promise<void>;
+    closeStdin(): Promise<void>;
     kill(signal?: number): void;
     wait(): Promise<number>;
     readonly exitCode: number | null;
 }
 export interface ShellHandle {
     pid: number;
-    write(data: Uint8Array | string): void;
+    write(data: Uint8Array | string): Promise<void>;
+    /** Ordered PTY output containing stdout and stderr exactly once. */
     onData: ((data: Uint8Array) => void) | null;
     resize(cols: number, rows: number): void;
     kill(signal?: number): void;
@@ -119,6 +126,7 @@ export interface OpenShellOptions {
     cwd?: string;
     cols?: number;
     rows?: number;
+    /** Optional stderr-only diagnostic tap; do not render it alongside `onData`. */
     onStderr?: (data: Uint8Array) => void;
 }
 export interface ConnectTerminalOptions extends OpenShellOptions {
@@ -168,7 +176,7 @@ export interface Permissions {
     childProcess?: ChildProcessPermissions;
     process?: ProcessPermissions;
     env?: EnvPermissions;
-    tool?: ToolPermissions;
+    binding?: BindingPermissions;
 }
 export interface ResourceBudgets {
     maxOutputBytes?: number;
@@ -229,6 +237,7 @@ export interface SystemDriver {
     network?: NetworkAdapter;
     commandExecutor?: CommandExecutor;
     permissions?: Permissions;
+    mounts: readonly NodeModulesMountConfig[];
     runtime: {
         process: ProcessConfig;
         os: OSConfig;
@@ -263,6 +272,13 @@ export interface NodeRuntimeDriverFactory {
 export interface KernelInterface {
     vfs: VirtualFileSystem;
 }
+export interface KernelRecursiveDirEntry {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+}
 export interface Kernel extends KernelInterface {
     mount(driver: KernelRuntimeDriver): Promise<void>;
     dispose(): Promise<void>;
@@ -272,17 +288,24 @@ export interface Kernel extends KernelInterface {
     connectTerminal(options?: ConnectTerminalOptions): Promise<number>;
     mountFs(path: string, fs: VirtualFileSystem, options?: {
         readOnly?: boolean;
-    }): void;
-    unmountFs(path: string): void;
+    }): void | Promise<void>;
+    unmountFs(path: string): void | Promise<void>;
     readFile(path: string): Promise<Uint8Array>;
     writeFile(path: string, content: string | Uint8Array): Promise<void>;
     mkdir(path: string): Promise<void>;
     readdir(path: string): Promise<string[]>;
+    readdirRecursive(path: string, options?: {
+        maxDepth?: number;
+    }): Promise<KernelRecursiveDirEntry[]>;
     stat(path: string): Promise<VirtualStat>;
     exists(path: string): Promise<boolean>;
     removeFile(path: string): Promise<void>;
     removeDir(path: string): Promise<void>;
+    removePath(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
+    movePath(oldPath: string, newPath: string): Promise<void>;
     readonly commands: ReadonlyMap<string, string>;
     readonly processes: ReadonlyMap<number, ProcessInfo>;
     readonly env: Record<string, string>;
@@ -304,17 +327,14 @@ export interface BindingTree {
     [key: string]: BindingFunction | BindingTree;
 }
 export type BindingFunction = (...args: unknown[]) => unknown;
-export interface ModuleAccessOptions {
-    cwd?: string;
-}
 export interface NodeDriverOptions {
     filesystem?: VirtualFileSystem;
     networkAdapter?: NetworkAdapter;
     commandExecutor?: CommandExecutor;
     permissions?: Permissions;
+    mounts?: readonly NodeModulesMountConfig[];
     processConfig?: ProcessConfig;
     osConfig?: OSConfig;
-    moduleAccess?: ModuleAccessOptions;
 }
 export interface DefaultNetworkAdapterOptions {
     loopbackExemptPorts?: number[];
@@ -345,40 +365,6 @@ export declare class KernelError extends Error {
     readonly code: string;
     constructor(code: string, message: string);
 }
-export declare class InMemoryFileSystem implements VirtualFileSystem {
-    private readonly entries;
-    constructor();
-    readFile(targetPath: string): Promise<Uint8Array>;
-    readTextFile(targetPath: string): Promise<string>;
-    readDir(targetPath: string): Promise<string[]>;
-    readDirWithTypes(targetPath: string): Promise<VirtualDirEntry[]>;
-    writeFile(targetPath: string, content: string | Uint8Array): Promise<void>;
-    createDir(targetPath: string): Promise<void>;
-    mkdir(targetPath: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    exists(targetPath: string): Promise<boolean>;
-    stat(targetPath: string): Promise<VirtualStat>;
-    removeFile(targetPath: string): Promise<void>;
-    removeDir(targetPath: string): Promise<void>;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    realpath(targetPath: string): Promise<string>;
-    symlink(target: string, linkPath: string): Promise<void>;
-    readlink(targetPath: string): Promise<string>;
-    lstat(targetPath: string): Promise<VirtualStat>;
-    link(oldPath: string, newPath: string): Promise<void>;
-    chmod(targetPath: string, mode: number): Promise<void>;
-    chown(targetPath: string, uid: number, gid: number): Promise<void>;
-    utimes(targetPath: string, atime: number, mtime: number): Promise<void>;
-    truncate(targetPath: string, length: number): Promise<void>;
-    pread(targetPath: string, offset: number, length: number): Promise<Uint8Array>;
-    pwrite(targetPath: string, offset: number, data: Uint8Array): Promise<void>;
-    private resolvePath;
-    private resolveEntry;
-    private newDirectory;
-    private toStat;
-}
-export declare function createInMemoryFileSystem(): InMemoryFileSystem;
 export declare class NodeFileSystem implements VirtualFileSystem {
     readonly rootPath: string;
     constructor(options: {
@@ -472,4 +458,5 @@ export declare function createKernel(options: {
         readOnly?: boolean;
     }>;
     syncFilesystemOnDispose?: boolean;
+    maxFilesystemBytes?: number;
 }): Kernel;