@outerlayer/cli 0.2.0 → 0.4.0

package/dist/import-capture-cmd-AVZ4VIVJ.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { loadMaintainedFiles, writeMaintainedFiles } from './chunk-WO2BXCTQ.js';
+import './chunk-EMY4I27X.js';
+import './chunk-RA3O54FC.js';
+import './chunk-Z5GEFMRW.js';
+import { statSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var GREEN = "\x1B[32m";
+var DIM = "\x1B[2m";
+var YELLOW = "\x1B[33m";
+var RESET = "\x1B[0m";
+var ImportCaptureError = class extends Error {
+};
+var SNIPPET_PATH = ".outerlayer/skills/emitting-evidence/references/agents-snippet.md";
+var AGENTS_MD_PATH = ".outerlayer/AGENTS.md";
+var AGENTS_MD_MARKER = "<!-- outerlayer:capture-pack -->";
+function runImportCapture(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  let cwdStat;
+  try {
+    cwdStat = statSync(cwd);
+  } catch {
+    throw new ImportCaptureError(`no such directory: ${cwd}`);
+  }
+  if (!cwdStat.isDirectory()) throw new ImportCaptureError(`not a directory: ${cwd}`);
+  const bundle = loadMaintainedFiles();
+  const { created: files, rewritten } = writeMaintainedFiles(cwd, bundle);
+  const snippet = bundle.find((f) => f.path === SNIPPET_PATH)?.content ?? "";
+  let appendedAgentsMd = false;
+  const agentsMdAbs = join(cwd, AGENTS_MD_PATH);
+  if (existsSync(agentsMdAbs)) {
+    const existing = readFileSync(agentsMdAbs, "utf8");
+    if (!existing.includes(AGENTS_MD_MARKER)) {
+      writeFileSync(agentsMdAbs, existing + "\n" + snippet);
+      appendedAgentsMd = true;
+    }
+  }
+  let output;
+  if (opts.json) {
+    output = JSON.stringify({ files, rewritten, appendedAgentsMd });
+  } else {
+    const lines = [
+      ...files.map((f) => `${GREEN}\u2713${RESET} wrote ${f}`),
+      ...rewritten.map((f) => `${YELLOW}!${RESET} rewrote ${f} to match this CLI's bundle (local edits were overwritten)`)
+    ];
+    if (appendedAgentsMd) lines.push(`${GREEN}\u2713${RESET} appended the evidence snippet to ${AGENTS_MD_PATH}`);
+    if (files.length === 0 && rewritten.length === 0 && !appendedAgentsMd) {
+      lines.push(`${DIM}capture pack already installed \u2014 nothing to write${RESET}`);
+    }
+    lines.push(`Run ${YELLOW}\`outerlayer emit\`${RESET} to compile the pack into your agent's native files.`);
+    output = lines.join("\n");
+  }
+  if (!opts.quiet) {
+    process.stdout.write(output + "\n");
+    if (!opts.json && !appendedAgentsMd && !existsSync(agentsMdAbs)) {
+      process.stdout.write(
+        `${DIM}  no ${AGENTS_MD_PATH} to append to \u2014 paste ${SNIPPET_PATH} into your instructions file if your harness reads no skills${RESET}
+`
+      );
+    }
+  }
+  return { files, rewritten, appendedAgentsMd, output };
+}
+
+export { ImportCaptureError, runImportCapture };

package/dist/{import-ruler-cmd-7LH2QOMG.js → import-ruler-cmd-GUHL6IY5.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { normalizePath } from './chunk-KFYJV2ZG.js';
+import { normalizePath } from './chunk-EMY4I27X.js';
 import './chunk-Z5GEFMRW.js';
 import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';

package/dist/index.js

@@ -6,20 +6,20 @@ createRequire(import.meta.url);
 // src/index.ts
 var argv = process.argv.slice(2);
 if (argv[0] === "hook") {
-  const { runHookFast } = await import('./hook-fast-J5LCDHUJ.js');
+  const { runHookFast } = await import('./hook-fast-EYENPK6F.js');
   await runHookFast(argv[1]);
   process.exit(0);
 }
 if (argv[0] === "hook-wrap") {
-  const { runHookWrapFast, parseHookWrapArgs } = await import('./hook-wrap-fast-KXYNX3AD.js');
+  const { runHookWrapFast, parseHookWrapArgs } = await import('./hook-wrap-fast-NPLHJXFK.js');
   const { id, captureOutput } = parseHookWrapArgs(argv.slice(1));
   const code = await runHookWrapFast(id, { captureOutput });
   process.exit(code);
 }
 if (argv[0] === "statusline") {
-  const { runStatuslineFast } = await import('./statusline-fast-3C5OXHDD.js');
+  const { runStatuslineFast } = await import('./statusline-fast-SVTMBMD7.js');
   await runStatuslineFast(argv.slice(1));
   process.exit(0);
 }
-var { runCli } = await import('./cli-G7DILYJY.js');
+var { runCli } = await import('./cli-NHUXABYH.js');
 await runCli(process.argv);

package/dist/init-DXBCOAJK.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { PLACEHOLDER_MARKER, RunnerInitError, isPlaceholderCommand, readConfigObject, runRunnerInit } from './chunk-CBZB6XY6.js';
+import './chunk-L2DBRKRA.js';
+import './chunk-7A6RVXPZ.js';
+import './chunk-ZNA27WEV.js';
+import './chunk-N5FOE5PS.js';
+import './chunk-OGFGZQA3.js';
+import './chunk-774HEQL6.js';
+import './chunk-QOZKPLVJ.js';
+import './chunk-W4SQCOZU.js';
+import './chunk-B2G7JHHB.js';
+import './chunk-5DLBAXY5.js';
+import './chunk-BFESLKPP.js';
+import './chunk-6Y63SXFO.js';
+import './chunk-G7FSV7JX.js';
+import './chunk-F6GFZXZ3.js';
+import './chunk-AUFG23AA.js';
+import './chunk-WZBHBH3J.js';
+import './chunk-XDDW4FRS.js';
+import './chunk-WIOZAJ2W.js';
+import './chunk-WO2BXCTQ.js';
+import './chunk-EMY4I27X.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-BCLJSQCV.js';
+import './chunk-BOLTI6LR.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-RA3O54FC.js';
+import './chunk-M5POMKKW.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-XCCLFVXM.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/init-YEXK35CF.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { execStartCommand } from './chunk-YYYXRJUW.js';
+import { writeLaunchAgent } from './chunk-LF6MLJCY.js';
+import { readConfigObject, RunnerInitError, isPlaceholderCommand } from './chunk-CBZB6XY6.js';
+import './chunk-L2DBRKRA.js';
+import './chunk-7A6RVXPZ.js';
+import './chunk-ZNA27WEV.js';
+import './chunk-N5FOE5PS.js';
+import './chunk-OGFGZQA3.js';
+import './chunk-774HEQL6.js';
+import './chunk-QOZKPLVJ.js';
+import './chunk-W4SQCOZU.js';
+import './chunk-B2G7JHHB.js';
+import './chunk-5DLBAXY5.js';
+import './chunk-BFESLKPP.js';
+import './chunk-6Y63SXFO.js';
+import './chunk-G7FSV7JX.js';
+import { resolveBuild } from './chunk-5Y3QQRUH.js';
+import { parseSize } from './chunk-F6GFZXZ3.js';
+import './chunk-AUFG23AA.js';
+import './chunk-WZBHBH3J.js';
+import './chunk-XDDW4FRS.js';
+import './chunk-WIOZAJ2W.js';
+import './chunk-WO2BXCTQ.js';
+import './chunk-EMY4I27X.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-BCLJSQCV.js';
+import './chunk-BOLTI6LR.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-RA3O54FC.js';
+import './chunk-M5POMKKW.js';
+import { hostKeyPath } from './chunk-ZM2IMMYN.js';
+import './chunk-XCCLFVXM.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { readFileSync, writeFileSync, existsSync, rmSync } from 'fs';
+
+createRequire(import.meta.url);
+
+// src/runner/vm/service.ts
+var VM_SERVICE_NAME = "outerlayer-runner";
+var STOP_MARGIN_MINUTES = 10;
+function runnerUnit(unit) {
+  const dir = `${unit.home}/.outerlayer`;
+  return `[Unit]
+Description=OuterLayer runner
+After=network-online.target docker.service
+Wants=network-online.target
+Requires=docker.service
+
+[Service]
+User=${unit.user}
+ExecStart=${unit.execStart}
+EnvironmentFile=-${dir}/runner.env
+Restart=on-failure
+RestartForceExitStatus=75
+RestartSec=30
+KillSignal=SIGTERM
+KillMode=mixed
+TimeoutStopSec=${unit.timeLimitMinutes + STOP_MARGIN_MINUTES}min
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+
+// src/runner/vm/sizing.ts
+var GIB = 1024 ** 3;
+var EXTRA_CPUS = 1;
+var EXTRA_MEMORY_GIB = 2;
+var EXTRA_DISK_GIB = 30;
+var gib = (size) => parseSize(size) / GIB;
+function sizeVm(build, concurrency, host) {
+  return {
+    cpus: Math.max(1, Math.min(Math.ceil(build.cpus * concurrency) + EXTRA_CPUS, host.cpus)),
+    memoryGiB: Math.max(1, Math.min(Math.ceil(gib(build.memory) * concurrency) + EXTRA_MEMORY_GIB, Math.floor(host.memoryBytes / GIB))),
+    diskGiB: Math.ceil(gib(build.disk) * concurrency) + EXTRA_DISK_GIB
+  };
+}
+
+// src/runner/vm/init.ts
+var VM_INSTANCE = "outerlayer-runner";
+var VmInitError = class extends Error {
+};
+var MIN_NODE_MAJOR = 22;
+var DEFAULT_TIME_LIMIT_MINUTES = 480;
+var TARBALL_IN_VM = "/tmp/outerlayer-cli.tgz";
+var NODE_VERSION = /^v(\d+)\./;
+var quote = (text) => `'${text.replace(/'/g, `'\\''`)}'`;
+function commandsAreReal(block) {
+  const commands = block?.commands ?? {};
+  const given = [commands.implement, commands.amend].filter((command) => typeof command === "string");
+  return given.length > 0 && given.every((command) => !isPlaceholderCommand(command));
+}
+async function runVmInit(configPath, deps) {
+  const { lima } = deps;
+  const instance = deps.instance ?? VM_INSTANCE;
+  const progress = deps.progress ?? (() => void 0);
+  const limactl = lima.locate();
+  if (limactl === void 0) {
+    throw new VmInitError(
+      "limactl is not installed, and the Linux VM needs it. Install Lima with `brew install lima` (https://lima-vm.io/docs/installation/), then run this again."
+    );
+  }
+  const config = readConfigObject(configPath);
+  const noted = config.runnerVm;
+  if (noted !== void 0) {
+    throw new RunnerInitError(
+      `${configPath}: the runner already lives in the VM ${noted.instance}. Start it with \`limactl start ${noted.instance}\`, or remove the runnerVm key after deleting the VM.`
+    );
+  }
+  if (typeof config.url !== "string" || typeof config.apiKey !== "string" || typeof config.appId !== "string") {
+    throw new RunnerInitError(`${configPath}: url, apiKey and appId are needed to move the runner into a VM. Run \`outerlayer login\` first.`);
+  }
+  const block = config.runner;
+  const { hooks: _ownHooks, ...carried } = block ?? {};
+  for (const hook of [block?.hooks?.provision, block?.hooks?.cleanup]) {
+    if (hook !== void 0 && hook !== "builtin:process") {
+      throw new RunnerInitError(
+        `${configPath}: the runner block names its own hooks (${hook}), and only a builtin:process block moves into the VM. Remove the block and run this again.`
+      );
+    }
+  }
+  if (lima.status(instance) !== void 0) {
+    throw new VmInitError(
+      `a Lima instance named ${instance} already exists. Delete it with \`limactl delete --force ${instance}\`, or use it, then run this again.`
+    );
+  }
+  const build = resolveBuild(configPath, carried.build);
+  const concurrency = typeof carried.concurrency === "number" ? carried.concurrency : 1;
+  const timeLimitMinutes = typeof carried.timeLimitMinutes === "number" ? carried.timeLimitMinutes : DEFAULT_TIME_LIMIT_MINUTES;
+  const size = sizeVm(build, concurrency, { cpus: deps.hostCpus, memoryBytes: deps.hostMemoryBytes });
+  const leftBehind = `The VM ${instance} was left as it is; delete it with \`limactl delete --force ${instance}\` to start over.`;
+  const failed = (what, result) => new VmInitError(`${what} failed: ${result.stderr.trim() || result.stdout.trim() || `exit status ${result.status}`}. ${leftBehind}`);
+  const sh = async (argv, stdin) => {
+    const result = await lima.shell(instance, argv, stdin === void 0 ? void 0 : { stdin });
+    if (result.status !== 0) throw failed(`the VM step \`${argv.join(" ")}\``, result);
+    return result.stdout;
+  };
+  progress(`creating the Linux VM ${instance}: this downloads an image and can take several minutes`);
+  const created = await lima.create({ instance, cpus: size.cpus, memoryGiB: size.memoryGiB, diskGiB: size.diskGiB });
+  if (created.status !== 0) throw failed("`limactl create`", created);
+  progress("starting the VM");
+  const started = await lima.start(instance);
+  if (started.status !== 0) throw failed("`limactl start`", started);
+  const user = (await sh(["id", "-un"])).trim();
+  const home = (await sh(["printenv", "HOME"])).trim();
+  progress("installing Node and the OuterLayer CLI in the VM");
+  await sh(["sudo", "apt-get", "update"]);
+  await sh(["sudo", "apt-get", "install", "-y", "nodejs", "npm"]);
+  const node = (await sh(["node", "--version"])).trim();
+  if (!(Number(NODE_VERSION.exec(node)?.[1]) >= MIN_NODE_MAJOR)) {
+    throw new VmInitError(`the VM's Node is ${node}, and the runner needs Node ${MIN_NODE_MAJOR} or later. ${leftBehind}`);
+  }
+  if (deps.cliPackage === void 0) {
+    await sh(["sudo", "npm", "install", "--global", `@outerlayer/cli@${deps.version}`]);
+  } else {
+    await sh(["sh", "-c", `cat > ${TARBALL_IN_VM} && sudo npm install --global ${TARBALL_IN_VM}`], readFileSync(deps.cliPackage));
+  }
+  await sh(["sudo", "usermod", "-aG", "docker", user]);
+  const outerlayer = (await sh(["sh", "-c", "command -v outerlayer"])).trim();
+  progress("setting up the runner in the VM");
+  const vmConfig = `${home}/.outerlayer/config.json`;
+  const handoff = {
+    url: config.url,
+    apiKey: config.apiKey,
+    appId: config.appId,
+    ...config.repos === void 0 ? {} : { repos: config.repos },
+    ...config.scrub === void 0 ? {} : { scrub: config.scrub },
+    ...block === void 0 ? {} : { runner: carried }
+  };
+  const innerOut = await sh(["sg", "docker", "-c", `${quote(outerlayer)} runner init --config-stdin --config ${quote(vmConfig)}`], JSON.stringify(handoff));
+  await sh(["sh", "-c", `${quote(outerlayer)} runner install --config ${quote(vmConfig)}`]);
+  const nodePath = (await sh(["sh", "-c", "command -v node"])).trim();
+  const execStart = execStartCommand(vmConfig, nodePath);
+  await sh(["sudo", "tee", `/etc/systemd/system/${VM_SERVICE_NAME}.service`], runnerUnit({ user, home, execStart, timeLimitMinutes }));
+  await sh(["sudo", "systemctl", "daemon-reload"]);
+  const enabled = commandsAreReal(block);
+  if (enabled) await sh(["sudo", "systemctl", "enable", "--now", VM_SERVICE_NAME]);
+  let agent;
+  let hadHostKey;
+  try {
+    agent = writeLaunchAgent(deps.home, limactl, instance);
+    const { apiKey: _apiKey, runner: _runner, ...kept } = config;
+    writeFileSync(configPath, `${JSON.stringify({ ...kept, runnerVm: { instance, since: (deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString() } }, null, 2)}
+`);
+    hadHostKey = existsSync(hostKeyPath(configPath));
+    rmSync(hostKeyPath(configPath), { force: true });
+  } catch (err) {
+    throw new VmInitError(`the VM ${instance} is ready, but this Mac could not be updated: ${err instanceof Error ? err.message : String(err)}. ${leftBehind}`);
+  }
+  return {
+    instance,
+    enabled,
+    lines: [
+      `created the Linux VM ${instance}: ${size.cpus} CPUs, ${size.memoryGiB} GiB memory, ${size.diskGiB} GiB disk`,
+      ...innerOut.split("\n").map((line) => line.trim()).filter((line) => line !== ""),
+      `the VM starts at login through ${agent}`,
+      `moved the runner key into the VM: apiKey and runner are gone from ${configPath}`,
+      ...hadHostKey ? ["deleted this Mac's old host key. If the runner key was bound to it, a member uses Clear host key on the API keys page before the VM's first claim"] : [],
+      "run outerlayer login again to use capture on this Mac, with a key that is not the runner key",
+      `put CLAUDE_CODE_OAUTH_TOKEN in ${home}/.outerlayer/runner.env inside the VM${enabled ? `, then restart the runner so it reads the file: limactl shell ${instance} sudo systemctl restart ${VM_SERVICE_NAME}` : ""}`,
+      enabled ? `the runner is running in the VM: limactl shell ${instance} outerlayer runner status` : `Edit the command lines in the VM's config, then run: limactl shell ${instance} sudo systemctl enable --now ${VM_SERVICE_NAME}`
+    ]
+  };
+}
+async function chooseVm(options) {
+  if (options.flag === false) return false;
+  if (options.flag === true) {
+    if (options.platform !== "darwin") {
+      throw new RunnerInitError(`--vm is for macOS: this machine is ${options.platform}, where the runner runs directly.`);
+    }
+    return true;
+  }
+  if (options.platform !== "darwin" || !options.isTTY) return false;
+  return options.ask();
+}
+
+export { VM_INSTANCE, VmInitError, chooseVm, runVmInit };

package/dist/init-cmd-NHR7PRSQ.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { summarizeChecks, summaryText, renderDoctorText } from './chunk-NYC54VBD.js';
+import { runConnect } from './chunk-2E54Z3P5.js';
+import './chunk-3TT7RQYB.js';
+import './chunk-F47JBIAW.js';
+import './chunk-BKO6JEZI.js';
+import './chunk-5DLBAXY5.js';
+import './chunk-BFESLKPP.js';
+import './chunk-6Y63SXFO.js';
+import './chunk-G7FSV7JX.js';
+import './chunk-USO2DKBD.js';
+import './chunk-N6LURUEF.js';
+import { C } from './chunk-YRYMNBGQ.js';
+import './chunk-WZBHBH3J.js';
+import './chunk-5QRP3MVS.js';
+import './chunk-WIOZAJ2W.js';
+import './chunk-EMY4I27X.js';
+import './chunk-BCLJSQCV.js';
+import './chunk-BOLTI6LR.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-M5POMKKW.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-UFFXNXLQ.js';
+import './chunk-XCCLFVXM.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);
+
+// src/init-cmd.ts
+var STEP_NAMES = ["connect", "hooks", "agent-setup", "doctor"];
+var COMMIT_LINE = "Commit and push .outerlayer/ so the factory reads your policy and skills. No checks run on your pull requests until the policy is on your default branch.";
+var CLOSING_LINE = "Add an issue on the Work page and press Build.";
+var errorMessage = (err) => err instanceof Error ? err.message : String(err);
+async function runInitCommand(flags, deps) {
+  const steps = {};
+  for (const name of STEP_NAMES) steps[name] = { outcome: "skipped", reason: "not reached" };
+  let text = "";
+  const say = (line) => {
+    text += line;
+  };
+  let unlinked;
+  const finish = () => {
+    const failed = STEP_NAMES.some((n) => steps[n].outcome === "failed");
+    if (unlinked !== void 0) {
+      say(`
+Next
+  Link ${unlinked.repository} on the factory's Work page: ${unlinked.url}
+  Then run \`outerlayer connect\` again.
+`);
+    }
+    if (flags.json) {
+      deps.stdout.write(JSON.stringify({ status: failed ? "failed" : "done", steps }, null, 2) + "\n");
+    } else {
+      deps.stdout.write(text + closing());
+    }
+    return failed ? 1 : 0;
+  };
+  const closing = () => {
+    if (unlinked !== void 0 || STEP_NAMES.some((n) => steps[n].outcome === "failed")) return "";
+    const setup = steps["agent-setup"];
+    const leftFiles = (setup.paths?.length ?? 0) > 0 || (setup.kept?.length ?? 0) > 0;
+    return `${leftFiles ? `
+${COMMIT_LINE}
+` : ""}
+${CLOSING_LINE}
+`;
+  };
+  const connect = await runConnect({ factory: flags.factory }, deps.connect).catch(
+    (err) => ({
+      code: 1,
+      outcome: "failed",
+      reason: errorMessage(err),
+      text: `${errorMessage(err)}
+`
+    })
+  );
+  steps.connect = {
+    outcome: connect.outcome,
+    reason: connect.reason,
+    ...connect.linked === void 0 ? {} : { linked: connect.linked },
+    ...connect.linkUrl === void 0 ? {} : { linkUrl: connect.linkUrl }
+  };
+  if (connect.linkUrl !== void 0 && connect.repository !== void 0) unlinked = { repository: connect.repository, url: connect.linkUrl };
+  const connected = connect.outcome === "done";
+  if (connect.outcome === "done") {
+    (flags.json ? deps.stderr : { write: (s) => (say(`${C.green}\u2713${C.reset} ${s}`), true) }).write(connect.text);
+  } else if (connect.outcome === "skipped") {
+    say(`${C.dim}- Connect skipped: ${connect.reason}${C.reset}
+`);
+    if (connect.next) say(`  ${connect.next}
+`);
+  } else {
+    deps.stderr.write(`${C.red}\u2717${C.reset} ${connect.text}`);
+  }
+  const hooks = await Promise.resolve().then(() => deps.runHooks({ connected })).catch((err) => ({ ok: false, text: `could not install the hooks: ${errorMessage(err)}
+`, detail: errorMessage(err) }));
+  steps.hooks = { outcome: hooks.ok ? "done" : "failed", reason: hooks.detail };
+  if (!hooks.ok) {
+    deps.stderr.write(hooks.text);
+    return finish();
+  }
+  say(hooks.text);
+  const agent = await Promise.resolve().then(() => deps.runAgentSetup()).catch(
+    (err) => ({
+      outcome: "failed",
+      reason: errorMessage(err),
+      text: `${C.red}\u2717${C.reset} agent setup could not run: ${errorMessage(err)}
+`,
+      paths: []
+    })
+  );
+  steps["agent-setup"] = {
+    outcome: agent.outcome,
+    reason: agent.reason,
+    paths: agent.paths,
+    ...agent.kept !== void 0 && agent.kept.length > 0 ? { kept: agent.kept } : {}
+  };
+  say(agent.text);
+  try {
+    const checks = await deps.runDoctorChecks();
+    const summary = summarizeChecks(checks);
+    steps.doctor = { outcome: summary.failures > 0 ? "failed" : "done", reason: summaryText(summary) };
+    say(renderDoctorText(checks));
+  } catch (err) {
+    steps.doctor = { outcome: "failed", reason: errorMessage(err) };
+    deps.stderr.write(`${C.red}\u2717${C.reset} doctor could not run: ${errorMessage(err)}
+`);
+  }
+  return finish();
+}
+
+export { runInitCommand };

package/dist/install-cmd-7WXOIFDO.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { isInLayout, packageRootIn, versionDir, switchCurrent, execStartLine } from './chunk-YYYXRJUW.js';
+import { RUNNER_DIR_MODE } from './chunk-ZM2IMMYN.js';
+import './chunk-Z5GEFMRW.js';
+import { realpathSync, readFileSync, mkdirSync, rmSync, cpSync, existsSync } from 'fs';
+import { dirname, sep, join } from 'path';
+
+createRequire(import.meta.url);
+var RunnerInstallError = class extends Error {
+};
+function runRunnerInstall(args) {
+  const { configPath, nodePath } = args;
+  let entry;
+  try {
+    entry = realpathSync(args.entryPath);
+  } catch {
+    throw new RunnerInstallError(`cannot read the running CLI at ${args.entryPath}`);
+  }
+  const packageRoot = dirname(dirname(entry));
+  if (!packageRoot.split(sep).includes("node_modules")) {
+    throw new RunnerInstallError(
+      `${packageRoot} is not an installed package: run \`outerlayer runner install\` from a CLI installed with npm, not from a source checkout`
+    );
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(`${packageRoot}/package.json`, "utf8"));
+  } catch {
+    manifest = {};
+  }
+  if (manifest.name !== "@outerlayer/cli") throw new RunnerInstallError(`${packageRoot} is not the @outerlayer/cli package`);
+  const version = manifest.version;
+  if (typeof version !== "string" || version === "") throw new RunnerInstallError(`${packageRoot}/package.json has no version`);
+  if (!isInLayout(configPath, entry)) {
+    const target = packageRootIn(versionDir(configPath, version));
+    mkdirSync(dirname(target), { recursive: true, mode: RUNNER_DIR_MODE });
+    rmSync(target, { recursive: true, force: true });
+    cpSync(packageRoot, target, { recursive: true });
+    carryHoistedDevcontainerCli(packageRoot, target);
+  }
+  switchCurrent(configPath, version);
+  return { version, execStart: execStartLine(configPath, nodePath) };
+}
+function carryHoistedDevcontainerCli(packageRoot, target) {
+  const dependency = join("@devcontainers", "cli");
+  if (existsSync(join(packageRoot, "node_modules", dependency))) return;
+  const hoisted = join(dirname(dirname(packageRoot)), dependency);
+  if (!existsSync(hoisted)) return;
+  const carried = join(dirname(dirname(target)), dependency);
+  mkdirSync(dirname(carried), { recursive: true, mode: RUNNER_DIR_MODE });
+  cpSync(hoisted, carried, { recursive: true });
+}
+
+export { RunnerInstallError, runRunnerInstall };

package/dist/lima-XN65D7GN.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import './chunk-Z5GEFMRW.js';
+import { spawnSync, spawn } from 'child_process';
+import { statSync, accessSync, constants } from 'fs';
+import { delimiter, resolve } from 'path';
+
+createRequire(import.meta.url);
+var NOT_INSTALLED = { status: 127, stdout: "", stderr: "limactl is not installed" };
+function realLima(env = process.env) {
+  const locate = () => {
+    for (const dir of (env.PATH ?? "").split(delimiter)) {
+      if (dir === "") continue;
+      const candidate = resolve(dir, "limactl");
+      try {
+        if (!statSync(candidate).isFile()) continue;
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+        continue;
+      }
+    }
+    return void 0;
+  };
+  const run = (argv, stdin) => {
+    const path = locate();
+    if (path === void 0) return Promise.resolve(NOT_INSTALLED);
+    return new Promise((done) => {
+      const child = spawn(path, argv, { env, stdio: ["pipe", "pipe", "pipe"] });
+      const out = [];
+      const err = [];
+      child.stdout.on("data", (chunk) => out.push(chunk));
+      child.stderr.on("data", (chunk) => err.push(chunk));
+      child.on("error", (error) => done({ status: 127, stdout: "", stderr: error.message }));
+      child.on("close", (code) => done({ status: code ?? 1, stdout: Buffer.concat(out).toString("utf8"), stderr: Buffer.concat(err).toString("utf8") }));
+      child.stdin.on("error", () => void 0);
+      child.stdin.end(stdin);
+    });
+  };
+  return {
+    locate,
+    status(instance) {
+      const path = locate();
+      if (path === void 0) return void 0;
+      const listed = spawnSync(path, ["list", "--format", "{{.Status}}", instance], { env, encoding: "utf8" });
+      const text = listed.status === 0 ? listed.stdout.trim() : "";
+      return text === "" ? void 0 : text;
+    },
+    create: ({ instance, cpus, memoryGiB, diskGiB }) => run(["create", "--tty=false", `--name=${instance}`, `--cpus=${cpus}`, `--memory=${memoryGiB}`, `--disk=${diskGiB}`, "--mount-none", "template:docker-rootful"]),
+    start: (instance) => run(["start", instance]),
+    shell: (instance, argv, options) => run(["shell", "--workdir", "/", instance, "--", ...argv], options?.stdin)
+  };
+}
+
+export { realLima };

package/dist/login-browser-7XGSV7MA.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { DEFAULT_DASHBOARD, readPipedKey, realLoginDeps, runLoginCommand, sanitizeMachineName, stdinKind } from './chunk-USO2DKBD.js';
+import './chunk-N6LURUEF.js';
+import './chunk-YRYMNBGQ.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/{config-POF7DEQW.js → logout-cmd-QAUFDJ6J.js}

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-export { RunnerConfigError, checkHooks, defaultRunnerConfigPath, loadRunnerConfig } from './chunk-WQ6VGRGZ.js';
+export { realLogoutDeps, revokeTokenOnDashboard, runLogoutCommand } from './chunk-N6LURUEF.js';
+import './chunk-YRYMNBGQ.js';
+import './chunk-EABW6AJQ.js';
 import './chunk-VNVZDWO3.js';
 import './chunk-Z5GEFMRW.js';
 

package/dist/{logs-TRNPQM42.js → logs-7RYUH5A6.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { jobsDir } from './chunk-JJP7YLMN.js';
+import { jobsDir } from './chunk-ZM2IMMYN.js';
 import './chunk-Z5GEFMRW.js';
 import { existsSync, watch, statSync, createReadStream } from 'fs';
 import { join } from 'path';