@dynamicagents/plugins 0.14.0 → 0.15.0

package/dist/workspace/exec.d.ts

@@ -1,94 +0,0 @@
-import { type WorkspaceHost } from "./open.js";
-/**
- * Running a command in a workspace's container, from outside the workspace
- * object: what `/computer`'s tools and `/repo`'s git share, and how a host
- * reaches its own container.
- */
-/** A command that has not finished in this long is a hung command. */
-export declare const DEFAULT_TIMEOUT_MS: number;
-/** Where checkouts live, in the container and in the workspace alike. */
-export declare const DEFAULT_CWD = "/workspace";
-/** Which workspace a caller reaches, and how its commands run there. */
-export interface WorkspaceClientConfig {
-    /**
-     * The Durable Object namespace holding workspaces, closed over at
-     * instantiation so it is never model input.
-     */
-    binding: DurableObjectNamespace<WorkspaceHost>;
-    /**
-     * Which workspace this agent gets, by name. A thunk because the useful name —
-     * caller plus repository — does not exist when the plugin list is built.
-     *
-     * One workspace is one container is one repository: `@cloudflare/computer`
-     * pairs a Durable Object with exactly one container, so "never mix two
-     * repositories" is structural here rather than a convention to maintain.
-     */
-    workspaceName: () => string;
-    /** Working directory for every command. Defaults to `/workspace`. */
-    cwd?: string;
-    /**
-     * Run every command through this shell, e.g. `"bash"`. Unset, the command
-     * string goes to the runtime as-is and lands on whatever `/bin/sh` is.
-     *
-     * Worth setting, because "whatever `/bin/sh` is" is **dash** on Debian and
-     * Ubuntu, and a model writing shell writes *bash*. `${PIPESTATUS[0]}` is the
-     * one that costs most — a bash builtin a model reaches for to read a piped exit
-     * code, which dash fails with exit 2, after the command it wrapped has already
-     * run. It is one member of a family (`[[ ]]`, arrays, `set -o pipefail`,
-     * process substitution), so the fix is the shell rather than a note in a prompt
-     * telling the model to write POSIX.
-     *
-     * Set it only if the image actually has that shell: a missing one fails *every*
-     * command rather than the bash-flavoured ones.
-     */
-    shell?: string;
-    /** Per-command timeout. Defaults to ten minutes. */
-    timeoutMs?: number;
-}
-/**
- * An `exec` bound to this workspace, for plugins that need a shell but should
- * not own a container.
- *
- * `@dynamicagents/plugins/repo` is the reason this exists: it needs `git` on a real
- * shell, but depending on this module would weld the two together and stop a
- * host from pointing it at its own container. Structurally typed for the same
- * reason — the two plugins compose without either importing the other.
- *
- * ## The agent tools' `env` is deliberately **not** merged here
- *
- * `/computer`'s `ComputerConfig.env` is merged into every command its tools
- * run; this takes no environment of its own.
- *
- * What this hands out is a raw shell to *another plugin*, whose commands this
- * module neither writes nor sees. `/repo` runs its unauthenticated git through
- * it and pins the environment those need — `GIT_TERMINAL_PROMPT=0` plus the
- * model-authored values it passes as variables. A host environment merged
- * underneath lets through every key it does *not* pin: `http_proxy`,
- * `GIT_PROXY_COMMAND`, `GIT_SSL_CAINFO`, `GIT_CONFIG_GLOBAL`, `GIT_EXEC_PATH` —
- * the last two redirect the config git reads and relocate its helper binaries.
- *
- * No token is at stake, since the credentialed operations do not run here at
- * all. The point is that changing what git does inside another plugin's commands
- * should not be something a tools plugin's config field does by accident,
- * from a host that only meant to set a registry. A host that wants it composes
- * it where the merge is visible:
- *
- * ```ts
- * exec: (command, options) =>
- *   workspaceExec(config)(command, {
- *     ...options,
- *     env: { ...mine, ...options?.env }
- *   });
- * ```
- */
-export declare function workspaceExec(config: WorkspaceClientConfig): (command: string, options?: {
-    cwd?: string;
-    env?: Record<string, string | undefined>;
-    timeout?: number;
-    runtime?: unknown;
-}) => Promise<{
-    success: boolean;
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}>;

package/dist/workspace/exec.js

@@ -1,153 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { cancelledNote } from "./format.js";
-import { openWorkspace, workspaceNameFromRuntime } from "./open.js";
-import { withShell } from "./shell.js";
-/**
- * Running a command in a workspace's container, from outside the workspace
- * object: what `/computer`'s tools and `/repo`'s git share, and how a host
- * reaches its own container.
- */
-/** A command that has not finished in this long is a hung command. */
-export const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
-/** Where checkouts live, in the container and in the workspace alike. */
-export const DEFAULT_CWD = "/workspace";
-/**
- * An `exec` bound to this workspace, for plugins that need a shell but should
- * not own a container.
- *
- * `@dynamicagents/plugins/repo` is the reason this exists: it needs `git` on a real
- * shell, but depending on this module would weld the two together and stop a
- * host from pointing it at its own container. Structurally typed for the same
- * reason — the two plugins compose without either importing the other.
- *
- * ## The agent tools' `env` is deliberately **not** merged here
- *
- * `/computer`'s `ComputerConfig.env` is merged into every command its tools
- * run; this takes no environment of its own.
- *
- * What this hands out is a raw shell to *another plugin*, whose commands this
- * module neither writes nor sees. `/repo` runs its unauthenticated git through
- * it and pins the environment those need — `GIT_TERMINAL_PROMPT=0` plus the
- * model-authored values it passes as variables. A host environment merged
- * underneath lets through every key it does *not* pin: `http_proxy`,
- * `GIT_PROXY_COMMAND`, `GIT_SSL_CAINFO`, `GIT_CONFIG_GLOBAL`, `GIT_EXEC_PATH` —
- * the last two redirect the config git reads and relocate its helper binaries.
- *
- * No token is at stake, since the credentialed operations do not run here at
- * all. The point is that changing what git does inside another plugin's commands
- * should not be something a tools plugin's config field does by accident,
- * from a host that only meant to set a registry. A host that wants it composes
- * it where the merge is visible:
- *
- * ```ts
- * exec: (command, options) =>
- *   workspaceExec(config)(command, {
- *     ...options,
- *     env: { ...mine, ...options?.env }
- *   });
- * ```
- */
-export function workspaceExec(config) {
-    return async (command, options) => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            // The caller forwards its sub-agent's runtime opaquely; only this side
-            // knows the key it might carry. That is what lets `/repo` reach a sub-agent's
-            // shared workspace without importing anything from here.
-            const name = workspaceNameFromRuntime(options?.runtime) ?? config.workspaceName();
-            const ws = __addDisposableResource(env_1, await openWorkspace(config.binding.get(config.binding.idFromName(name))), false);
-            const env = options?.env
-                ? Object.fromEntries(Object.entries(options.env).filter((entry) => entry[1] !== undefined))
-                : undefined;
-            // Named rather than inlined, because the note below has to state it: a
-            // ceiling the model cannot see is one it cannot work within.
-            const timeoutMs = options?.timeout ?? config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-            // `withShell`, never `withShellTranscript`: the caller reads this result in
-            // code. `/repo` compares `stdout` against a URL, tests it for emptiness to
-            // decide a tree is clean, and reads a sha out of it to push — all of which
-            // need `stdout` to carry the answer alone, with git's diagnostics on the
-            // channel git put them on.
-            const handle = __addDisposableResource(env_1, await ws.runtime.exec(withShell(command, config.shell), {
-                cwd: options?.cwd ?? config.cwd ?? DEFAULT_CWD,
-                encoding: "utf8",
-                timeoutMs,
-                ...(env ? { env } : {})
-            }), false);
-            const result = await handle.result();
-            const killed = cancelledNote(result.status, result.exitCode, timeoutMs);
-            return {
-                // `/repo` branches on `success`, which this runtime does not report — it
-                // has `status` and `exitCode`. Derived from the exit code rather than the
-                // status, because a command that runs and fails is `completed` here.
-                success: result.exitCode === 0,
-                stdout: result.stdout,
-                // Appended rather than substituted: a command killed at the ceiling may
-                // well have written plenty first, and that output is the more useful half.
-                // This is the only field the note can travel on — `stdout` is a data
-                // channel the caller parses, and the four fields are the whole contract.
-                stderr: killed
-                    ? [result.stderr, killed].filter(Boolean).join("\n")
-                    : result.stderr,
-                exitCode: result.exitCode
-            };
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    };
-}

package/dist/workspace/format.d.ts

@@ -1,36 +0,0 @@
-import type { WorkspaceRuntimeStatus } from "@cloudflare/computer";
-/**
- * Text shared by the workspace and the tools over it: the output bound, the
- * elapsed-time phrase, and what a killed command is told.
- */
-/**
- * Middle-out truncation, so both the first error and the final summary survive.
- *
- * The guard is not defensive padding. Without it a `max` at or below the marker's
- * own length makes `half` zero or negative, and `slice(-0)` is `slice(0)` — the
- * *whole* string — so the function returns more than it was given: 500 characters
- * in, 543 out at `max: 80`. A silent inversion of the one thing it does,
- * reachable from a public config field.
- */
-export declare function truncateOutput(text: string, max: number): string;
-/** Elapsed time in the shape a sentence wants. */
-export declare function humanMs(ms: number): string;
-/**
- * Why a command has nothing to show for itself.
- *
- * {@link renderResult} states a non-`completed` status on its verdict line;
- * {@link file://./exec.ts workspaceExec} has no verdict line, only the four fields its caller
- * branches on. A *killed* process writes nothing, so without this a `git clone`
- * that hit the ten-minute ceiling reaches the model through
- * `@dynamicagents/plugins/repo` as `clone failed:` with an empty reason — which reads
- * like a bug in the plugin rather than a limit it can work within.
- *
- * Only `cancelled`. A `failed` status is an ordinary non-zero exit, where the
- * command's own stderr is the better explanation and this would be noise on top
- * of it.
- *
- * Both plausible causes are named because the exit code cannot separate them:
- * 137 is SIGKILL, which is what the timeout sends *and* what the kernel sends a
- * container that ran out of memory.
- */
-export declare function cancelledNote(status: WorkspaceRuntimeStatus | undefined, exitCode: number, timeoutMs: number): string | undefined;

package/dist/workspace/format.js

@@ -1,57 +0,0 @@
-/**
- * Text shared by the workspace and the tools over it: the output bound, the
- * elapsed-time phrase, and what a killed command is told.
- */
-/**
- * Middle-out truncation, so both the first error and the final summary survive.
- *
- * The guard is not defensive padding. Without it a `max` at or below the marker's
- * own length makes `half` zero or negative, and `slice(-0)` is `slice(0)` — the
- * *whole* string — so the function returns more than it was given: 500 characters
- * in, 543 out at `max: 80`. A silent inversion of the one thing it does,
- * reachable from a public config field.
- */
-export function truncateOutput(text, max) {
-    if (text.length <= max)
-        return text;
-    const marker = (dropped) => `\n\n… [${dropped} characters omitted from the middle] …\n\n`;
-    // No budget for two halves plus the marker: keep the head, which is where the
-    // first error is, and say nothing clever.
-    const half = Math.floor((max - marker(text.length).length) / 2);
-    if (half < 1)
-        return text.slice(0, Math.max(0, max));
-    return (text.slice(0, half) + marker(text.length - half * 2) + text.slice(-half));
-}
-/** Elapsed time in the shape a sentence wants. */
-export function humanMs(ms) {
-    const s = Math.round(ms / 1000);
-    return s < 60
-        ? `${s}s`
-        : `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s`;
-}
-/**
- * Why a command has nothing to show for itself.
- *
- * {@link renderResult} states a non-`completed` status on its verdict line;
- * {@link file://./exec.ts workspaceExec} has no verdict line, only the four fields its caller
- * branches on. A *killed* process writes nothing, so without this a `git clone`
- * that hit the ten-minute ceiling reaches the model through
- * `@dynamicagents/plugins/repo` as `clone failed:` with an empty reason — which reads
- * like a bug in the plugin rather than a limit it can work within.
- *
- * Only `cancelled`. A `failed` status is an ordinary non-zero exit, where the
- * command's own stderr is the better explanation and this would be noise on top
- * of it.
- *
- * Both plausible causes are named because the exit code cannot separate them:
- * 137 is SIGKILL, which is what the timeout sends *and* what the kernel sends a
- * container that ran out of memory.
- */
-export function cancelledNote(status, exitCode, timeoutMs) {
-    if (status !== "cancelled")
-        return undefined;
-    return (`the command was killed rather than exiting on its own (exit ${exitCode}), so ` +
-        `anything it had not yet written is gone. The two usual causes are the ` +
-        `per-command time limit — ${humanMs(timeoutMs)} here — and the container ` +
-        `running out of memory.`);
-}

package/dist/workspace/git-host.d.ts

@@ -1,79 +0,0 @@
-import type { RepoGitResult } from "../repo/index.js";
-import type { GitClient } from "@cloudflare/computer/git";
-/**
- * The git operations that need the GitHub token, run on this side.
- *
- * They are here rather than on the `WorkspaceStub` the plugin already holds
- * because `WorkspaceGitStub` exposes only `cli(argv)` across a Durable Object
- * boundary, and argv cannot carry an `onAuth` callback. Routed through here, the
- * credential is read from the workspace object's own `env` and never crosses an
- * RPC boundary, never appears in an argument list, and never enters the
- * container.
- *
- * That last clause is the point, and it is why running credentialed `git` in the
- * container is not an option however carefully it is sandboxed: git executes
- * whatever `.git/config` and `.git/hooks` name, the model has a root shell on
- * that filesystem, and even a disposable git dir leaves the token readable
- * through `/proc` for the life of the process. isomorphic-git runs here and has
- * no hooks, no `ext::` transport, no template directory and no credential
- * helpers.
- *
- * **The caller owns the preconditions.** Bringing the workspace up to date is
- * the workspace object's job and it must happen first: git here reads that
- * object's SQLite, so a commit made in the container that has not been pulled
- * yet is a commit this code cannot see. The workspace object's `gitClone`,
- * `gitFetch` and `gitPush` in `./object.ts` are where that is settled.
- */
-export interface GitHostDeps {
-    /** The workspace's own client — isomorphic-git over the local store. */
-    git: () => GitClient;
-    /** The GitHub credential, read at the moment it would be handed over. */
-    token: () => string | undefined;
-    tag: () => string;
-}
-export declare class WorkspaceGitHost {
-    #private;
-    private readonly deps;
-    constructor(deps: GitHostDeps);
-    /**
-     * Each operation takes `url` explicitly rather than a remote name: resolving
-     * `origin` would read `.git/config`, a workspace file a co-installed shell
-     * tool can write.
-     */
-    clone(req: {
-        url: string;
-        dir: string;
-        allowedHosts: string[];
-        branch?: string;
-        depth?: number;
-    }): Promise<RepoGitResult>;
-    fetch(req: {
-        url: string;
-        dir: string;
-        allowedHosts: string[];
-        depth?: number;
-    }): Promise<RepoGitResult>;
-    /**
-     * `remote.origin.url` from the local store, or `undefined` where there is no
-     * checkout or no origin. Reads only, and needs no credential.
-     */
-    origin(dir: string): Promise<string | undefined>;
-    push(req: {
-        url: string;
-        dir: string;
-        branch: string;
-        allowedHosts: string[];
-    }): Promise<RepoGitResult>;
-}
-/**
- * A git error's message with the chain of causes behind it.
- *
- * `@cloudflare/computer/git` wraps isomorphic-git's errors, and classifies some
- * by a heuristic: any failure whose message mentions `.git` beside a missing
- * path or a ref it could not find is reported as "not a git repository" — a
- * sentence that is wrong about a checkout that plainly is one, and names
- * neither the file nor the ref. What actually failed is only on `cause`, which
- * a Durable Object boundary does not carry, so it is folded into the message
- * here while the error is still itself.
- */
-export declare function describeGitError(err: unknown): string;

package/dist/workspace/git-host.js

@@ -1,226 +0,0 @@
-/**
- * What the container's own `git init` would write, over isomorphic-git's.
- *
- * isomorphic-git's `init` writes `core.*` for a filesystem without symlinks or
- * an executable bit that ignores case, and the container's git obeys it. With
- * `symlinks = false`, a command there that rewrites the tree — starter puts a
- * worktree on its branch with `checkout -f` — writes each link as a file holding
- * its target, and `status` calls that clean. With `filemode = false`, a script
- * made executable is committed as 100644. The store models all three.
- */
-const CONTAINER_CORE_CONFIG = {
-    "core.symlinks": true,
-    "core.filemode": true,
-    "core.ignorecase": false
-};
-export class WorkspaceGitHost {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    /**
-     * Each operation takes `url` explicitly rather than a remote name: resolving
-     * `origin` would read `.git/config`, a workspace file a co-installed shell
-     * tool can write.
-     */
-    async clone(req) {
-        return this.#run(req.allowedHosts, async (git, onAuth) => {
-            // Spelled out rather than `git.clone`, and the reason is the credential.
-            //
-            // `clone` is the one network operation the client does not give an
-            // `onAuth` callback — it authenticates only through a `headers` option,
-            // which means attaching the token to the very first request to a URL the
-            // *model* chose. Composing the same work out of `fetch` puts every
-            // credentialed request on this side of `onAuth` instead, where the host is
-            // checked at the moment the token would be handed over. The cost is four
-            // calls instead of one; `clone` is these four.
-            await git.init({ dir: req.dir });
-            // Straight after `init`, so a clone that fails part-way leaves nothing
-            // behind that the container's git would misread.
-            for (const [path, value] of Object.entries(CONTAINER_CORE_CONFIG))
-                await git.configSet({ dir: req.dir, path, value });
-            await git.remoteAdd({
-                dir: req.dir,
-                name: "origin",
-                url: req.url,
-                force: true
-            });
-            const fetched = await git.fetch({
-                url: req.url,
-                dir: req.dir,
-                onAuth,
-                // Omission is passed through as omission, because the tool the model
-                // reads says so: `repo_clone` describes `depth` as "omit for full
-                // history; needed if you must rebase", and `/repo` deliberately leaves
-                // the key off when it is unset. Defaulting to 1 here made every such
-                // clone shallow, so the one thing the model was told to omit it for —
-                // rebasing — failed on a repository it had asked for in full.
-                ...(req.depth === undefined ? {} : { depth: req.depth }),
-                singleBranch: true,
-                tags: false,
-                ...(req.branch ? { ref: req.branch } : {})
-            });
-            const landed = req.branch ?? fetched.defaultBranch?.replace(/^refs\/heads\//, "");
-            if (!landed)
-                throw new Error(`cloned ${req.url} but the remote named no default branch to check out`);
-            await git.checkout({ dir: req.dir, ref: landed });
-            // What a real `git clone` writes and the container's git will look for:
-            // without it the branch tracks nothing, and an agent reaching for a bare
-            // `git status` in the shell sees a branch with no upstream.
-            await git.configSet({
-                dir: req.dir,
-                path: `branch.${landed}.remote`,
-                value: "origin"
-            });
-            await git.configSet({
-                dir: req.dir,
-                path: `branch.${landed}.merge`,
-                value: `refs/heads/${landed}`
-            });
-            return landed;
-        });
-    }
-    async fetch(req) {
-        return this.#run(req.allowedHosts, async (git, onAuth) => {
-            const result = await git.fetch({
-                url: req.url,
-                dir: req.dir,
-                onAuth,
-                prune: true,
-                tags: false,
-                singleBranch: false,
-                // Every branch is fetched, but isomorphic-git still resolves one ref
-                // against the remote's list, and left to itself it picks the current
-                // branch's upstream. A checkout left on a branch whose pull request
-                // merged — and whose remote branch went with it — then fails every
-                // fetch with `Could not find refs/heads/<branch>`. The remote's HEAD
-                // is always listed.
-                remoteRef: "HEAD",
-                ...(req.depth ? { depth: req.depth } : {})
-            });
-            return `fetched ${req.url} (default branch ${result.defaultBranch ?? "unknown"})`;
-        });
-    }
-    /**
-     * `remote.origin.url` from the local store, or `undefined` where there is no
-     * checkout or no origin. Reads only, and needs no credential.
-     */
-    async origin(dir) {
-        try {
-            const url = await this.deps
-                .git()
-                .configGet({ dir, path: "remote.origin.url" });
-            return typeof url === "string" && url ? url : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async push(req) {
-        return this.#run(req.allowedHosts, async (git, onAuth) => {
-            const result = await git.push({
-                url: req.url,
-                dir: req.dir,
-                ref: req.branch,
-                remoteRef: req.branch,
-                onAuth
-                // No `force`, ever, and not a knob: `/repo` refuses anything but a plain
-                // branch name precisely so that a push cannot be turned into a force
-                // push, and this is the other end of that promise.
-            });
-            // isomorphic-git reports a rejected push in the *result* rather than by
-            // throwing — a non-fast-forward comes back `ok: false` with the reason on
-            // the ref. Reading only the absence of an exception would report every
-            // rejected push as a success, in the one plugin whose entire theme is that
-            // a failed command is not a completed operation.
-            if (!result.ok) {
-                const perRef = Object.entries(result.refs)
-                    .filter(([, status]) => !status.ok)
-                    .map(([ref, status]) => `${ref}: ${status.error ?? "rejected"}`)
-                    .join("; ");
-                // `||`, not `??`, on the second rung: `perRef` is a joined string, so
-                // "no failing ref carried a reason" is `""` rather than nullish — and
-                // `??` would hand that through as the error message. A rejected push
-                // reporting a blank reason is the one outcome worse than a generic one.
-                throw new Error(result.error ?? (perRef || "the remote rejected the push"));
-            }
-            return `pushed ${req.branch} to ${req.url}`;
-        });
-    }
-    /**
-     * The shared body: entry-point bookkeeping, the credential, and the translation
-     * back into something that survives RPC.
-     *
-     * A thrown `GitError` loses its prototype crossing a Durable Object boundary,
-     * so `instanceof` on the far side is not available and the caller would be left
-     * pattern-matching a string. The `code` is lifted here, while the error is
-     * still itself, and travels as data.
-     */
-    async #run(allowedHosts, body) {
-        // Bound to the credential rather than checked before the call, which is
-        // strictly stronger: this is the moment the token would be handed over, and
-        // it sees the URL git actually authenticated against — including one it
-        // reached by redirect. A host nobody allowed gets no credential and the
-        // request fails unauthenticated, rather than the token being offered to it
-        // and *then* the mistake being noticed.
-        const onAuth = (url) => {
-            let host;
-            try {
-                const parsed = new URL(url);
-                if (parsed.protocol !== "https:")
-                    return {};
-                host = parsed.hostname;
-            }
-            catch {
-                return {};
-            }
-            if (!allowedHosts.includes(host)) {
-                console.warn(`[${this.deps.tag()}] refused to authenticate to a host`, {
-                    host
-                });
-                return {};
-            }
-            return { username: "x-access-token", password: this.deps.token() };
-        };
-        try {
-            return { ok: true, detail: await body(this.deps.git(), onAuth) };
-        }
-        catch (err) {
-            const code = err?.code;
-            const message = describeGitError(err);
-            console.error(`[${this.deps.tag()}] git failed`, { code, message });
-            return {
-                ok: false,
-                ...(typeof code === "string" ? { code } : {}),
-                message
-            };
-        }
-    }
-}
-/**
- * A git error's message with the chain of causes behind it.
- *
- * `@cloudflare/computer/git` wraps isomorphic-git's errors, and classifies some
- * by a heuristic: any failure whose message mentions `.git` beside a missing
- * path or a ref it could not find is reported as "not a git repository" — a
- * sentence that is wrong about a checkout that plainly is one, and names
- * neither the file nor the ref. What actually failed is only on `cause`, which
- * a Durable Object boundary does not carry, so it is folded into the message
- * here while the error is still itself.
- */
-export function describeGitError(err) {
-    const parts = [];
-    const seen = new Set();
-    let at = err;
-    for (let depth = 0; at !== undefined && at !== null && depth < 4; depth++) {
-        const e = at;
-        const text = typeof e.message === "string" ? e.message : String(at);
-        if (!seen.has(text)) {
-            seen.add(text);
-            const name = typeof e.name === "string" ? e.name : "";
-            parts.push(name && depth > 0 ? `${name}: ${text}` : text);
-        }
-        at = e.cause;
-    }
-    return parts.join(" ← ");
-}