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

package/dist/test/sandbox-agent.js

@@ -0,0 +1,395 @@
+import { once } from "node:events";
+import { createServer } from "node:http";
+import { mkdtemp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+function json(response, status, value) {
+    const body = Buffer.from(JSON.stringify(value));
+    response.writeHead(status, {
+        "content-length": String(body.length),
+        "content-type": "application/json",
+    });
+    response.end(body);
+}
+function problem(response, status, detail) {
+    json(response, status, {
+        type: "about:blank",
+        title: status === 404 ? "Not Found" : "Bad Request",
+        status,
+        detail,
+    });
+}
+async function readBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+function decodePath(rootDir, rawPath) {
+    const candidate = rawPath && rawPath.length > 0 ? rawPath : rootDir;
+    const direct = resolve(candidate.startsWith("/") ? candidate : resolve(rootDir, candidate));
+    const directRel = relative(rootDir, direct);
+    if (!(directRel.startsWith("..") || directRel === "..")) {
+        return direct;
+    }
+    const mapped = resolve(rootDir, candidate.replace(/^\/+/, ""));
+    const mappedRel = relative(rootDir, mapped);
+    if (mappedRel.startsWith("..") || mappedRel === "..") {
+        throw new Error(`Path escapes mock sandbox root: ${candidate}`);
+    }
+    return mapped;
+}
+function mapProcessPath(rootDir, value) {
+    const direct = resolve(value);
+    const directRel = relative(rootDir, direct);
+    if (!(directRel.startsWith("..") || directRel === "..")) {
+        return direct;
+    }
+    if (!value.startsWith("/")) {
+        return value;
+    }
+    return decodePath(rootDir, value);
+}
+function processInfo(proc) {
+    return {
+        id: proc.id,
+        command: proc.command,
+        args: proc.args,
+        status: proc.status,
+        pid: proc.pid,
+        exitCode: proc.exitCode,
+        cwd: proc.cwd,
+        createdAtMs: proc.createdAtMs,
+        exitedAtMs: proc.exitedAtMs,
+        interactive: proc.interactive,
+        tty: proc.tty,
+        owner: "user",
+    };
+}
+function appendLog(proc, stream, chunk) {
+    proc.sequence += 1;
+    proc.logs.push({
+        data: chunk.toString("base64"),
+        encoding: "base64",
+        sequence: proc.sequence,
+        stream,
+        timestampMs: Date.now(),
+    });
+}
+async function waitForProcessExit(proc, timeoutMs = 2_000) {
+    if (proc.status === "exited") {
+        return;
+    }
+    await Promise.race([
+        once(proc.child, "close").then(() => undefined),
+        new Promise((resolveTimeout) => {
+            setTimeout(resolveTimeout, timeoutMs);
+        }),
+    ]);
+}
+async function runCommand(request) {
+    const startedAt = Date.now();
+    return await new Promise((resolveRun) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let timedOut = false;
+        const child = spawn(request.command, request.args?.map((value) => mapProcessPath(request.rootDir, value)) ?? [], {
+            cwd: request.cwd ? mapProcessPath(request.rootDir, request.cwd) : undefined,
+            env: request.env ? { ...process.env, ...request.env } : process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const finish = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolveRun(value);
+        };
+        const timeout = request.timeoutMs && request.timeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGKILL");
+            }, request.timeoutMs)
+            : null;
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (error) => {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            finish({
+                durationMs: Date.now() - startedAt,
+                exitCode: 127,
+                stderr: error.message,
+                stderrTruncated: false,
+                stdout: "",
+                stdoutTruncated: false,
+                timedOut,
+            });
+        });
+        child.on("close", (code) => {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            finish({
+                durationMs: Date.now() - startedAt,
+                exitCode: code,
+                stderr,
+                stderrTruncated: false,
+                stdout,
+                stdoutTruncated: false,
+                timedOut,
+            });
+        });
+    });
+}
+export async function startMockSandboxAgent() {
+    const rootDir = await mkdtemp(resolve(tmpdir(), "agent-os-sandbox-agent-"));
+    const processes = new Map();
+    const server = createServer(async (request, response) => {
+        try {
+            const url = new URL(request.url ?? "/", "http://127.0.0.1");
+            const method = request.method ?? "GET";
+            if (method === "GET" && url.pathname === "/") {
+                json(response, 200, { ok: true });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/health") {
+                json(response, 200, { status: "ok" });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/fs/entries") {
+                const target = decodePath(rootDir, url.searchParams.get("path"));
+                const entries = await readdir(target, { withFileTypes: true });
+                const payload = await Promise.all(entries.map(async (entry) => {
+                    const entryPath = resolve(target, entry.name);
+                    const metadata = await stat(entryPath);
+                    return {
+                        name: entry.name,
+                        path: entryPath,
+                        entryType: entry.isDirectory() ? "directory" : "file",
+                        size: metadata.size,
+                        modified: null,
+                    };
+                }));
+                payload.sort((left, right) => left.name.localeCompare(right.name));
+                json(response, 200, payload);
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/fs/file") {
+                const target = decodePath(rootDir, url.searchParams.get("path"));
+                const bytes = await readFile(target);
+                response.writeHead(200, {
+                    "content-length": String(bytes.length),
+                    "content-type": "application/octet-stream",
+                });
+                response.end(bytes);
+                return;
+            }
+            if (method === "PUT" && url.pathname === "/v1/fs/file") {
+                const target = decodePath(rootDir, url.searchParams.get("path"));
+                await mkdir(dirname(target), { recursive: true });
+                const body = await readBody(request);
+                await writeFile(target, body);
+                json(response, 200, {
+                    path: target,
+                    bytesWritten: body.length,
+                });
+                return;
+            }
+            if (method === "DELETE" && url.pathname === "/v1/fs/entry") {
+                const target = decodePath(rootDir, url.searchParams.get("path"));
+                await rm(target, {
+                    force: true,
+                    recursive: url.searchParams.get("recursive") === "true",
+                });
+                json(response, 200, { path: target });
+                return;
+            }
+            if (method === "POST" && url.pathname === "/v1/fs/mkdir") {
+                const target = decodePath(rootDir, url.searchParams.get("path"));
+                await mkdir(target, { recursive: true });
+                json(response, 200, { path: target });
+                return;
+            }
+            if (method === "POST" && url.pathname === "/v1/fs/move") {
+                const body = JSON.parse((await readBody(request)).toString("utf8"));
+                const from = decodePath(rootDir, body.from);
+                const to = decodePath(rootDir, body.to);
+                await mkdir(dirname(to), { recursive: true });
+                await rename(from, to);
+                json(response, 200, { from, to });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/fs/stat") {
+                const target = decodePath(rootDir, url.searchParams.get("path"));
+                const metadata = await stat(target);
+                json(response, 200, {
+                    path: target,
+                    entryType: metadata.isDirectory() ? "directory" : "file",
+                    size: metadata.size,
+                    modified: null,
+                });
+                return;
+            }
+            if (method === "POST" && url.pathname === "/v1/processes/run") {
+                const requestBody = JSON.parse((await readBody(request)).toString("utf8"));
+                json(response, 200, await runCommand({
+                    ...requestBody,
+                    rootDir,
+                    cwd: requestBody.cwd ?? undefined,
+                }));
+                return;
+            }
+            if (method === "POST" && url.pathname === "/v1/processes") {
+                const requestBody = JSON.parse((await readBody(request)).toString("utf8"));
+                const child = spawn(requestBody.command, requestBody.args?.map((value) => mapProcessPath(rootDir, value)) ?? [], {
+                    cwd: requestBody.cwd
+                        ? mapProcessPath(rootDir, requestBody.cwd)
+                        : undefined,
+                    env: requestBody.env
+                        ? { ...process.env, ...requestBody.env }
+                        : process.env,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                const proc = {
+                    id: randomUUID(),
+                    command: requestBody.command,
+                    args: requestBody.args ?? [],
+                    child,
+                    createdAtMs: Date.now(),
+                    cwd: requestBody.cwd ?? null,
+                    exitCode: null,
+                    exitedAtMs: null,
+                    interactive: requestBody.interactive === true,
+                    logs: [],
+                    pid: child.pid ?? null,
+                    sequence: 0,
+                    status: "running",
+                    tty: requestBody.tty === true,
+                };
+                processes.set(proc.id, proc);
+                child.stdout.on("data", (chunk) => appendLog(proc, "stdout", chunk));
+                child.stderr.on("data", (chunk) => appendLog(proc, "stderr", chunk));
+                child.on("close", (code) => {
+                    proc.status = "exited";
+                    proc.exitCode = code;
+                    proc.exitedAtMs = Date.now();
+                });
+                child.on("error", (error) => {
+                    appendLog(proc, "stderr", Buffer.from(error.message, "utf8"));
+                    proc.status = "exited";
+                    proc.exitCode = 127;
+                    proc.exitedAtMs = Date.now();
+                });
+                json(response, 200, processInfo(proc));
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/processes") {
+                json(response, 200, {
+                    processes: Array.from(processes.values()).map(processInfo),
+                });
+                return;
+            }
+            const processMatch = url.pathname.match(/^\/v1\/processes\/([^/]+)(?:\/(stop|kill|logs|input))?$/);
+            if (processMatch) {
+                const [, rawId, action] = processMatch;
+                const proc = processes.get(decodeURIComponent(rawId));
+                if (!proc) {
+                    problem(response, 404, `Unknown process: ${rawId}`);
+                    return;
+                }
+                if (method === "POST" && action === "stop") {
+                    if (proc.status === "running") {
+                        proc.child.kill("SIGTERM");
+                        await waitForProcessExit(proc);
+                    }
+                    json(response, 200, processInfo(proc));
+                    return;
+                }
+                if (method === "POST" && action === "kill") {
+                    if (proc.status === "running") {
+                        proc.child.kill("SIGKILL");
+                        await waitForProcessExit(proc);
+                    }
+                    json(response, 200, processInfo(proc));
+                    return;
+                }
+                if (method === "GET" && action === "logs") {
+                    const tail = Number(url.searchParams.get("tail") ?? "0");
+                    const stream = (url.searchParams.get("stream") ?? "combined");
+                    let entries = proc.logs;
+                    if (stream !== "combined") {
+                        entries = entries.filter((entry) => entry.stream === stream);
+                    }
+                    if (Number.isFinite(tail) && tail > 0) {
+                        entries = entries.slice(-tail);
+                    }
+                    json(response, 200, {
+                        processId: proc.id,
+                        stream,
+                        entries,
+                    });
+                    return;
+                }
+                if (method === "POST" && action === "input") {
+                    const body = JSON.parse((await readBody(request)).toString("utf8"));
+                    const bytes = body.encoding === "base64"
+                        ? Buffer.from(body.data, "base64")
+                        : Buffer.from(body.data, "utf8");
+                    proc.child.stdin.write(bytes);
+                    json(response, 200, { bytesWritten: bytes.length });
+                    return;
+                }
+            }
+            problem(response, 404, `Unhandled mock sandbox-agent route: ${method} ${url.pathname}`);
+        }
+        catch (error) {
+            problem(response, 400, error instanceof Error ? error.message : String(error));
+        }
+    });
+    server.listen(0, "127.0.0.1");
+    await once(server, "listening");
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Mock sandbox-agent failed to bind to a TCP port");
+    }
+    const baseUrl = `http://127.0.0.1:${address.port}`;
+    const { SandboxAgent } = await import("sandbox-agent");
+    const client = await SandboxAgent.connect({
+        baseUrl,
+        waitForHealth: { timeoutMs: 5_000 },
+    });
+    return {
+        baseUrl,
+        client,
+        rootDir,
+        path: (...segments) => resolve(rootDir, ...segments),
+        stop: async () => {
+            for (const proc of processes.values()) {
+                if (proc.status === "running") {
+                    proc.child.kill("SIGKILL");
+                    await waitForProcessExit(proc);
+                }
+            }
+            await new Promise((resolveClose, rejectClose) => {
+                server.close((error) => {
+                    if (error) {
+                        rejectClose(error);
+                        return;
+                    }
+                    resolveClose();
+                });
+            });
+            await rm(rootDir, { force: true, recursive: true });
+        },
+    };
+}

package/dist/test/terminal-harness.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TerminalHarness wires openShell() to a headless xterm Terminal so tests can
+ * assert against deterministic terminal screen state.
+ */
+import { Terminal } from "@xterm/headless";
+import type { Kernel } from "../runtime-compat.js";
+type ShellHandle = ReturnType<Kernel["openShell"]>;
+export declare class TerminalHarness {
+    readonly term: Terminal;
+    readonly shell: ShellHandle;
+    private typing;
+    private disposed;
+    constructor(kernel: Kernel, options?: {
+        cols?: number;
+        rows?: number;
+        env?: Record<string, string>;
+        cwd?: string;
+    });
+    type(input: string): Promise<void>;
+    private typeInternal;
+    screenshotTrimmed(): string;
+    line(row: number): string;
+    waitFor(text: string, occurrence?: number, timeoutMs?: number): Promise<void>;
+    exit(): Promise<number>;
+    dispose(): Promise<void>;
+}
+export {};

package/dist/test/terminal-harness.js

@@ -0,0 +1,122 @@
+/**
+ * TerminalHarness wires openShell() to a headless xterm Terminal so tests can
+ * assert against deterministic terminal screen state.
+ */
+import { Terminal } from "@xterm/headless";
+const SETTLE_MS = 50;
+const POLL_MS = 20;
+const DEFAULT_WAIT_TIMEOUT_MS = 5_000;
+export class TerminalHarness {
+    term;
+    shell;
+    typing = false;
+    disposed = false;
+    constructor(kernel, options) {
+        const cols = options?.cols ?? 80;
+        const rows = options?.rows ?? 24;
+        this.term = new Terminal({ cols, rows, allowProposedApi: true });
+        this.shell = kernel.openShell({
+            cols,
+            rows,
+            env: options?.env,
+            cwd: options?.cwd,
+            onStderr: (data) => {
+                this.term.write(data);
+            },
+        });
+        this.shell.onData = (data) => {
+            this.term.write(data);
+        };
+    }
+    async type(input) {
+        if (this.typing) {
+            throw new Error("TerminalHarness.type() called while previous type() is still in-flight");
+        }
+        this.typing = true;
+        try {
+            await this.typeInternal(input);
+        }
+        finally {
+            this.typing = false;
+        }
+    }
+    typeInternal(input) {
+        return new Promise((resolve) => {
+            let timer = null;
+            const originalOnData = this.shell.onData;
+            const resetTimer = () => {
+                if (timer !== null)
+                    clearTimeout(timer);
+                timer = setTimeout(() => {
+                    this.shell.onData = originalOnData;
+                    resolve();
+                }, SETTLE_MS);
+            };
+            this.shell.onData = (data) => {
+                this.term.write(data);
+                resetTimer();
+            };
+            resetTimer();
+            this.shell.write(input);
+        });
+    }
+    screenshotTrimmed() {
+        const buf = this.term.buffer.active;
+        const lines = [];
+        for (let row = 0; row < this.term.rows; row++) {
+            const line = buf.getLine(buf.viewportY + row);
+            lines.push(line ? line.translateToString(true) : "");
+        }
+        while (lines.length > 0 && lines[lines.length - 1] === "") {
+            lines.pop();
+        }
+        return lines.join("\n");
+    }
+    line(row) {
+        const buf = this.term.buffer.active;
+        const line = buf.getLine(buf.viewportY + row);
+        return line ? line.translateToString(true) : "";
+    }
+    async waitFor(text, occurrence = 1, timeoutMs = DEFAULT_WAIT_TIMEOUT_MS) {
+        const deadline = Date.now() + timeoutMs;
+        while (true) {
+            const screen = this.screenshotTrimmed();
+            let count = 0;
+            let idx = -1;
+            while (true) {
+                idx = screen.indexOf(text, idx + 1);
+                if (idx === -1)
+                    break;
+                count++;
+                if (count >= occurrence)
+                    return;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`waitFor("${text}", ${occurrence}) timed out after ${timeoutMs}ms.\n` +
+                    `Expected: "${text}" (occurrence ${occurrence})\n` +
+                    `Screen:\n${screen}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+        }
+    }
+    async exit() {
+        this.shell.write("\x04");
+        return this.shell.wait();
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        try {
+            this.shell.kill();
+            await Promise.race([
+                this.shell.wait(),
+                new Promise((resolve) => setTimeout(resolve, 500)),
+            ]);
+        }
+        catch {
+            // Shell may already be gone.
+        }
+        this.term.dispose();
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+export type { AgentCapabilities, AgentInfo, AgentOsCreateSidecarOptions, AgentOsLimits, AgentOsOptions, AgentOsSharedSidecarOptions, AgentOsSidecarConfig, AgentOsSidecarDescription, AgentRegistryEntry, BatchReadResult, BatchWriteEntry, BatchWriteResult, CreateSessionOptions, DirEntry, McpServerConfig, McpServerConfigLocal, McpServerConfigRemote, MountConfig, MountConfigJsonObject, MountConfigJsonPrimitive, MountConfigJsonValue, NativeMountConfig, NativeMountPluginDescriptor, OverlayMountConfig, PermissionReply, PermissionRequest, PermissionRequestHandler, PlainMountConfig, ProcessTreeNode, PromptResult, ReaddirRecursiveOptions, ResumeSessionOptions, ResumeSessionResult, RootFilesystemConfig, RootLowerInput, SessionConfigOption, SessionEventHandler, SessionInfo, SessionInitData, SessionMode, SessionModeState, SpawnedProcessInfo, } from "./agent-os.js";
+export type { AgentConfig, AgentType } from "./agents.js";
+export type { CronAction, CronEvent, CronEventHandler, CronJob, CronJobInfo, CronJobOptions, ScheduleDriver, ScheduleEntry, ScheduleHandle, } from "./cron/index.js";
+export type { HostDirBackendOptions, HostDirMountPluginConfig, NodeModulesMountConfig, } from "./host-dir-mount.js";
+export type { HostTool, ToolExample, ToolKit } from "./host-tools.js";
+export type { AcpTimeoutErrorData, JsonRpcError, JsonRpcErrorData, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, UnknownSessionErrorData, } from "./json-rpc.js";
+export type { FilesystemSnapshotExport, LayerHandle, LayerStore, OverlayFilesystemMode, RootSnapshotExport, SnapshotImportSource, SnapshotLayerHandle, WritableLayerHandle, } from "./layers.js";
+export type { AgentSoftwareDescriptor, AnySoftwareDescriptor, SoftwareContext, SoftwareDescriptor, SoftwareInput, SoftwareRoot, ToolSoftwareDescriptor, WasmCommandDirDescriptor, WasmCommandSoftwareDescriptor, } from "./packages.js";
+export type { ChildProcessPermissions, ConnectTerminalOptions, EnvPermissions, ExecOptions, ExecResult, FsPermissionRule, FsPermissions, KernelExecOptions, KernelExecResult, KernelSpawnOptions, NetworkAccessRequest, NetworkPermissions, OpenShellOptions, PatternPermissionRule, PermissionDecision, PermissionMode, Permissions, ProcessInfo, RulePermissions, StdioChannel, TimingMitigation, VirtualDirEntry, VirtualFileSystem, VirtualStat, } from "./runtime.js";
+export type { PromptCapabilities } from "./agent-session-types.js";

package/dist/types.js

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

package/fixtures/AGENTOS_SYSTEM_PROMPT.md

@@ -0,0 +1,21 @@
+# agentOS
+
+You are running inside agentOS, a Linux-like operating system for coding agents. 
+
+Known limitations:
+
+- Binaries inside agentOS are special. You cannot download and install arbitrary binaries (e.g. via curl or apt).
+- No file watching (inotify, fs.watch).
+
+## Bug Reports
+
+If you find a bug in something that does not behave like you would expect in agentOS, generate a bug report and indicate the user should file it under: https://github.com/rivet-dev/rivet/issues (This repository holds agentOS inside of it.)
+
+## Tools CLI
+
+Tools are available as CLI commands:
+
+- `agentos list-tools` — list all available toolkits and tools
+- `agentos-{toolkit} {tool} --help` — show usage for a specific tool
+- `agentos-{toolkit} {tool} --flag value` — invoke a tool
+