bottleship 0.1.0-prototype.1 → 0.1.0-prototype.2

package/dist/src/cli.js

@@ -1,94 +1,137 @@
-// bottleship CLI. Built for agents: JSON on stdout, errors are {error, message, fix} with exit 1.
-// Only `init` on a terminal talks to a human.
-import { execFileSync } from "node:child_process";
-import { readdirSync, readFileSync, statSync } from "node:fs";
+// bottleship CLI. The top-level commands are for a person at a terminal; `bottleship agent <cmd>` is for coding agents:
+// JSON on stdout, errors are {error, message, fix} with exit 1.
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { ROOT } from "./paths.js";
-import { BsError, getProvider, loadConfig } from "./config.js";
-import { ask, goneFix, inBox, newBox, openBox, parseId, waitAgent, agentState } from "./boxes.js";
-import { init } from "./init.js";
+import { BsError, loadConfig } from "./config.js";
+import { getProvider, providerNames } from "./provider.js";
+import { agentState, ask, createBox, goneFix, inBox, openBox, parseId, prepare, startAgent, waitAgent } from "./boxes.js";
+import { checkout, dotenvFiles, readRepoEnv, toRepo, workingTree } from "./repo.js";
+import { init, setUp } from "./init.js";
+import { onboardPrompt } from "./onboard.js";
+import { REVIEW_PORT, startReview } from "./review/start.js";
+import { updateReview, waitForComments } from "./review/loop.js";
+import { reviewInTerminal } from "./review/terminal.js";
+import { parsePrRef, parseRepoArg, prRepo, prRepoFromRemote, sameRepo } from "./review/target.js";
 import { c, terminalUI } from "./ui.js";
-import { shq } from "../presets/providers/util.js";
-const HELP = `bottleship: run coding agents in remote sandboxes ("boxes"), like subagents. Output is JSON.
+import { shq } from "./util.js";
+const HELP = `  init [--reset]          set up this machine for boxes, then the repo you are in
+  review [<pr>]           a guided review of a PR (17, owner/name#17 or its link), or of this checkout's changes,
+      [--base <ref>]      in your browser
+  box list                the boxes on this machine, with their reviews
+  box rm [<id>]           removes a box; without an id, asks which
+  help
+
+Your coding agent uses the rest: bottleship agent help
+README: ${join(ROOT, "README.md")}`;
+const AGENT_HELP = `bottleship agent: the commands for coding agents. Each prints JSON; errors are {error, message, fix} with exit 1, and most results say in "next" what to do next.
 
-  init [--yes] [--provider P] [--agent A] [--git-name N] [--git-email E]
-       [--host H]                  (ssh) the host boxes run on
-       [--i-understand-no-isolation]  (local, ssh) the user accepts agents running unsandboxed
-       [--provider custom --name N]  scaffolds ~/.bottleship/providers/N.ts for your own sandboxes
-       [--reset]                   start over: sets config.json aside as config.json.bak (on a terminal, offers to forget saved logins)
-                                   one-time setup; a human runs it in a terminal, or an agent with --yes
+Boxes
   new "<task>" [--repo owner/name | --no-repo] [--provider P] [--agent A]
-                                   new box: clones the repo (default: the cwd's origin; local: a worktree), starts the agent
+      a box with the repo cloned (default: the cwd's origin), its environment prepared, and an agent working on the task.
+      Write a complete prompt: the task, the context it needs, and what done means, including "work on branch <name>,
+      commit and push as you go, and open a PR when done". The box agent sees nothing of your conversation.
   status <id> [--wait S] [--lines N]
-                                   is the agent running, its exit code and last output lines
-  ask <id> "<message>"             follow-up in the same conversation, once the agent has finished
-  exec <id> [-i] -- <cmd...>       run a command in the box's workspace; -i streams stdin/stdout
-  rm <id>                          destroy the box
-  help
+      whether the box agent is running, its exit code and last output; --wait blocks until it finishes
+  ask <id> "<message>"
+      a follow-up in the same conversation, once the agent has finished
+  exec <id> [-i] -- <cmd...>
+      runs a command in the box's workspace (git log, tests, logs in ~/.bottleship/); one argument is a script,
+      several are argv; -i streams stdin and stdout
+  rm <id>
+      destroys the box, when its work is merged or abandoned. If a box is gone, start a new one on the branch it pushed.
+  list
+      every box on this machine, with its review url if it is a review
+  Treat each box as a subagent you manage, and keep track of the ids you start.
+
+Reviews
+  review <pr> [--repo owner/name] [--provider P] [--agent A]
+      pr: 17, #17, owner/name#17, or the PR's link; a bare number is in the cwd's repo. Returns a url at once: show it
+      to the user. The box agent builds a guided tour of the PR there; status <id> --wait 1800 returns when it is done.
+      The user's comments go into their pending review on GitHub, and the tour's chat goes to the box agent, which
+      commits fixes to the PR's branch when asked.
+  review --note "<what changed and why>" [--base <ref>] [--provider P] [--agent A]
+      the cwd checkout's local changes (commits, uncommitted and untracked files) against where the branch left the
+      default branch, or --base. The checkout stays untouched; the note is checked in the tour like a PR description.
+      Returns a url at once: show it to the user, then run review next <id> in the background.
+  review next <id> [--note "<what changed>" --reply <message id>="<your answer>"...] [--timeout S]
+      local reviews: waits for what the user sends you from the tour's chat, each message with an id, the page and
+      lines it is about, and the conversation so far. Address the messages in the checkout, then run it again with
+      --note and one --reply per message: it brings the checkout into the box, answers, has the box agent refresh the
+      tour, and waits for the next messages. When it returns done, the user has finished: do what their note says.
+
+Setup
+  onboard
+      the instructions for writing this repo's box environment (.bottleship/) with the user
+  onboard --check [--timeout S] [--provider P]
+      builds a box from this working tree, runs .bottleship/setup.sh and start.sh, waits for the ports, returns their URLs
+  init --yes [--provider P] [--agent A] [--git-name N] [--git-email E]
+      sets up this machine without prompts. The user normally runs bottleship init in their own terminal, which also
+      sets up the repo they are in.
+  Secrets: never ask the user to paste one to you. If one is missing, ask them to run bottleship init in their terminal.
 
 README: ${join(ROOT, "README.md")}`;
 const out = (obj) => void process.stdout.write(JSON.stringify(obj, null, 2) + "\n");
-const git = (cwd, ...args) => {
-    try {
-        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-    }
-    catch {
-        return "";
-    }
-};
-// owner/name or a GitHub URL becomes an https clone URL, so the GH_TOKEN helper applies; anything else is cloned as is
-function toRepo(s) {
-    const gh = s.match(/^([\w.-]+\/[\w.-]+?)(?:\.git)?$/) ?? s.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
-    return gh ? { url: `https://github.com/${gh[1]}.git`, label: gh[1] } : { url: s, label: s };
-}
-// .env files at the repo root, minus templates like .env.example
-function dotenvFiles(root) {
-    const names = readdirSync(root).filter((f) => /^\.env/.test(f) && !/\.(example|sample|template)$/.test(f) && statSync(join(root, f)).isFile());
-    return Object.fromEntries(names.map((f) => [f, readFileSync(join(root, f), "utf8")]));
-}
 function args(argv, options = {}) {
     return parseArgs({ args: argv, options, allowPositionals: true, strict: true });
 }
 const need = (v, usage) => {
     if (!v)
-        throw new BsError("bad_request", `usage: bottleship ${usage}`, "bottleship help");
+        throw new BsError("bad_request", `usage: bottleship agent ${usage}`, "bottleship agent help");
     return v;
 };
 async function cmdNew(argv) {
     const { values, positionals } = args(argv, { repo: { type: "string" }, "no-repo": { type: "boolean" }, provider: { type: "string" }, agent: { type: "string" } });
     const prompt = need(positionals.join(" ").trim(), 'new "<task>" [--repo owner/name | --no-repo]');
     const cfg = loadConfig();
-    const origin = git(process.cwd(), "remote", "get-url", "origin");
-    const here = origin ? toRepo(origin) : undefined;
+    const here = checkout(process.cwd());
     let repo;
-    let dotenv = {};
-    // the local checkout, when the task's repo is the cwd's repo
-    let source;
     if (values.repo)
         repo = toRepo(values.repo);
     else if (!values["no-repo"]) {
-        if (!here)
+        if (!here?.origin)
             throw new BsError("no_repo", "this directory has no git origin to clone", "pass --repo owner/name, or --no-repo for an empty workspace");
-        repo = here;
-    }
-    if (repo && repo.url === here?.url) {
-        source = git(process.cwd(), "rev-parse", "--show-toplevel");
-        dotenv = dotenvFiles(source);
+        repo = here.origin;
     }
+    // the local checkout of the task's repo gives the box its .env files and its image
+    const local = repo && here && repo.url === here.origin?.url ? here.root : undefined;
     const agent = values.agent ?? cfg.agent;
-    const b = await newBox(cfg, { provider: values.provider ?? cfg.provider, agent, prompt, repo, dotenv, source });
-    return { id: b.id, provider: b.provider.name, agent, repo: repo?.label ?? null, ...(b.warning && { warning: b.warning }), ...(b.login && { login: b.login }), next: b.login ? loginNext(b.id) : `bottleship status ${b.id} --wait 600` };
+    const b = await createBox(cfg, {
+        provider: values.provider ?? cfg.provider,
+        label: prompt,
+        agent,
+        ...(repo && { workspace: { clone: repo } }),
+        ...(local && { repoEnv: readRepoEnv(local), dotenv: dotenvFiles(local) }),
+    });
+    await startAgent(b, prompt);
+    return { id: b.id, provider: b.provider.name, agent, repo: repo?.label ?? null, next: `bottleship agent status ${b.id} --wait 600` };
+}
+async function cmdCheck(values) {
+    const cfg = loadConfig();
+    const repo = checkout(process.cwd());
+    if (!repo)
+        throw new BsError("no_repo", "this directory is not in a git repository", "run bottleship agent onboard --check from inside the repo");
+    const repoEnv = readRepoEnv(repo.root);
+    if (!repoEnv)
+        throw new BsError("no_repo_env", `${repo.root} has no .bottleship/ yet`, "set it up: bottleship agent onboard gives the instructions");
+    const b = await createBox(cfg, { provider: values.provider ?? cfg.provider, label: "check", workspace: { tar: await workingTree(repo.root) }, repoEnv, dotenv: dotenvFiles(repo.root) });
+    const r = await prepare(b, Number(values.timeout ?? 900));
+    const urls = r.stage === "ready" && b.provider.url ? Object.fromEntries(await Promise.all(repoEnv.ports.map(async (p) => [p, await b.provider.url(b.box, p)]))) : {};
+    return {
+        id: b.id,
+        stage: r.stage,
+        ...(r.message && { message: r.message }),
+        ...(r.log && { log: r.log }),
+        ...(r.stage === "ready" && { urls }),
+        next: r.stage === "ready"
+            ? `open the URLs to confirm the app serves; bottleship agent rm ${b.id} when done`
+            : `fix .bottleship/ and run bottleship agent onboard --check again; inspect with bottleship agent exec ${b.id} -- <cmd> (logs in ~/.bottleship/), then bottleship agent rm ${b.id}`,
+    };
 }
-const loginNext = (id) => `show the user this URL and code; the task starts once they approve. Then bottleship status ${id} --wait 600`;
 function statusNext(id, s) {
     if (s.agent === "running")
-        return `bottleship status ${id} --wait 600`;
-    if (s.agent === "waiting_for_login")
-        return s.login ? loginNext(id) : `bottleship status ${id}`;
-    if (s.agent === "login_failed")
-        return `the agent's login failed or timed out, see log. bottleship ask ${id} "<prompt>" starts a new login; if the task never ran, send the whole task again`;
-    return `bottleship ask ${id} "<follow-up>", or bottleship rm ${id} when done`;
+        return `bottleship agent status ${id} --wait 600`;
+    return `bottleship agent ask ${id} "<follow-up>", or bottleship agent rm ${id} when done`;
 }
 async function cmdStatus(argv) {
     const { values, positionals } = args(argv, { wait: { type: "string" }, lines: { type: "string" } });
@@ -114,10 +157,8 @@ async function cmdAsk(argv) {
     const [id, ...words] = positionals;
     const message = need(words.join(" ").trim(), 'ask <id> "<message>"');
     const b = await openBox(loadConfig(), need(id, 'ask <id> "<message>"'));
-    const login = await ask(b, message);
-    if (login)
-        return { id: b.id, agent: "waiting_for_login", login, next: loginNext(b.id) };
-    return { id: b.id, agent: "running", next: `bottleship status ${b.id} --wait 600` };
+    await ask(b, message);
+    return { id: b.id, agent: "running", next: `bottleship agent status ${b.id} --wait 600` };
 }
 // one argument is a script, several are a command whose arguments are passed literally
 async function cmdExec(argv) {
@@ -134,9 +175,7 @@ async function cmdExec(argv) {
         process.exitCode = r.code ?? 1;
         return;
     }
-    if (!b.provider.openStream)
-        throw new BsError("no_stream", `provider ${b.provider.name} has no openStream()`, "use exec without -i, or add openStream to the provider");
-    const s = await b.provider.openStream(b.box, script);
+    const s = b.provider.stream(b.box, script);
     process.stdin.pipe(s.stdin);
     s.stdout.pipe(process.stdout);
     s.stderr.pipe(process.stderr);
@@ -149,32 +188,205 @@ async function cmdExec(argv) {
 }
 async function cmdRm(argv) {
     const id = need(args(argv).positionals[0], "rm <id>");
-    const cfg = loadConfig();
-    const { provider, box } = parseId(cfg, id);
-    await (await getProvider(cfg, provider)).destroy(box);
+    const { provider, box } = parseId(loadConfig(), id);
+    await getProvider(provider).destroy(box);
     return { removed: `${provider}:${box}` };
 }
-async function cmdInit(argv, ui) {
-    const { values } = args(argv, { yes: { type: "boolean", short: "y" }, provider: { type: "string" }, host: { type: "string" }, name: { type: "string" }, agent: { type: "string" }, "git-name": { type: "string" }, "git-email": { type: "string" }, "i-understand-no-isolation": { type: "boolean" }, reset: { type: "boolean" } });
-    const result = await init({ provider: values.provider, host: values.host, name: values.name, agent: values.agent, gitName: values["git-name"], gitEmail: values["git-email"], noIsolation: values["i-understand-no-isolation"], reset: values.reset }, ui);
+async function cmdInit(argv) {
+    const { values } = args(argv, { yes: { type: "boolean", short: "y" }, provider: { type: "string" }, agent: { type: "string" }, "git-name": { type: "string" }, "git-email": { type: "string" }, reset: { type: "boolean" } });
+    const result = await init({ provider: values.provider, agent: values.agent, gitName: values["git-name"], gitEmail: values["git-email"], reset: values.reset });
     if (!result.ok)
         process.exitCode = 1;
     return result;
 }
+// the onboarding instructions, or with --check a box that tries them
+async function cmdOnboard(argv) {
+    const { values } = args(argv, { check: { type: "boolean" }, timeout: { type: "string" }, provider: { type: "string" } });
+    if (values.check)
+        return cmdCheck(values);
+    const { root, prompt } = onboardPrompt(process.cwd());
+    return { repo: root, instructions: prompt, next: "follow instructions, working with the user" };
+}
+// the boxes every provider here knows of; a provider without a list script, or one that fails (docker not running), has none
+async function listBoxes() {
+    const all = await Promise.all(providerNames().map(async (name) => {
+        try {
+            const p = getProvider(name);
+            if (!p.list)
+                return [];
+            return await Promise.all((await p.list()).map(async ({ box, created }) => {
+                const review = box.startsWith("bs-review-") && p.url ? await p.url(box, REVIEW_PORT).catch(() => undefined) : undefined;
+                return { id: `${name}:${box}`, ...(created && { created }), ...(review && { review }) };
+            }));
+        }
+        catch {
+            return [];
+        }
+    }));
+    return all.flat().sort((a, b) => (b.created ?? "").localeCompare(a.created ?? ""));
+}
+const ago = (iso) => {
+    if (!iso)
+        return "";
+    const m = Math.round((Date.now() - Date.parse(iso)) / 60000);
+    return m < 60 ? `${m}m ago` : m < 48 * 60 ? `${Math.round(m / 60)}h ago` : `${Math.round(m / 1440)}d ago`;
+};
+// a person's view of the boxes: a list to read, and removing one by id or picked from it
+async function cmdBox(argv, ui) {
+    const [sub, ...rest] = argv;
+    const { positionals } = args(rest);
+    if (sub === "list") {
+        const boxes = await listBoxes();
+        if (!boxes.length)
+            return void process.stdout.write("No boxes.\n");
+        const w = Math.max(...boxes.map((b) => b.id.length));
+        for (const b of boxes)
+            process.stdout.write(`${b.id.padEnd(w)}  ${c.dim(ago(b.created).padEnd(8))}  ${b.review ?? ""}\n`);
+        return;
+    }
+    if (sub === "rm") {
+        let id = positionals[0];
+        if (!id) {
+            const boxes = await listBoxes();
+            if (!boxes.length)
+                return void process.stdout.write("No boxes.\n");
+            id = await ui.choose("Which box should go?", boxes.map((b) => ({ value: b.id, hint: [ago(b.created), b.review].filter(Boolean).join("  ") })), boxes[0].id);
+        }
+        const { provider, box } = parseId(loadConfig(), id);
+        await getProvider(provider).destroy(box);
+        return void process.stdout.write(`Removed ${provider}:${box}\n`);
+    }
+    throw new BsError("bad_request", sub ? `unknown command "box ${sub}"` : "usage: bottleship box list | box rm [<id>]", "bottleship help");
+}
+async function cmdReview(argv, ui) {
+    // a person picks the PR and, for local changes, the base; the rest is the config's, or an agent's to say
+    const { values, positionals } = ui
+        ? args(argv, { base: { type: "string" } })
+        : args(argv, { repo: { type: "string" }, provider: { type: "string" }, agent: { type: "string" }, base: { type: "string" }, note: { type: "string" }, timeout: { type: "string" }, reply: { type: "string", multiple: true } });
+    if (!ui && positionals[0] === "next")
+        return out(await reviewNext(need(positionals[1], "review next <id>"), values));
+    if (!positionals[0])
+        return reviewLocal(values, ui);
+    const ref = parsePrRef(positionals[0]);
+    const flag = values.repo ? parseRepoArg(values.repo) : undefined;
+    if (ref.repo && flag && !sameRepo(ref.repo, flag))
+        throw new BsError("bad_request", `the PR is in ${prRepo(ref.repo).label}, but --repo says ${prRepo(flag).label}`, "drop --repo; the PR link or shorthand already names the repo");
+    const cfg = loadConfig();
+    const here = checkout(process.cwd());
+    // the PR's own repo, else --repo, else the repo this command runs in
+    const named = ref.repo ?? flag;
+    const repo = named ? prRepo(named) : here?.remote ? prRepoFromRemote(here.remote) : undefined;
+    if (!repo)
+        throw new BsError("no_repo", "this directory is not in a git repo with an origin, so it is unclear which repo the PR is in", "run it inside the repo, pass --repo owner/name, or use a PR link or owner/name#17");
+    // the local checkout of the same repo supplies .env files, and .bottleship/ when the PR has none yet
+    const local = here?.remote && prRepoFromRemote(here.remote).label === repo.label ? here.root : undefined;
+    const opts = { source: { pr: { repo, number: ref.number } }, local, provider: values.provider ?? cfg.provider, agent: values.agent ?? cfg.agent };
+    if (ui)
+        return reviewInTerminal(ui, cfg, opts);
+    const r = await startReview(cfg, opts);
+    out({
+        id: r.box.id,
+        url: r.url,
+        pr: r.pr,
+        env: r.env,
+        next: `show the user the url: it says the review is being set up until the box agent has built the tour, then shows it. bottleship agent status ${r.box.id} --wait 1800 returns when the agent is done; bottleship agent ask ${r.box.id} "<follow-up>" for more; bottleship agent rm ${r.box.id} when the review is over`,
+    });
+}
+// the checkout's local changes: the working tree against where its branch left the default branch (or --base)
+async function reviewLocal(values, ui) {
+    const cfg = loadConfig();
+    const here = checkout(process.cwd());
+    if (!here)
+        throw new BsError("no_repo", "this directory is not in a git repo, so there are no local changes to review", "run it inside the repo, or pass a PR: review <pr>");
+    const repo = here.remote ? prRepoFromRemote(here.remote).label : undefined;
+    const opts = { source: { changes: { root: here.root, base: values.base, note: values.note, repo } }, local: here.root, provider: values.provider ?? cfg.provider, agent: values.agent ?? cfg.agent };
+    if (ui)
+        return reviewInTerminal(ui, cfg, opts);
+    const r = await startReview(cfg, opts);
+    out({
+        id: r.box.id,
+        url: r.url,
+        pr: r.pr,
+        env: r.env,
+        next: `show the user the url: it says the review is being set up until the box agent has built the tour, then shows it. Then run bottleship agent review next ${r.box.id} in the background: it returns what the reviewer writes to you in the tour's chat, or that they are done`,
+    });
+}
+// a local review's loop: the agent's update and answers when it has them, then what the reviewer sends next
+async function reviewNext(id, o) {
+    const usage = 'review next <id> [--note "<what changed>" --reply <message id>="<your answer>"...]';
+    const replies = o.reply ?? [];
+    if (replies.length && !o.note?.trim())
+        throw new BsError("bad_request", `usage: bottleship agent ${usage}`, "say in --note what you changed, or that nothing did, for the reviewer");
+    const answers = {};
+    for (const r of replies) {
+        const m = r.match(/^(c\d+)=([\s\S]+)$/);
+        if (!m)
+            throw new BsError("bad_request", `--reply "${r}" is not <message id>=<text>`, 'e.g. --reply c3="Moved the check before the query"');
+        answers[m[1]] = m[2];
+    }
+    const b = await openBox(loadConfig(), id);
+    let sent;
+    if (o.note?.trim()) {
+        const here = checkout(process.cwd());
+        if (!here)
+            throw new BsError("no_repo", "this directory is not in a git repo", "run it in the checkout the review is of");
+        sent = await updateReview(b, here.root, { note: o.note.trim(), answers });
+    }
+    const w = await waitForComments(b, o.timeout === undefined ? undefined : Number(o.timeout));
+    const base = { id: b.id, ...sent, comments: w.comments };
+    if (w.done)
+        return { ...base, done: true, ...(w.done.note && { note: w.done.note }), next: `the reviewer is done${w.comments.length ? ", with these last messages" : ""}: do what they say${w.done.note ? " and what the note says" : ""}, then bottleship agent rm ${b.id}` };
+    if (!w.comments.length)
+        return { ...base, next: `nothing yet: bottleship agent review next ${b.id} again, in the background` };
+    return {
+        ...base,
+        next: `answer each message, changing this checkout only where the reviewer asks you to, then run bottleship agent review next ${b.id} --note "<what changed, or that nothing did>" --reply <message id>="<your answer>" (one --reply per message) in the background: it sends your update and waits for the next messages`,
+    };
+}
+// commands that moved, and where to
+const MOVED = {
+    new: "bottleship agent new", status: "bottleship agent status", ask: "bottleship agent ask", exec: "bottleship agent exec", rm: "bottleship box rm, or for agents bottleship agent rm",
+    check: "bottleship agent onboard --check", onboard: "bottleship init sets up the repo you are in; agents run bottleship agent onboard",
+};
+async function agentCmd(argv) {
+    const [cmd, ...rest] = argv;
+    switch (cmd) {
+        case "new": return out(await cmdNew(rest));
+        case "status": return out(await cmdStatus(rest));
+        case "ask": return out(await cmdAsk(rest));
+        case "exec": return await cmdExec(rest);
+        case "rm": return out(await cmdRm(rest));
+        case "list": return out({ boxes: await listBoxes() });
+        case "review": return await cmdReview(rest);
+        case "onboard": return out(await cmdOnboard(rest));
+        case "init": return out(await cmdInit(rest));
+        case "help":
+        case "--help":
+        case "-h":
+        case undefined:
+            return void process.stdout.write(AGENT_HELP + "\n");
+        default:
+            throw new BsError("bad_request", `unknown command "agent ${cmd}"`, "bottleship agent help");
+    }
+}
+// the top-level commands talk to a person; without a terminal they point the caller to the agent ones
+function terminal(cmd, agentCmd = cmd) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY))
+        throw new BsError("needs_terminal", `bottleship ${cmd} is for a person at a terminal`, `agents run bottleship agent ${agentCmd}; see bottleship agent help`);
+    return terminalUI();
+}
 async function main() {
     const [cmd, ...argv] = process.argv.slice(2);
-    // init talks to a human on a terminal, unless told --yes
-    const ui = cmd === "init" && process.stdin.isTTY && process.stdout.isTTY && !argv.includes("--yes") && !argv.includes("-y") ? terminalUI() : undefined;
+    let ui;
     try {
         switch (cmd) {
-            case "new": return out(await cmdNew(argv));
-            case "status": return out(await cmdStatus(argv));
-            case "ask": return out(await cmdAsk(argv));
-            case "exec": return await cmdExec(argv);
-            case "rm": return out(await cmdRm(argv));
+            case "agent": return await agentCmd(argv);
+            case "review": return await cmdReview(argv, (ui = terminal(cmd)));
+            // plain lines, not the framed setup look
+            case "box": return await cmdBox(argv, terminal(cmd, argv[0] === "rm" ? "rm" : "list"));
             case "init": {
-                const r = await cmdInit(argv, ui);
-                return ui ? undefined : out(r);
+                const { values } = args(argv, { reset: { type: "boolean" } });
+                return await setUp(process.cwd(), { reset: values.reset }, (ui = terminal(cmd)));
             }
             case "help":
             case "--help":
@@ -182,14 +394,16 @@ async function main() {
             case undefined:
                 return void process.stdout.write(HELP + "\n");
             default:
-                throw new BsError("bad_request", `unknown command "${cmd}"`, "bottleship help");
+                throw new BsError("bad_request", `unknown command "${cmd}"`, MOVED[cmd] ? `it moved: ${MOVED[cmd]}` : "bottleship help");
         }
     }
     catch (e) {
         const err = e instanceof BsError ? e
-            : e.code?.startsWith("ERR_PARSE_ARGS") ? new BsError("bad_request", e.message, "bottleship help")
+            : e.code?.startsWith("ERR_PARSE_ARGS") ? new BsError("bad_request", e.message, cmd === "agent" ? "bottleship agent help" : "bottleship help")
                 : new BsError("internal", e.message);
         process.exitCode = 1;
+        if (cmd === "box" && err.code !== "needs_terminal")
+            return void process.stderr.write(`${err.message}\n${err.fix ? c.dim(err.fix) + "\n" : ""}`);
         if (!ui)
             return out(err.toJSON());
         const fix = err.code === "secret_missing" ? "run `bottleship init` again once you have the value" : err.fix;

package/dist/src/config.d.ts

@@ -1,4 +1,4 @@
-import type { AgentSpec, BsErrorJSON, Config, LoadedProvider, SecretSource } from "./types.ts";
+import type { AgentSpec, BsErrorJSON, Config, SecretSource } from "./types.ts";
 export declare class BsError extends Error {
     code: string;
     fix: string | undefined;
@@ -7,9 +7,6 @@ export declare class BsError extends Error {
     toJSON(): BsErrorJSON;
 }
 export declare const DEFAULTS: Config;
-export declare const unisolated: (cfg: Config, provider: string) => boolean;
-export declare const noIsolationAccepted: (cfg: Config, provider: string) => boolean;
-export declare function noIsolationError(provider: string): BsError;
 export declare function readUserConfig(): Partial<Config>;
 export declare function writeUserConfig(raw: Partial<Config>): void;
 export declare function loadConfig(raw?: Partial<Config>): Config;
@@ -23,5 +20,5 @@ export declare function boxEnv(cfg: Config, agentName: string): {
     env: Record<string, string>;
     missing: NamedSecret[];
 };
-export declare function neededSecrets(cfg: Config, providerName: string, agentName: string): NamedSecret[];
-export declare function getProvider(cfg: Config, name: string): Promise<LoadedProvider>;
+export declare function neededSecrets(cfg: Config, agentName: string): NamedSecret[];
+export declare function missingSecrets(names: string[]): BsError;

package/dist/src/config.js

@@ -1,19 +1,9 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-// ~/.bottleship/config.json: personal, never from a repo. Decides providers, agents,
+// ~/.bottleship/config.json: personal, never from a repo. Decides the provider, the agents,
 // the git identity, and which env vars (and secrets) every box gets.
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { CONFIG_FILE, DIST, HOME, ROOT } from "./paths.js";
+import { join } from "node:path";
+import { CONFIG_FILE, HOME, ROOT } from "./paths.js";
 import { readSecret } from "./secrets.js";
-import * as kit from "../presets/providers/util.js";
 // errors agents can act on: a code, a message, and the next step
 export class BsError extends Error {
     code;
@@ -35,24 +25,8 @@ export const DEFAULTS = {
     git: { name: "", email: "" },
     // a fine-grained token for the repos the user picks; init asks for it
     env: { GH_TOKEN: { store: "github" } },
-    providers: {
-        docker: { module: "builtin:docker" },
-        exe: { module: "builtin:exe" },
-        e2b: { module: "builtin:e2b", apiKey: { store: "e2b" } },
-        daytona: { module: "builtin:daytona", apiKey: { store: "daytona" } },
-        modal: { module: "builtin:modal", tokenId: { store: "modal-token-id" }, tokenSecret: { store: "modal-token-secret" } },
-        ssh: { module: "builtin:ssh" },
-        local: { module: "builtin:local" },
-    },
     agents: {},
-    templates: {},
 };
-// providers whose boxes run agents unsandboxed, as the user, so the user has to accept that once in init
-export const unisolated = (cfg, provider) => ["builtin:local", "builtin:ssh"].includes(cfg.providers[provider]?.module ?? "");
-export const noIsolationAccepted = (cfg, provider) => cfg.providers[provider]?.acceptNoIsolation === true;
-export function noIsolationError(provider) {
-    return new BsError("no_isolation_unconfirmed", `the ${provider} provider runs agents with no isolation and with permission prompts off, as the user, and the user has not accepted that`, `ask the user to run \`bottleship init --provider ${provider}\` in their terminal and confirm, or pick an isolated provider (docker, e2b, daytona, modal, exe)`);
-}
 function builtinAgents() {
     const dir = join(ROOT, "presets/agents");
     const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
@@ -65,38 +39,25 @@ export function writeUserConfig(raw) {
     mkdirSync(HOME, { recursive: true });
     writeFileSync(CONFIG_FILE, JSON.stringify(raw, null, 2) + "\n");
 }
-// providers merge over the builtins, and each agent over its builtin; env replaces the default so entries can be dropped
+// each agent merges over its builtin; env replaces the default so entries can be dropped
 export function loadConfig(raw = readUserConfig()) {
-    return {
-        ...DEFAULTS,
-        ...raw,
-        git: { ...DEFAULTS.git, ...raw.git },
-        providers: { ...DEFAULTS.providers, ...raw.providers },
-        agents: mergeAgents(builtinAgents(), raw.agents ?? {}),
-    };
-}
-// a user entry for a builtin agent overrides its fields, and login's, so { "login": { "use": "token" } } is enough
-function mergeAgents(builtin, user) {
-    const agents = { ...builtin };
-    for (const [name, spec] of Object.entries(user)) {
-        const login = builtin[name]?.login || spec.login ? { ...builtin[name]?.login, ...spec.login } : undefined;
-        agents[name] = { ...builtin[name], ...spec, ...(login && { login }) };
-    }
-    return agents;
-}
-// the env var that logs a box's agent in on the token route; the device route logs in inside the box
-function loginEnv(cfg, agentName) {
-    const l = getAgent(cfg, agentName).login;
-    return l?.use === "token" && l.token ? { [l.token.env]: { store: l.token.store } } : {};
+    const agents = builtinAgents();
+    for (const [name, spec] of Object.entries(raw.agents ?? {}))
+        agents[name] = { ...agents[name], ...spec };
+    return { ...DEFAULTS, ...raw, git: { ...DEFAULTS.git, ...raw.git }, agents };
 }
-// the agent's env, its login token, then config env over both
-const allEnv = (cfg, agentName) => ({ ...getAgent(cfg, agentName).env, ...loginEnv(cfg, agentName), ...cfg.env });
 export function getAgent(cfg, name) {
     const a = cfg.agents[name];
     if (!a)
         throw new BsError("unknown_agent", `no agent "${name}"`, `known: ${Object.keys(cfg.agents).join(", ")}. Add one under "agents" in ${CONFIG_FILE}`);
     return a;
 }
+// the agent's env, its login token, then config env over both
+function allEnv(cfg, agentName) {
+    const agent = getAgent(cfg, agentName);
+    const login = agent.login ? { [agent.login.env]: { store: agent.login.store } } : {};
+    return { ...agent.env, ...login, ...cfg.env };
+}
 export const isSource = (v) => typeof v === "object" && v !== null && ["store", "command", "env"].some((k) => typeof v[k] === "string");
 // the env every box of this agent gets, read now; missing secrets are listed, not thrown
 export function boxEnv(cfg, agentName) {
@@ -115,37 +76,10 @@ export function boxEnv(cfg, agentName) {
     }
     return { env, missing };
 }
-// every secret a box of this provider and agent needs: the provider's own API keys, the box env and the agent's login
-export function neededSecrets(cfg, providerName, agentName) {
-    const fromProvider = Object.entries(cfg.providers[providerName] ?? {}).filter(([, v]) => isSource(v)).map(([k, v]) => ({ name: `providers.${providerName}.${k}`, source: v }));
-    const fromEnv = Object.entries(allEnv(cfg, agentName)).filter(([, v]) => isSource(v)).map(([name, v]) => ({ name, source: v }));
-    return [...fromProvider, ...fromEnv];
+// every secret a box of this agent needs: the box env and the agent's login
+export function neededSecrets(cfg, agentName) {
+    return Object.entries(allEnv(cfg, agentName)).filter(([, v]) => isSource(v)).map(([name, v]) => ({ name, source: v }));
 }
-// providers.<name> = { module, ...options }; module is "builtin:<preset>", an absolute path, or relative to HOME (.mjs or .ts)
-export async function getProvider(cfg, name) {
-    const spec = cfg.providers[name];
-    if (!spec)
-        throw new BsError("unknown_provider", `no provider "${name}"`, `known: ${Object.keys(cfg.providers).join(", ")}. Add one under "providers" in ${CONFIG_FILE}`);
-    const { module, ...options } = spec;
-    const file = module.startsWith("builtin:")
-        ? join(DIST, "presets/providers", `${module.slice("builtin:".length)}.js`)
-        : isAbsolute(module) ? module : resolve(HOME, module);
-    const bad = (msg) => new BsError("bad_provider", `provider "${name}" (${file}) ${msg}`, `fix providers.${name}.module in ${CONFIG_FILE}`);
-    if (module.startsWith("builtin:") && !existsSync(file))
-        throw new BsError("bad_provider", `${module} is not in this version of bottleship`, "update bottleship, or pick another provider with `bottleship init --provider <name>`");
-    let factory;
-    try {
-        factory = (await import(__rewriteRelativeImportExtension(pathToFileURL(file).href))).default;
-    }
-    catch (e) {
-        throw bad(`failed to load: ${e.message}`);
-    }
-    if (typeof factory !== "function")
-        throw bad("has no default export function");
-    const ctx = { name, options, secret: readSecret, log: (...a) => console.error(`[${name}]`, ...a), kit };
-    const provider = { name, ...(await factory(ctx)) };
-    for (const m of ["create", "exec", "destroy"])
-        if (typeof provider[m] !== "function")
-            throw bad(`has no ${m}()`);
-    return provider;
+export function missingSecrets(names) {
+    return new BsError("secret_missing", `no value for ${names.join(", ")}`, "ask the user to run `bottleship init` in their terminal; it asks for missing secrets with a hidden prompt. Never ask the user to paste a secret to you", { missing: names });
 }