@agentorg/cli 0.0.5 → 0.0.6

package/dist/src/oauth.js

@@ -0,0 +1,46 @@
+/** What the sign-in tab says, by outcome: `complete`'s refusal code, or `signed_in`. */
+const SAYS = {
+    signed_in: "Signed in to ChatGPT. You can close this tab.",
+    denied: "You declined on ChatGPT's page. Start again from AgentOrg when you're ready.",
+    expired: "This sign-in expired. Start again from AgentOrg.",
+};
+const FAILED = "The sign-in didn't work. Start again from AgentOrg.";
+/**
+ * `/oauth/chatgpt`: where ChatGPT sends the browser back. It hands the whole callback address to
+ * the person's `login.complete`, then sends the tab on to `?result=<outcome>`, an address without
+ * the sign-in's code, so the code stays out of the tab's address and history; that page says how
+ * it went and links back to the shell. The code is never logged or shown, and no page sends a
+ * referrer.
+ */
+export function oauthRoute(person) {
+    return (request, response, url) => {
+        if (request.method !== "GET")
+            return void response.writeHead(405).end();
+        const result = url.searchParams.get("result");
+        if (result !== null && [...url.searchParams.keys()].length === 1)
+            return page(response, result === "signed_in" ? 200 : 400, Object.hasOwn(SAYS, result) ? SAYS[result] : FAILED);
+        const after = (outcome) => {
+            response.writeHead(303, {
+                Location: `${url.pathname}?result=${encodeURIComponent(outcome)}`,
+                "Cache-Control": "no-store",
+                "Referrer-Policy": "no-referrer",
+            });
+            response.end();
+        };
+        void person.call("login", "complete", { callbackUrl: url.href }).then(() => after("signed_in"), (error) => {
+            const code = error?.code;
+            after(typeof code === "string" && Object.hasOwn(SAYS, code) ? code : "failed");
+        });
+    };
+}
+function page(response, status, text) {
+    response.writeHead(status, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store",
+        "Referrer-Policy": "no-referrer",
+        "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'",
+    });
+    response.end(`<!doctype html><meta charset="utf-8"><title>AgentOrg</title>` +
+        `<style>body{font:15px system-ui,sans-serif;margin:20vh auto;max-width:28rem;padding:0 16px}</style>` +
+        `<p>${text}</p><p><a href="/">Back to AgentOrg</a></p>`);
+}

package/dist/src/programs.d.ts

@@ -0,0 +1,29 @@
+import type { PersonCalls } from "./oauth.js";
+export interface ProgramsOptions {
+    home: string;
+    hubUrl: string;
+    /** Where the first run says what it couldn't do. */
+    log?: (message: string) => void;
+    /** How ChatGPT's requests leave, instead of the network. For tests. */
+    fetch?: (request: Request, init: RequestInit) => Promise<Response>;
+}
+export interface Programs {
+    /** The Actors running now, by program. */
+    chatgpt?: string;
+    agents?: string;
+    mcp?: string;
+    management?: string;
+    /** Leave the Hub, in the order that lets each finish. What each keeps stays. */
+    close(): Promise<void>;
+}
+/**
+ * Close every Actor that runs a package, as an earlier release's do: the programs replace them.
+ * Before the Hub opens. Each stays listed as closed; the files it left in the home stay too, unread.
+ */
+export declare function closePackageActors(home: string): void;
+/**
+ * Make what is missing and start each program. A program whose Actor exists keeps it and its
+ * credential. A step that fails is logged, the programs that don't need it still start, and the
+ * next start tries again.
+ */
+export declare function startPrograms(person: PersonCalls, options: ProgramsOptions): Promise<Programs>;

package/dist/src/programs.js

@@ -0,0 +1,171 @@
+// The app's programs: ChatGPT, the agent provider, the MCP provider and management, each an Actor
+// of its own that this process runs on its own channel, with its own private folder under the home.
+// Every step reads what is there before it acts, so each start converges on the same system.
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { HubState, PERSON } from "@agentorg/hub";
+import { startManager } from "@agentorg/manager";
+import { startMcpProvider } from "@agentorg/mcp";
+import { startAgentProvider } from "assistant/provider";
+import { startChatGPT } from "chatgpt";
+/**
+ * Close every Actor that runs a package, as an earlier release's do: the programs replace them.
+ * Before the Hub opens. Each stays listed as closed; the files it left in the home stay too, unread.
+ */
+export function closePackageActors(home) {
+    if (!existsSync(join(home, "hub.db")))
+        return;
+    const state = HubState.open(home);
+    try {
+        for (const { actorId, package: from, state: now } of state.actors())
+            if (now !== "closed" && from !== "external" && from !== "builtin")
+                state.closeActor(PERSON, actorId);
+    }
+    finally {
+        state.close();
+    }
+}
+/** The Hub's exports each program holds. */
+const hubBinding = (name) => ({ slot: name, provider: "hub", export: name });
+/**
+ * Make what is missing and start each program. A program whose Actor exists keeps it and its
+ * credential. A step that fails is logged, the programs that don't need it still start, and the
+ * next start tries again.
+ */
+export async function startPrograms(person, options) {
+    const log = options.log ?? (() => { });
+    const { hubUrl } = options;
+    const root = join(options.home, "programs");
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    chmodSync(root, 0o700);
+    const call = (slot, method, input = {}) => person.call(slot, method, input);
+    const programLog = {
+        info() { },
+        warn() { },
+        error: (message) => log(message),
+    };
+    const dirOf = (name) => join(root, name);
+    const identityFile = (name) => join(root, `${name}.identity`);
+    /** The program's Actor: the one kept for it unless that is closed, or a new one. */
+    const identity = async (name, title, bindings) => {
+        let kept;
+        try {
+            kept = JSON.parse(readFileSync(identityFile(name), "utf8"));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (kept) {
+            const { actors } = await call("actors", "list");
+            const { actorId } = kept;
+            if (actors.some((actor) => actor.actorId === actorId && actor.state !== "closed"))
+                return kept;
+        }
+        const made = await call("actors", "create", { name: title, bindings });
+        const file = identityFile(name);
+        writeFileSync(`${file}.tmp`, JSON.stringify(made), { mode: 0o600, flush: true });
+        renameSync(`${file}.tmp`, file);
+        return made;
+    };
+    /** Bind the person's `slot` to `export` of `provider`, unless it is bound already. */
+    const personSlot = async (slot, provider, exported) => {
+        const { bindings } = await call("bindings", "list", {
+            actor: "person",
+        });
+        if (bindings.some((binding) => binding.consumer === "person" && binding.slot === slot))
+            return;
+        await call("grants", "bind", { consumer: "person", slot, provider, export: exported });
+    };
+    const closers = [];
+    const attempt = async (what, run) => {
+        try {
+            return await run();
+        }
+        catch (error) {
+            log(`First run: ${what} didn't work: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    };
+    const chatgpt = await attempt("ChatGPT", async () => {
+        const { actorId, credential } = await identity("chatgpt", "ChatGPT", []);
+        const running = await startChatGPT({
+            hubUrl,
+            actorId,
+            credential,
+            dir: dirOf("chatgpt"),
+            log: programLog,
+            ...(options.fetch ? { fetch: options.fetch } : {}),
+        });
+        closers.unshift(() => running.close());
+        await personSlot("login", actorId, "login");
+        return actorId;
+    });
+    // Each agent's binding to the model comes from the provider's own, so ChatGPT goes first.
+    const agents = chatgpt &&
+        (await attempt("the agent provider", async () => {
+            const { actorId, credential } = await identity("agents", "AgentOrg", [
+                hubBinding("actors"),
+                { slot: "model", provider: chatgpt, export: "session" },
+            ]);
+            const running = await startAgentProvider({
+                hubUrl,
+                actorId,
+                credential,
+                model: { actor: chatgpt, export: "session" },
+                dir: dirOf("agents"),
+                log: programLog,
+            });
+            closers.unshift(() => running.close());
+            return actorId;
+        }));
+    const mcp = await attempt("the MCP provider", async () => {
+        const { actorId, credential } = await identity("mcp", "Local", [hubBinding("actors")]);
+        const running = await startMcpProvider({
+            hubUrl,
+            actorId,
+            credential,
+            dir: dirOf("mcp"),
+            log: programLog,
+        });
+        closers.unshift(() => running.close());
+        return actorId;
+    });
+    const management = await attempt("management", async () => {
+        const { actorId, credential } = await identity("management", "Management", [
+            hubBinding("actors"),
+            hubBinding("grants"),
+            hubBinding("bindings"),
+        ]);
+        // Management outlasts the providers at the end and is up before they're connected to it.
+        const running = await startManager({
+            hubUrl,
+            actorId,
+            credential,
+            dir: dirOf("management"),
+            log: programLog,
+        });
+        closers.push(() => running.close());
+        for (const [slot, exported] of [
+            ["agents", "agents"],
+            ["connections", "connections"],
+            ["skills", "skills"],
+        ])
+            await personSlot(slot, actorId, exported);
+        return actorId;
+    });
+    if (management)
+        for (const provider of [agents, mcp])
+            if (provider)
+                await attempt("connecting a provider to management", () => call("grants", "expose", { provider, export: "provider", to: management }));
+    return {
+        ...(chatgpt ? { chatgpt } : {}),
+        ...(agents ? { agents } : {}),
+        ...(mcp ? { mcp } : {}),
+        ...(management ? { management } : {}),
+        async close() {
+            for (const close of closers)
+                await close().catch((error) => log(`A program didn't stop: ${String(error)}`));
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/cli",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "AgentOrg as one app: the Hub, the person's gateway and the shell, on loopback.",
   "license": "MIT",
   "repository": {
@@ -23,22 +23,14 @@
   },
   "files": [
     "dist/src",
-    "dist/bundled",
     "static",
     "dist/node_modules"
   ],
   "dependencies": {
-    "@assistant-ui/react": "^0.15.32",
+    "@modelcontextprotocol/client": "2.4.0",
     "ajv": "^8.20.0",
-    "esbuild": "0.28.2",
-    "radix-ui": "^1.8.1",
-    "react": "^19.3.1",
-    "react-dom": "^19.3.1",
-    "react-markdown": "^10.1.0",
-    "react-resizable-panels": "^4.19.1",
-    "remark-gfm": "^4.0.1",
-    "remend": "^1.4.0",
     "ws": "^8.22.1",
+    "yaml": "2.9.1",
     "zod": "^4.6.7"
   },
   "publishConfig": {

package/dist/bundled/index.json

@@ -1,6 +0,0 @@
-{
-  "installer": "sha256-4055f8fddf6b90f3d356543f554b2a9e9a2c4a8827a8774f8f87952dc1692331.agentorg",
-  "chatgpt": "sha256-e356ea3c1899138a8494baf521556831006f38534fa9e92ae873e7e6956c3a46.agentorg",
-  "assistant": "sha256-1f64ca62a0209d767d6aa6c4feb50b0653d60f10bebbc301f79bd3a37e0153c1.agentorg",
-  "board": "sha256-0e91cc3d0e9762b81abc2427b5496b20f383abcd6fb97d928a8d50e956b54d1f.agentorg"
-}

package/dist/node_modules/@agentorg/hub/dist/src/build.d.ts

@@ -1,17 +0,0 @@
-/** What a package's source may total, paths and text: it fits in one frame. */
-export declare const MAX_SOURCE: number;
-/**
- * The source as given, checked before anything is written or queued: its paths (no two the same
- * but for case, none both a file and a folder), its size.
- */
-export declare function checkSource(files: unknown): [string, string][];
-/**
- * Build a package from its source, given as data, and add it with `add`: the files are written to
- * a fresh folder in the home, built as `agentorg build` builds (importing by name only the SDK,
- * the interfaces, zod, React, react-dom and the kit, and nothing outside the folder; reading no tsconfig; at most 16
- * modules and 16 MiB built), and the folder is gone after, whatever happened. A build that fails
- * is `Refused("build")` with the build's message, which names no path outside the package.
- */
-export declare function buildSource<T>(home: string, entries: [string, string][], sandbox: (paths: string[]) => string[], add: (file: string) => T): Promise<T>;
-/** Folders of builds a crash interrupted: removed when the Hub opens. */
-export declare function sweepBuilds(home: string): void;

package/dist/node_modules/@agentorg/hub/dist/src/build.js

@@ -1,120 +0,0 @@
-import { readdirSync, rmSync } from "node:fs";
-import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { Refused } from "@agentorg/sdk";
-import { BuildError, buildPackage } from "@agentorg/sdk/build";
-/** What a package's source may total, paths and text: it fits in one frame. */
-export const MAX_SOURCE = 768 * 1024;
-/** Files one package's source may have. */
-const MAX_FILES = 256;
-/**
- * What a package built by the Hub may import by name: the SDK, the interfaces, zod, and React and
- * the kit for views (`react/jsx-runtime`, which JSX compiles to, is React's).
- */
-const ALLOWED = [
-    "@agentorg/sdk",
-    "@agentorg/interfaces",
-    "zod",
-    "react",
-    "react-dom",
-    "@agentorg/kit",
-];
-/** Where those are found: this package's own folder (dist/src/build.js → the package). */
-const FROM = fileURLToPath(new URL("../..", import.meta.url));
-/** A source path: `package.json`, or a source file under `src/` named plainly. */
-const PATH = /^(package\.json|src(\/[A-Za-z0-9_][A-Za-z0-9_.-]*)*\/[A-Za-z0-9_][A-Za-z0-9_.-]*\.(ts|tsx|mts|js|mjs|jsx|json))$/;
-/** Files under `src/` that tools read as configuration: a tsconfig can name any file to read. */
-const CONFIG = /(^|\/)(tsconfig|jsconfig|package)\.json$/;
-/** At most 16 modules and 16 MiB built; 30 s to bundle each module, 60 s for the whole build. */
-const LIMITS = { modules: 16, bytes: 16 * 1024 * 1024, bundleMs: 30_000, totalMs: 60_000 };
-/** How long reading one module's definition may take, in a Hub build. */
-const DESCRIBE_MS = 5_000;
-/**
- * The source as given, checked before anything is written or queued: its paths (no two the same
- * but for case, none both a file and a folder), its size.
- */
-export function checkSource(files) {
-    if (typeof files !== "object" || files === null || Array.isArray(files))
-        throw new Refused("invalid", "files is an object of path to text.");
-    const entries = Object.entries(files);
-    if (entries.length > MAX_FILES)
-        throw new Refused("invalid", `A package's source is at most ${MAX_FILES} files.`);
-    let size = 0;
-    const seen = new Set();
-    for (const [path, text] of entries) {
-        if (path.length > 256 || !PATH.test(path) || (path !== "package.json" && CONFIG.test(path)))
-            throw new Refused("invalid", `${JSON.stringify(path)}: a package's source is package.json and source files under src/ (.ts, .tsx, .mts, .js, .mjs, .jsx, .json; no tsconfig, jsconfig or package.json there), by plain relative paths.`);
-        const lower = path.toLowerCase();
-        if (seen.has(lower))
-            throw new Refused("invalid", `${path}: another path differs from it only by case.`);
-        seen.add(lower);
-        if (typeof text !== "string")
-            throw new Refused("invalid", `${path} isn't text.`);
-        size += Buffer.byteLength(path) + Buffer.byteLength(text);
-    }
-    if (size > MAX_SOURCE)
-        throw new Refused("invalid", `A package's source is at most ${MAX_SOURCE / 1024} KiB.`);
-    if (!entries.some(([path]) => path === "package.json"))
-        throw new Refused("invalid", "A package's source has a package.json.");
-    for (const lower of seen)
-        for (let at = lower.indexOf("/"); at > 0; at = lower.indexOf("/", at + 1))
-            if (seen.has(lower.slice(0, at)))
-                throw new Refused("invalid", `${lower.slice(0, at)} is both a file and a folder.`);
-    return entries;
-}
-/**
- * A build's message as the caller may see it: the package's own paths relative to it, and the
- * places the Hub knows (its home, its installation) never named. The SDK already tells a place
- * outside the package as <outside>; only known prefixes are replaced here, so what the caller
- * wrote comes back as written.
- */
-function told(message, source, home) {
-    return message
-        .replaceAll(`${source}/`, "")
-        .replaceAll(source, ".")
-        .replaceAll(home, "<home>")
-        .replaceAll(FROM.replace(/\/$/, ""), "<hub>");
-}
-/**
- * Build a package from its source, given as data, and add it with `add`: the files are written to
- * a fresh folder in the home, built as `agentorg build` builds (importing by name only the SDK,
- * the interfaces, zod, React, react-dom and the kit, and nothing outside the folder; reading no tsconfig; at most 16
- * modules and 16 MiB built), and the folder is gone after, whatever happened. A build that fails
- * is `Refused("build")` with the build's message, which names no path outside the package.
- */
-export async function buildSource(home, entries, sandbox, add) {
-    const dir = await realpath(await mkdtemp(join(home, "build-")));
-    const source = join(dir, "source");
-    try {
-        let built;
-        try {
-            for (const [path, text] of entries) {
-                await mkdir(dirname(join(source, path)), { recursive: true, mode: 0o700 });
-                await writeFile(join(source, path), text, { mode: 0o600, flag: "wx" });
-            }
-            built = await buildPackage(source, {
-                out: join(dir, "out"),
-                packages: { allowed: ALLOWED, from: FROM },
-                limits: LIMITS,
-                describeTimeoutMs: DESCRIBE_MS,
-                // The describer runs the source's code: in the OS sandbox host processes run in.
-                describer: { sandbox },
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Refused("build", told(error instanceof BuildError ? message : `The build failed: ${message}`, source, await realpath(home)));
-        }
-        return add(built.file);
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true });
-    }
-}
-/** Folders of builds a crash interrupted: removed when the Hub opens. */
-export function sweepBuilds(home) {
-    for (const name of readdirSync(home))
-        if (name.startsWith("build-"))
-            rmSync(join(home, name), { recursive: true, force: true });
-}

package/dist/node_modules/@agentorg/hub/dist/src/logs.d.ts

@@ -1,33 +0,0 @@
-/** One line of an Actor's log, as `hub.actors.logs` returns it. */
-export interface LogLine {
-    level: "info" | "warn" | "error";
-    message: string;
-    data?: Record<string, unknown>;
-    module?: string;
-    at: string;
-}
-/** Where an Actor's log is kept in the home; the previous file, rotated once, is `<file>.1`. */
-export declare const logFile: (home: string, actorId: string) => string;
-/**
- * The newest `limit` entries of an Actor's log, oldest first, across its file and the one rotated
- * before it. Lines that aren't a log entry are skipped and don't count.
- */
-export declare function readLogs(home: string, actorId: string, limit: number): LogLine[];
-/**
- * An entry as it is written, whoever gave it: a known level, the text cut, and the data rebuilt
- * as a fresh object of at most `MAX_FIELDS` keys, each value a primitive or JSON text, cut.
- */
-export declare function boundedEntry(level: unknown, message: unknown, data: unknown, module: string | undefined): LogLine;
-/**
- * Add an entry to an Actor's log (0600). A file that would pass 1 MiB is rotated to `<file>.1`
- * first, replacing the one before, so an Actor's logs never hold more than two files.
- */
-export declare function appendLog(home: string, actorId: string, entry: LogLine): void;
-/** Add entries to an Actor's log in one write, rotating first as `appendLog` does. */
-export declare function appendLogs(home: string, actorId: string, entries: LogLine[]): void;
-/**
- * A line a host process wrote, as a log entry: on stderr, a JSON line with a message and a time is
- * one of the runner's `ctx.log` entries (bounded like any other); anything else is the process's
- * own output, `info` from stdout and `error` from stderr.
- */
-export declare function outputEntry(stream: "stdout" | "stderr", line: string): LogLine;

package/dist/node_modules/@agentorg/hub/dist/src/logs.js

@@ -1,162 +0,0 @@
-import { appendFileSync, closeSync, fstatSync, mkdirSync, openSync, readSync, renameSync, statSync, } from "node:fs";
-import { join } from "node:path";
-/** Where an Actor's log is kept in the home; the previous file, rotated once, is `<file>.1`. */
-export const logFile = (home, actorId) => join(home, "logs", `${actorId}.log`);
-/** A log file is rotated once it would pass this; each read takes at most this of a file's end. */
-const MAX_FILE = 1024 * 1024;
-const TAIL = MAX_FILE;
-/** A line's text is cut to this. */
-const MAX_MESSAGE = 4096;
-/** A line's data: this many keys at most, each value a primitive or JSON text, cut to this. */
-const MAX_FIELDS = 16;
-const MAX_FIELD = 1024;
-function tail(path) {
-    let fd;
-    try {
-        fd = openSync(path, "r");
-    }
-    catch {
-        return []; // Not written yet.
-    }
-    try {
-        const size = fstatSync(fd).size;
-        const length = Math.min(size, TAIL);
-        const buffer = Buffer.alloc(length);
-        readSync(fd, buffer, 0, length, size - length);
-        const lines = buffer.toString("utf8").split("\n");
-        // Cut mid-file, the first line is a fragment.
-        return size > length ? lines.slice(1) : lines;
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-const LEVELS = new Set(["info", "warn", "error"]);
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/** A line as a log entry, built from its known fields only; anything else isn't one. */
-function entryOf(line) {
-    let raw;
-    try {
-        raw = JSON.parse(line);
-    }
-    catch {
-        return undefined; // A partial line from a crash, or not ours.
-    }
-    if (!isRecord(raw) || typeof raw.message !== "string" || typeof raw.at !== "string")
-        return undefined;
-    return {
-        level: LEVELS.has(raw.level) ? raw.level : "info",
-        message: raw.message,
-        ...(isRecord(raw.data) ? { data: raw.data } : {}),
-        ...(typeof raw.module === "string" ? { module: raw.module } : {}),
-        at: raw.at,
-    };
-}
-/**
- * The newest `limit` entries of an Actor's log, oldest first, across its file and the one rotated
- * before it. Lines that aren't a log entry are skipped and don't count.
- */
-export function readLogs(home, actorId, limit) {
-    const file = logFile(home, actorId);
-    const lines = [...tail(`${file}.1`), ...tail(file)];
-    const entries = [];
-    for (let i = lines.length - 1; i >= 0 && entries.length < limit; i--) {
-        const entry = entryOf(lines[i]);
-        if (entry)
-            entries.push(entry);
-    }
-    return entries.reverse();
-}
-/** Anything as text, even what can't say itself (no prototype, a throwing `toString`). */
-function textOf(value) {
-    try {
-        return String(value);
-    }
-    catch {
-        return "[unprintable]";
-    }
-}
-/** One field's value as it is kept: a number, boolean or null as is, anything else as text, cut. */
-function fieldOf(read) {
-    try {
-        const value = read();
-        if (value === null || typeof value === "number" || typeof value === "boolean")
-            return value;
-        const text = typeof value === "string" ? value : textOf(JSON.stringify(value));
-        return text.slice(0, MAX_FIELD);
-    }
-    catch {
-        return "[unreadable]"; // A getter, toJSON or bigint that throws.
-    }
-}
-/**
- * An entry as it is written, whoever gave it: a known level, the text cut, and the data rebuilt
- * as a fresh object of at most `MAX_FIELDS` keys, each value a primitive or JSON text, cut.
- */
-export function boundedEntry(level, message, data, module) {
-    let fields;
-    try {
-        if (isRecord(data)) {
-            // No prototype: a `__proto__` key is a key like any other.
-            fields = Object.create(null);
-            let kept = 0;
-            // Only the first keys are read: the rest are never touched.
-            for (const key in data) {
-                if (!Object.hasOwn(data, key))
-                    continue;
-                if (kept++ >= MAX_FIELDS)
-                    break;
-                fields[key.slice(0, MAX_FIELD)] = fieldOf(() => data[key]);
-            }
-        }
-    }
-    catch {
-        fields = undefined; // Data that can't even list its keys (a hostile proxy) is left out.
-    }
-    return {
-        level: LEVELS.has(level) ? level : "info",
-        message: textOf(message).slice(0, MAX_MESSAGE),
-        ...(fields ? { data: fields } : {}),
-        ...(module === undefined ? {} : { module }),
-        at: new Date().toISOString(),
-    };
-}
-/**
- * Add an entry to an Actor's log (0600). A file that would pass 1 MiB is rotated to `<file>.1`
- * first, replacing the one before, so an Actor's logs never hold more than two files.
- */
-export function appendLog(home, actorId, entry) {
-    appendLogs(home, actorId, [entry]);
-}
-/** Add entries to an Actor's log in one write, rotating first as `appendLog` does. */
-export function appendLogs(home, actorId, entries) {
-    if (!entries.length)
-        return;
-    const file = logFile(home, actorId);
-    const line = entries.map((entry) => `${JSON.stringify(entry)}\n`).join("");
-    // Past what a reader takes of a file, a line could never be read back.
-    if (Buffer.byteLength(line) > MAX_FILE)
-        return;
-    mkdirSync(join(home, "logs"), { recursive: true, mode: 0o700 });
-    let size = 0;
-    try {
-        size = statSync(file).size;
-    }
-    catch {
-        // Not written yet.
-    }
-    if (size > 0 && size + Buffer.byteLength(line) > MAX_FILE)
-        renameSync(file, `${file}.1`);
-    appendFileSync(file, line, { mode: 0o600 });
-}
-/**
- * A line a host process wrote, as a log entry: on stderr, a JSON line with a message and a time is
- * one of the runner's `ctx.log` entries (bounded like any other); anything else is the process's
- * own output, `info` from stdout and `error` from stderr.
- */
-export function outputEntry(stream, line) {
-    const parsed = stream === "stderr" ? entryOf(line) : undefined;
-    return parsed
-        ? boundedEntry(parsed.level, parsed.message, parsed.data, parsed.module?.slice(0, 64))
-        : boundedEntry(stream === "stdout" ? "info" : "error", line, undefined, undefined);
-}