@bondedhq/runner 0.0.0-stage → 0.1.0

package/dist/init/apply.js

@@ -0,0 +1,73 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+/**
+ * Where a project path really is, refused when it would land outside the project (`..`, an
+ * absolute path, or a symlinked folder that points elsewhere).
+ */
+export function insideProject(root, path) {
+    if (isAbsolute(path))
+        throw new Error(`refusing to write ${path}: not a path in the project`);
+    const realRoot = realpathSync(root);
+    const target = resolve(realRoot, path);
+    let existing = target;
+    while (!existsSync(existing))
+        existing = dirname(existing);
+    const real = join(realpathSync(existing), relative(existing, target));
+    const rel = relative(realRoot, real);
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel))
+        throw new Error(`refusing to write ${path}: it is outside the project`);
+    return real;
+}
+/**
+ * Writes the plan's files. Each changed file must still be as it was when the plan was made, so
+ * nothing written in between is overwritten.
+ */
+export function applyPlan(root, plan) {
+    const targets = plan.changes.map((c) => ({ change: c, abs: insideProject(root, c.path) }));
+    for (const { change, abs } of targets) {
+        const now = existsSync(abs) ? readFileSync(abs, "utf8") : undefined;
+        if (now !== change.before)
+            throw new Error(`${change.path} changed since init read it; run init again`);
+    }
+    for (const { change, abs } of targets) {
+        mkdirSync(dirname(abs), { recursive: true });
+        writeFileSync(abs, change.after);
+    }
+    return targets.map((t) => t.change.path);
+}
+/**
+ * Appends the names that aren't in the env file yet, with empty values. Never reads values out or
+ * changes a line that is there.
+ */
+export function appendEnvNames(root, names, file = ".env") {
+    const abs = insideProject(root, file);
+    const text = existsSync(abs) ? readFileSync(abs, "utf8") : "";
+    const present = new Set(text
+        .split("\n")
+        .map((l) => /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(l)?.[1])
+        .filter(Boolean));
+    const missing = [...new Set(names)].filter((n) => !present.has(n));
+    if (!missing.length)
+        return [];
+    const block = `${text && !text.endsWith("\n") ? "\n" : ""}${text ? "\n" : ""}# Bonded (bonded-runner init): fill these in\n${missing.map((n) => `${n}=`).join("\n")}\n`;
+    writeFileSync(abs, text + block);
+    return missing;
+}
+/** The install command for the project's package manager. */
+export function installCommand(pm, packages) {
+    return pm === "npm" ? ["npm", "install", ...packages] : [pm, "add", ...packages];
+}
+/** Runs a command in the project, its output shown as it runs. Resolves with its exit code. */
+export function run(command, cwd) {
+    return new Promise((done) => {
+        const child = spawn(command[0], command.slice(1), {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.once("error", () => done(127));
+        child.once("close", (code) => done(code ?? 1));
+    });
+}
+//# sourceMappingURL=apply.js.map

package/dist/init/check.d.ts

@@ -0,0 +1,79 @@
+/**
+ * A client for Bonded's connection check, so `init` can run one right after connecting. With the
+ * runner token alone: `POST /runner/check` (the token as the bearer, no body) checks the preview
+ * or agent the token belongs to and answers with a stream token, then `GET
+ * /checks/:id/events?token=` follows it to the result. With an owner's session (the older way):
+ * `POST /previews/:id/checks` or `/self/agents/:id/checks`, then the same events with the
+ * session. The API decides pass or fail; this only prints it.
+ */
+/** The Bonded API the runner talks to when neither --api nor BONDED_API_URL says otherwise. */
+export declare const DEFAULT_API_URL = "https://api-production-ba50.up.railway.app";
+/** What a connection check streams (the API's `ConnectionCheckEvent`). */
+export type CheckEvent = {
+    type: "started";
+} | {
+    type: "tool";
+    name: string;
+    surface?: string | null;
+    ok: boolean;
+    error?: string;
+} | {
+    type: "tx";
+    ok: boolean;
+    reason?: string;
+} | {
+    type: "done";
+    exitCode?: number | null;
+    durationMs: number;
+    stdoutTail?: string;
+    stderrTail?: string;
+} | ({
+    type: "result";
+} & CheckResult);
+export interface CheckResult {
+    passed: boolean;
+    problems: string[];
+    warnings?: string[];
+    /** The same sentences with their troubleshooting codes. */
+    issues?: {
+        code: string;
+        severity: "problem" | "warning";
+        message: string;
+    }[];
+    taskCompleted: boolean | null;
+    toolsCalled: number;
+    surfacesRead: string[];
+    durationMs?: number;
+    codeHash?: string;
+}
+export type CheckTarget = {
+    /** The Bonded API, e.g. https://api.bonded.example. */
+    api: string;
+    /** The runner token (`bonded_rt_...`): it names the preview or agent to check. */
+    runnerToken: string;
+} | {
+    api: string;
+    /** A session token from signing in (`bonded_ss_...`). */
+    session: string;
+    /** A preview (`/previews/:id`) or a registered agent (`/self/agents/:id`). */
+    subject: {
+        kind: "preview" | "agent";
+        id: string;
+    };
+};
+export declare function runConnectionCheck(target: CheckTarget, onEvent: (event: CheckEvent) => void, options?: {
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<CheckResult>;
+/** Server-sent events from a response body: each message's `id` and `data`. */
+export declare function serverSentEvents(body: ReadableStream<Uint8Array>): AsyncGenerator<{
+    id?: string;
+    data: string;
+}>;
+/** One check event as a line for the terminal (the web app's wording). */
+export declare function eventLine(event: CheckEvent): string;
+/** Where each problem's fix is explained, by its code (the anchor). */
+export declare const TROUBLESHOOTING_URL = "https://bonded-nu.vercel.app/docs/guides/troubleshooting/";
+/** The result as lines: the verdict, then each problem and warning, with its fix's link. */
+export declare function resultLines(result: CheckResult): string[];
+//# sourceMappingURL=check.d.ts.map

package/dist/init/check.js

@@ -0,0 +1,158 @@
+/**
+ * A client for Bonded's connection check, so `init` can run one right after connecting. With the
+ * runner token alone: `POST /runner/check` (the token as the bearer, no body) checks the preview
+ * or agent the token belongs to and answers with a stream token, then `GET
+ * /checks/:id/events?token=` follows it to the result. With an owner's session (the older way):
+ * `POST /previews/:id/checks` or `/self/agents/:id/checks`, then the same events with the
+ * session. The API decides pass or fail; this only prints it.
+ */
+/** The Bonded API the runner talks to when neither --api nor BONDED_API_URL says otherwise. */
+export const DEFAULT_API_URL = "https://api-production-ba50.up.railway.app";
+export async function runConnectionCheck(target, onEvent, options = {}) {
+    const fetcher = options.fetch ?? fetch;
+    const base = target.api.replace(/\/+$/, "");
+    const byToken = "runnerToken" in target;
+    const started = byToken
+        ? await fetcher(`${base}/runner/check`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${target.runnerToken}` },
+        })
+        : await fetcher(`${base}${target.subject.kind === "preview"
+            ? `/previews/${encodeURIComponent(target.subject.id)}/checks`
+            : `/self/agents/${encodeURIComponent(target.subject.id)}/checks`}`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${target.session}`,
+                "content-type": "application/json",
+            },
+            body: "{}",
+        });
+    const body = (await started.json().catch(() => ({})));
+    if (!started.ok || !body.checkId)
+        throw new Error(body.error ?? `the API answered ${started.status} to the check`);
+    if (byToken && !body.streamToken)
+        throw new Error("the API didn't give a stream token for the check's events");
+    // The events: with the stream token the check came with, or with the session.
+    const eventsUrl = byToken
+        ? `${base}/checks/${encodeURIComponent(body.checkId)}/events?token=${encodeURIComponent(body.streamToken)}`
+        : `${base}/checks/${encodeURIComponent(body.checkId)}/events`;
+    const headers = byToken
+        ? {}
+        : { authorization: `Bearer ${target.session}` };
+    const seen = body.events ?? [];
+    seen.forEach(onEvent);
+    if (body.result) {
+        if (!seen.some((e) => e.type === "result"))
+            onEvent({ type: "result", ...body.result });
+        return body.result;
+    }
+    const deadline = Date.now() + (options.timeoutMs ?? 5 * 60_000);
+    let lastId = "";
+    let skip = seen.length;
+    while (Date.now() < deadline) {
+        const response = await fetcher(eventsUrl, {
+            headers: {
+                ...headers,
+                accept: "text/event-stream",
+                ...(lastId ? { "last-event-id": lastId } : {}),
+            },
+            signal: AbortSignal.timeout(Math.max(1_000, deadline - Date.now())),
+        });
+        if (!response.ok || !response.body)
+            throw new Error(`the API answered ${response.status} to the check's events`);
+        for await (const message of serverSentEvents(response.body)) {
+            if (message.id)
+                lastId = message.id;
+            let event;
+            try {
+                event = JSON.parse(message.data);
+            }
+            catch {
+                continue;
+            }
+            // The first stream starts from the beginning: skip what the POST already showed.
+            if (skip > 0) {
+                skip--;
+                continue;
+            }
+            onEvent(event);
+            if (event.type === "result") {
+                const { type: _type, ...result } = event;
+                void _type;
+                return result;
+            }
+        }
+        skip = 0;
+    }
+    throw new Error("the check didn't finish in time; see it on your agent's page");
+}
+/** Server-sent events from a response body: each message's `id` and `data`. */
+export async function* serverSentEvents(body) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let id;
+    let data = [];
+    for await (const chunk of body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        let newline;
+        while ((newline = buffer.indexOf("\n")) >= 0) {
+            const line = buffer.slice(0, newline).replace(/\r$/, "");
+            buffer = buffer.slice(newline + 1);
+            if (line === "") {
+                if (data.length)
+                    yield { ...(id ? { id } : {}), data: data.join("\n") };
+                data = [];
+                id = undefined;
+            }
+            else if (line.startsWith("data:"))
+                data.push(line.slice(5).replace(/^ /, ""));
+            else if (line.startsWith("id:"))
+                id = line.slice(3).trim();
+        }
+    }
+    if (data.length)
+        yield { ...(id ? { id } : {}), data: data.join("\n") };
+}
+/** One check event as a line for the terminal (the web app's wording). */
+export function eventLine(event) {
+    switch (event.type) {
+        case "started":
+            return "Episode started: your agent got its task";
+        case "tool": {
+            const surface = event.surface ? ` (read ${event.surface})` : "";
+            return event.ok
+                ? `Called ${event.name}${surface}`
+                : `Called ${event.name}${surface}: ${event.error ?? "it failed"}`;
+        }
+        case "tx":
+            return event.ok
+                ? "Sent a transaction to its vault"
+                : `A transaction was refused: ${event.reason ?? "no reason given"}`;
+        case "done": {
+            const exit = event.exitCode === undefined || event.exitCode === null
+                ? ""
+                : `, exit code ${event.exitCode}`;
+            return `Finished after ${(event.durationMs / 1000).toFixed(1)} s${exit}`;
+        }
+        case "result":
+            return event.passed ? "The check passed" : "The check found problems";
+    }
+}
+/** Where each problem's fix is explained, by its code (the anchor). */
+export const TROUBLESHOOTING_URL = "https://bonded-nu.vercel.app/docs/guides/troubleshooting/";
+/** The result as lines: the verdict, then each problem and warning, with its fix's link. */
+export function resultLines(result) {
+    const line = (kind, text) => {
+        const code = result.issues?.find((i) => i.message === text && i.severity === kind)?.code;
+        return code && code !== "other" && /^[a-z0-9-]+$/.test(code)
+            ? [`  ${kind}: ${text}`, `    how to fix: ${TROUBLESHOOTING_URL}#${code}`]
+            : [`  ${kind}: ${text}`];
+    };
+    return [
+        result.passed ? "Connection check passed: a rating will work." : "Connection check failed:",
+        ...result.problems.flatMap((p) => line("problem", p)),
+        ...(result.warnings ?? []).flatMap((w) => line("warning", w)),
+        `  ${result.toolsCalled} tool call${result.toolsCalled === 1 ? "" : "s"}, task ${result.taskCompleted ? "done" : "not done"}${result.surfacesRead.length ? `, read ${result.surfacesRead.join(", ")}` : ""}`,
+    ];
+}
+//# sourceMappingURL=check.js.map

package/dist/init/command.d.ts

@@ -0,0 +1,34 @@
+import { AgentMode } from "@bondedhq/shared";
+import { type CheckTarget } from "./check.js";
+import { type Project } from "./detect.js";
+export declare const INIT_USAGE: string;
+export interface InitIO {
+    cwd: string;
+    env: Record<string, string | undefined>;
+    out: (line: string) => void;
+    err: (line: string) => void;
+    /** Asks a yes/no question; undefined when there is no terminal to ask in. */
+    confirm?: (question: string) => Promise<boolean>;
+    /** Runs a command (the package install). */
+    run?: (command: string[], cwd: string) => Promise<number>;
+    /** Starts the runner and resolves when it stops (tests replace it). */
+    connect?: (options: ConnectOptions) => Promise<number>;
+}
+export interface ConnectOptions {
+    gateway: string;
+    token: string;
+    mode: AgentMode;
+    command: string[];
+    cwd: string;
+    check?: CheckTarget;
+    out: (line: string) => void;
+    err: (line: string) => void;
+}
+export declare function initCommand(argv: string[], io: InitIO): Promise<number>;
+/** Why an API URL can't be used: it must be https, except on this machine. */
+export declare function apiUrlProblem(api: string): string | undefined;
+/** The agent's command: what came after --, else the package.json start script. */
+export declare function agentCommand(project: Project, given: string[]): string[];
+/** Asks on the terminal; undefined when stdin isn't one. */
+export declare function terminalConfirm(): InitIO["confirm"];
+//# sourceMappingURL=command.d.ts.map

package/dist/init/command.js

@@ -0,0 +1,314 @@
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+import { AgentMode } from "@bondedhq/shared";
+import { codeIdentity } from "../code-hash.js";
+import { Runner } from "../runner.js";
+import { gatewayUrlProblem } from "../tail.js";
+import { appendEnvNames, applyPlan, installCommand, run } from "./apply.js";
+import { DEFAULT_API_URL, eventLine, resultLines, runConnectionCheck, } from "./check.js";
+import { detectProject, FRAMEWORKS } from "./detect.js";
+import { unifiedDiff } from "./diff.js";
+import { frameworkLine, planInit } from "./plan.js";
+export const INIT_USAGE = `Usage: bonded-runner init [folder] [options] [-- <agent command...>]
+
+Run in your agent's folder. Finds its framework, then proposes the changes that connect it to
+Bonded, as a diff, and asks before writing anything:
+  - the rating hook: while Bonded rates the agent, it uses the episode's tools;
+  - trading through your Mandate Vault in production (once BONDED_VAULT_ADDRESS is set).
+On yes it writes them and adds @bondedhq/sdk with your package manager.
+
+  --print              print the proposed changes and exit; write nothing
+  --yes, -y            apply without asking
+  --framework <name>   skip detection: ${FRAMEWORKS.filter((f) => f !== "python").join(", ")}
+  --url                also add an Agent URL route (Next.js, Express, Hono, or a node:http server)
+  --env                append the new variables' names, with empty values, to .env
+  --skip-install       don't add @bondedhq/sdk
+  --overwrite-generated
+                       rewrite files init wrote before even if you edited them (the diff shows
+                       what goes). Without it, an edited file is kept
+
+Connect right after (optional). With a runner token and the gateway, init starts the runner
+with the agent command after -- (or your package.json start script) and, once it is connected,
+runs a connection check with the runner token and prints its events and result:
+  BONDED_RUNNER_TOKEN  your runner token, from your agent's page. Prefer this to --token, which
+                       anyone on the machine can read in the process list
+  --token <token>      the same, on the command line
+  --gateway <url>      the Arena Gateway (or BONDED_GATEWAY_URL)
+  --mode tools|chain   default tools
+  --api <url>          the Bonded API (or BONDED_API_URL); default ${DEFAULT_API_URL}
+  --skip-check         start the runner without running a check
+  --session <token>    the older way: check with your session token (or BONDED_SESSION_TOKEN)
+  --preview <id> | --agent <id>
+                       and the preview or agent to check (needed only with --session)
+
+Example:
+  npx @bondedhq/runner init
+  BONDED_RUNNER_TOKEN=... npx @bondedhq/runner init --yes --gateway https://arena.example.com -- node agent.js`;
+export async function initCommand(argv, io) {
+    const dash = argv.indexOf("--");
+    const own = dash >= 0 ? argv.slice(0, dash) : argv;
+    const command = dash >= 0 ? argv.slice(dash + 1) : [];
+    let values;
+    let positionals;
+    try {
+        ({ values, positionals } = parseArgs({
+            args: own,
+            allowPositionals: true,
+            options: {
+                print: { type: "boolean", default: false },
+                yes: { type: "boolean", short: "y", default: false },
+                framework: { type: "string" },
+                url: { type: "boolean", default: false },
+                env: { type: "boolean", default: false },
+                "skip-install": { type: "boolean", default: false },
+                "overwrite-generated": { type: "boolean", default: false },
+                token: { type: "string" },
+                gateway: { type: "string" },
+                mode: { type: "string", default: "tools" },
+                api: { type: "string" },
+                "skip-check": { type: "boolean", default: false },
+                session: { type: "string" },
+                preview: { type: "string" },
+                agent: { type: "string" },
+                help: { type: "boolean", short: "h", default: false },
+            },
+        }));
+    }
+    catch (error) {
+        io.err(`${error instanceof Error ? error.message : String(error)}\n\n${INIT_USAGE}`);
+        return 1;
+    }
+    if (values.help) {
+        io.out(INIT_USAGE);
+        return 0;
+    }
+    if (values.framework && !FRAMEWORKS.includes(values.framework)) {
+        io.err(`--framework must be one of ${FRAMEWORKS.join(", ")}`);
+        return 1;
+    }
+    const mode = AgentMode.safeParse(values.mode);
+    if (!mode.success) {
+        io.err("--mode must be tools or chain");
+        return 1;
+    }
+    const root = resolve(io.cwd, positionals[0] ?? ".");
+    const project = detectProject(root, values.framework);
+    const plan = planInit(project, {
+        url: values.url,
+        overwriteGenerated: values["overwrite-generated"],
+    });
+    printPlan(project, plan, io.out);
+    const install = values["skip-install"] ? [] : plan.install;
+    const installCmd = install.length ? installCommand(project.packageManager, install) : undefined;
+    const hasWork = plan.changes.length > 0 || installCmd !== undefined || values.env;
+    if (values.print)
+        return 0;
+    if (hasWork) {
+        let yes = values.yes;
+        if (!yes) {
+            if (!io.confirm) {
+                io.out("\nNothing written: not a terminal. Run again with --yes to apply, or --print to only print.");
+                return 0;
+            }
+            const what = [
+                plan.changes.length
+                    ? `write ${plan.changes.length} file${plan.changes.length === 1 ? "" : "s"}`
+                    : "",
+                installCmd ? `run \`${installCmd.join(" ")}\`` : "",
+                values.env ? "append the variable names to .env" : "",
+            ]
+                .filter(Boolean)
+                .join(", ");
+            yes = await io.confirm(`\n${capitalise(what)}?`);
+        }
+        if (!yes) {
+            io.out("Nothing written.");
+            return 0;
+        }
+        try {
+            for (const path of applyPlan(root, plan))
+                io.out(`wrote ${path}`);
+            if (values.env) {
+                const added = appendEnvNames(root, plan.env);
+                io.out(added.length
+                    ? `added to .env: ${added.join(", ")} (empty: fill them in)`
+                    : ".env already names them all");
+            }
+        }
+        catch (error) {
+            io.err(error instanceof Error ? error.message : String(error));
+            return 1;
+        }
+        if (installCmd) {
+            io.out(`\n$ ${installCmd.join(" ")}`);
+            const code = await (io.run ?? run)(installCmd, root);
+            if (code !== 0) {
+                io.err(`\`${installCmd.join(" ")}\` failed (exit ${code}). Run it yourself, then start your agent.`);
+                return 1;
+            }
+        }
+    }
+    const token = values.token ?? io.env.BONDED_RUNNER_TOKEN;
+    const gateway = values.gateway ?? io.env.BONDED_GATEWAY_URL;
+    if (!token || !gateway) {
+        io.out(`\nNext: start the runner with your runner token (from your agent's page):\n  BONDED_RUNNER_TOKEN=... npx @bondedhq/runner --gateway <gateway url>${mode.data === "chain" ? " --mode chain" : ""} -- ${agentCommand(project, command).join(" ") || "<your agent command>"}\nthen run a connection check on the page. Or run init again with BONDED_RUNNER_TOKEN and --gateway: it starts the runner and runs the check here.`);
+        return 0;
+    }
+    const problem = gatewayUrlProblem(gateway);
+    if (problem) {
+        io.err(problem);
+        return 1;
+    }
+    const agent = agentCommand(project, command);
+    if (!agent.length) {
+        io.err("No agent command: put it after -- (e.g. -- node agent.js), or add a start script to package.json.");
+        return 1;
+    }
+    if (values.token)
+        io.err("Note: a token given with --token shows in the process list. Next time, set BONDED_RUNNER_TOKEN instead.");
+    const api = (values.api ?? io.env.BONDED_API_URL ?? DEFAULT_API_URL).trim();
+    const apiProblem = apiUrlProblem(api);
+    if (apiProblem) {
+        io.err(apiProblem);
+        return 1;
+    }
+    const session = values.session ?? io.env.BONDED_SESSION_TOKEN;
+    const subject = values.preview
+        ? { kind: "preview", id: values.preview }
+        : values.agent
+            ? { kind: "agent", id: values.agent }
+            : undefined;
+    // The runner token names what to check; a session and a subject is the older way, still read.
+    const check = values["skip-check"]
+        ? undefined
+        : session && subject
+            ? { api, session, subject }
+            : { api, runnerToken: token };
+    return (io.connect ?? connect)({
+        gateway,
+        token,
+        mode: mode.data,
+        command: agent,
+        cwd: root,
+        ...(check ? { check } : {}),
+        out: io.out,
+        err: io.err,
+    });
+}
+/** Why an API URL can't be used: it must be https, except on this machine. */
+export function apiUrlProblem(api) {
+    let url;
+    try {
+        url = new URL(api);
+    }
+    catch {
+        return `--api must be a URL, e.g. ${DEFAULT_API_URL}`;
+    }
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol === "https:" || (url.protocol === "http:" && local))
+        return undefined;
+    return "--api must be https (plain http only on localhost)";
+}
+/** The agent's command: what came after --, else the package.json start script. */
+export function agentCommand(project, given) {
+    if (given.length)
+        return given;
+    if (project.scripts.start)
+        return [project.packageManager, "run", "start"];
+    return [];
+}
+function printPlan(project, plan, out) {
+    out(`Framework: ${frameworkLine(project)}`);
+    out(`Package manager: ${project.packageManager}${project.typescript ? ", TypeScript" : ""}`);
+    if (plan.changes.length) {
+        out("\nProposed changes:\n");
+        for (const c of plan.changes) {
+            out(`# ${c.path}${c.before === undefined ? " (new file)" : ""}: ${c.why}`);
+            out(unifiedDiff(c.path, c.before, c.after).trimEnd());
+            out("");
+        }
+    }
+    else
+        out("\nNo file changes needed.");
+    if (plan.install.length)
+        out(`Adds: ${plan.install.join(" ")}`);
+    if (plan.manual.length) {
+        out("\nBy hand (init didn't change these, to be safe):");
+        for (const m of plan.manual)
+            out(m.includes("\n") ? m : `  - ${m}`);
+    }
+    if (plan.notes.length) {
+        out("\nGood to know:");
+        for (const n of plan.notes)
+            out(`  - ${n}`);
+    }
+    if (plan.env.length)
+        out(`\nVariables: ${plan.env.join(", ")}`);
+}
+/** Starts the runner; with a check target, runs a connection check once it is connected. */
+async function connect(options) {
+    const log = (line) => options.err(`[bonded-runner] ${line}`);
+    const code = codeIdentity({ command: options.command, cwd: options.cwd });
+    log(`code hash ${code.codeHash} (${code.codeSource}: ${code.detail})`);
+    let checked = false;
+    let failed = false;
+    const runner = new Runner({
+        code,
+        gateway: options.gateway,
+        token: options.token,
+        mode: options.mode,
+        command: options.command,
+        cwd: options.cwd,
+        log,
+        onConnect: () => {
+            if (checked)
+                return;
+            checked = true;
+            if (!options.check) {
+                options.out("\nConnected. Run a connection check on your agent's page; leave this running for your rating (Ctrl-C stops it).");
+                return;
+            }
+            options.out("\nConnected. Running a connection check...");
+            runConnectionCheck(options.check, (event) => options.out(`  ${eventLine(event)}`)).then((result) => {
+                for (const line of resultLines(result))
+                    options.out(line);
+                if (result.passed)
+                    options.out("Leave the runner running for your rating (Ctrl-C stops it).");
+                else {
+                    failed = true;
+                    void runner.stop();
+                }
+            }, (error) => {
+                options.err(`The connection check couldn't run: ${error instanceof Error ? error.message : String(error)}`);
+                options.out("The runner is still connected: run the check on your agent's page.");
+            });
+        },
+    });
+    const stop = () => void runner.stop();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    const result = await runner.start();
+    if (result.code !== 0)
+        log(result.reason);
+    return failed ? 1 : result.code;
+}
+function capitalise(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+/** Asks on the terminal; undefined when stdin isn't one. */
+export function terminalConfirm() {
+    if (!process.stdin.isTTY)
+        return undefined;
+    return async (question) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = await rl.question(`${question} [y/N] `);
+            return /^y(es)?$/i.test(answer.trim());
+        }
+        finally {
+            rl.close();
+        }
+    };
+}
+//# sourceMappingURL=command.js.map