@pushary/agent-hooks 0.60.0 → 0.61.0

package/dist/chunk-QHOVJXOT.js

@@ -0,0 +1,255 @@
+import {
+  generateKeypair,
+  openSealedKey,
+  publicKeyFingerprint
+} from "./chunk-3EGEA4KH.js";
+import {
+  getBaseUrl
+} from "./chunk-2UMNXADU.js";
+
+// src/cli/login-ui.ts
+import { hostname } from "os";
+
+// src/cli/browser.ts
+import { spawn } from "child_process";
+var command = () => {
+  if (process.platform === "darwin") return { bin: "open", args: [] };
+  if (process.platform === "win32") return { bin: "cmd", args: ["/c", "start", ""] };
+  if (process.platform === "linux") return { bin: "xdg-open", args: [] };
+  return null;
+};
+var canOpenBrowser = () => {
+  if (process.env.PUSHARY_NO_BROWSER === "1") return false;
+  if (process.env.CI) return false;
+  if (process.env.SSH_TTY) return false;
+  if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
+  return command() !== null;
+};
+var openInBrowser = (url) => {
+  const resolved = command();
+  if (!resolved) return false;
+  try {
+    const child = spawn(resolved.bin, [...resolved.args, url], {
+      stdio: "ignore",
+      detached: true,
+      windowsHide: true
+    });
+    child.unref();
+    child.on("error", () => {
+    });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/cli/login.ts
+var START_PATH = "/api/cli/auth/start";
+var CLAIM_PATH = "/api/cli/auth/claim";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var post = async (url, body, fetchImpl) => fetchImpl(url, {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify(body),
+  signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+});
+var asString = (value) => typeof value === "string" && value ? value : null;
+var asNumber = (value, fallback) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
+var startLogin = async (machineLabel, cliVersion, deps = {}) => {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const baseUrl = deps.baseUrl ?? getBaseUrl();
+  const keypair = generateKeypair();
+  let response;
+  try {
+    response = await post(
+      `${baseUrl}${START_PATH}`,
+      { cliPublicKey: keypair.publicKeyB64, machineLabel, cliVersion },
+      fetchImpl
+    );
+  } catch (err) {
+    return { kind: "unavailable", detail: err instanceof Error ? err.message : "network error" };
+  }
+  if (response.status === 429) {
+    const retry = Number(response.headers.get("retry-after") ?? "60");
+    return { kind: "rate-limited", retryAfterSeconds: Number.isFinite(retry) ? retry : 60 };
+  }
+  if (!response.ok) {
+    return { kind: "unavailable", detail: `HTTP ${response.status}` };
+  }
+  const body = await response.json().catch(() => null);
+  const loginId = body ? asString(body.loginId) : null;
+  const userCode = body ? asString(body.userCode) : null;
+  if (!body || !loginId || !userCode) {
+    return { kind: "unavailable", detail: "the server did not return a login code" };
+  }
+  return {
+    kind: "ok",
+    start: {
+      loginId,
+      userCode,
+      verificationUrl: asString(body.verificationUrl) ?? `${baseUrl}/cli/authorize`,
+      // The cadence comes from the server so a later change needs no CLI release.
+      intervalMs: Math.max(1, asNumber(body.interval, 2)) * 1e3,
+      expiresInSeconds: Math.max(1, asNumber(body.expiresInSeconds, 900)),
+      fingerprint: asString(body.fingerprint) ?? publicKeyFingerprint(keypair.publicKeyB64),
+      keypair
+    }
+  };
+};
+var pollOnce = async (start, deps = {}) => {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const baseUrl = deps.baseUrl ?? getBaseUrl();
+  let response;
+  try {
+    response = await fetchImpl(`${baseUrl}${CLAIM_PATH}?id=${encodeURIComponent(start.loginId)}`, {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+  } catch (err) {
+    return { kind: "unreachable", detail: err instanceof Error ? err.message : "network error" };
+  }
+  if (!response.ok) return { kind: "unreachable", detail: `HTTP ${response.status}` };
+  const body = await response.json().catch(() => null);
+  if (!body) return { kind: "unreachable", detail: "unreadable response" };
+  switch (body.status) {
+    case "authorized": {
+      const sealed = asString(body.sealed);
+      if (!sealed) return { kind: "unreachable", detail: "authorized without a sealed key" };
+      try {
+        return {
+          kind: "authorized",
+          apiKey: openSealedKey(sealed, start.keypair),
+          siteSlug: asString(body.siteSlug) ?? "",
+          keyName: asString(body.keyName) ?? "CLI"
+        };
+      } catch {
+        return { kind: "unreachable", detail: "the key did not decrypt" };
+      }
+    }
+    case "payment_required":
+      return {
+        kind: "payment-required",
+        checkoutUrl: asString(body.checkoutUrl) ?? `${baseUrl}/dashboard/settings?tab=billing`,
+        plan: asString(body.plan) ?? "agent"
+      };
+    case "rejected":
+      return { kind: "rejected" };
+    case "expired":
+      return { kind: "expired" };
+    case "needs_workspace":
+      return { kind: "needs-workspace" };
+    default:
+      return { kind: "pending", expiresInSeconds: asNumber(body.expiresInSeconds, 0) };
+  }
+};
+var waitForLogin = async (start, handlers = {}, deps = {}) => {
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = now() + start.expiresInSeconds * 1e3;
+  let polls = 0;
+  let consecutiveFailures = 0;
+  const noticed = /* @__PURE__ */ new Set();
+  while (now() < deadline) {
+    const state = await pollOnce(start, deps);
+    polls += 1;
+    if (state.kind === "authorized" || state.kind === "rejected" || state.kind === "expired") {
+      return { state, polls };
+    }
+    if (state.kind === "unreachable") {
+      consecutiveFailures += 1;
+      if (consecutiveFailures === 3 && !noticed.has("unreachable")) {
+        noticed.add("unreachable");
+        handlers.onNotice?.(state);
+      }
+    } else {
+      consecutiveFailures = 0;
+      if ((state.kind === "needs-workspace" || state.kind === "payment-required") && !noticed.has(state.kind)) {
+        noticed.add(state.kind);
+        handlers.onNotice?.(state);
+      }
+    }
+    handlers.onTick?.(state, Math.max(0, Math.ceil((deadline - now()) / 1e3)));
+    await sleep(start.intervalMs);
+  }
+  return { state: { kind: "expired" }, polls };
+};
+var cancelLogin = async (start, deps = {}) => {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const baseUrl = deps.baseUrl ?? getBaseUrl();
+  try {
+    await fetchImpl(`${baseUrl}${START_PATH}`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ loginId: start.loginId, cliPublicKey: start.keypair.publicKeyB64 }),
+      signal: AbortSignal.timeout(5e3)
+    });
+  } catch {
+  }
+};
+
+// src/cli/login-ui.ts
+var runBrowserLogin = async (ui, options, deps = {}) => {
+  const started = await startLogin(hostname(), options.cliVersion, deps);
+  if (started.kind === "rate-limited") {
+    return { kind: "unavailable", detail: `too many attempts, retry in ${started.retryAfterSeconds}s` };
+  }
+  if (started.kind === "unavailable") {
+    return { kind: "unavailable", detail: started.detail };
+  }
+  const start = started.start;
+  let cancelled = false;
+  const onSignal = () => {
+    if (cancelled) return;
+    cancelled = true;
+    void cancelLogin(start, deps).finally(() => {
+      ui.say("");
+      ui.say("  Cancelled. Nothing was written.");
+      process.exit(130);
+    });
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGHUP", onSignal);
+  try {
+    ui.say("");
+    ui.say(`  ${ui.bold("Sign in to Pushary")}`);
+    ui.say("");
+    ui.say(`  1. Open ${ui.cyan(start.verificationUrl)}`);
+    ui.say(`  2. Enter this code: ${ui.bold(start.userCode)}`);
+    ui.say("");
+    ui.say(`  ${ui.dim(`This terminal shows fingerprint ${start.fingerprint}. The page shows the same one.`)}`);
+    ui.say(`  ${ui.dim("The code is only on your screen. Nobody can send you a link that fills it in.")}`);
+    ui.say("");
+    if (!options.noBrowser && canOpenBrowser() && openInBrowser(start.verificationUrl)) {
+      ui.say(`  ${ui.dim("Opened your browser.")}`);
+    }
+    const notice = (state2) => {
+      if (state2.kind === "needs-workspace") {
+        ui.say(`  ${ui.yellow("!")} Waiting on a workspace. Finish creating one in the browser and this continues on its own.`);
+      } else if (state2.kind === "payment-required") {
+        ui.say(`  ${ui.yellow("!")} A plan is needed before a key can be issued. Nothing was created yet.`);
+        ui.say(`  ${ui.dim("Choose one at")} ${ui.cyan(state2.checkoutUrl)}`);
+        ui.say(`  ${ui.dim("This terminal keeps the same code and finishes on its own once the plan is active.")}`);
+        if (!options.noBrowser && canOpenBrowser()) openInBrowser(state2.checkoutUrl);
+      } else if (state2.kind === "unreachable") {
+        ui.say(`  ${ui.yellow("!")} Still trying. pushary.com is not answering ${ui.dim(`(${state2.detail})`)}`);
+      }
+    };
+    const { state } = await waitForLogin(start, { onNotice: notice }, deps);
+    if (state.kind === "authorized") {
+      return {
+        kind: "ok",
+        apiKey: state.apiKey,
+        siteSlug: state.siteSlug,
+        keyName: state.keyName
+      };
+    }
+    if (state.kind === "rejected") return { kind: "rejected" };
+    return { kind: "expired" };
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGHUP", onSignal);
+  }
+};
+
+export {
+  runBrowserLogin
+};

package/dist/chunk-R6C4USIV.js

@@ -0,0 +1,44 @@
+import {
+  describeKeyCheck,
+  keyCheckFromResponse
+} from "./chunk-UKNAAVEE.js";
+import {
+  createIo
+} from "./chunk-TX7KBKT7.js";
+import {
+  EXIT
+} from "./chunk-SML23YOT.js";
+
+// src/cli/report-key.ts
+var { dim, yellow } = createIo();
+var printKeyCheck = (check, baseUrl) => {
+  const report = describeKeyCheck(check, baseUrl);
+  console.log(`  ${yellow("!")} ${report.message}`);
+  for (const line of report.next) console.log(`  ${dim(line)}`);
+  return report;
+};
+var exitIfKeyFailure = async (response, baseUrl) => {
+  const check = await keyCheckFromResponse(response, baseUrl);
+  if (!check) return;
+  const report = printKeyCheck(check, baseUrl);
+  process.exit(report.exitCode);
+};
+var responseDetail = async (response) => {
+  try {
+    const body = await response.json();
+    const text = [body.error, body.message].find((part) => typeof part === "string" && part);
+    if (typeof text === "string") return text;
+  } catch {
+  }
+  return response.statusText || `HTTP ${response.status}`;
+};
+var exitOnFailedResponse = async (response, baseUrl) => {
+  await exitIfKeyFailure(response, baseUrl);
+  console.log(`  ${yellow("!")} Failed: ${await responseDetail(response)}`);
+  process.exit(EXIT.FAILED);
+};
+
+export {
+  printKeyCheck,
+  exitOnFailedResponse
+};

package/dist/{chunk-BQLCELYC.js → chunk-S4TFBJ5O.js}

@@ -4,7 +4,12 @@ import {
 
 // src/codex-config.ts
 import { createHash } from "crypto";
+import { homedir } from "os";
+import { join } from "path";
 var CODEX_HOOK_BINARY = "pushary-codex-hook";
+var codexHome = () => process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+var codexConfigToml = () => join(codexHome(), "config.toml");
+var codexHooksJson = () => join(codexHome(), "hooks.json");
 var CODEX_HOOK_EVENTS = [
   { event: "PermissionRequest", matcher: "Bash|apply_patch", timeout: HOOK_BUDGETS.codex.budgetSeconds, statusMessage: "Waiting for your phone" },
   { event: "PreToolUse", matcher: "Bash|apply_patch", timeout: HOOK_BUDGETS.codex.budgetSeconds, statusMessage: "Checking Pushary policy" },
@@ -310,6 +315,8 @@ var hasInstructionBlock = (filePath) => {
 };
 
 export {
+  codexConfigToml,
+  codexHooksJson,
   addCodexMcpServer,
   readCodexMcpAuth,
   addCodexHooks,

package/dist/chunk-SML23YOT.js

@@ -0,0 +1,216 @@
+// src/cli/commands.ts
+var COMMAND_LIST = [
+  {
+    name: "setup",
+    module: "pushary-setup",
+    summary: "Configure Claude Code, Codex, Gemini CLI, Hermes, or Cursor with Pushary"
+  },
+  {
+    name: "claude",
+    module: "pushary-claude",
+    summary: "Run Claude Code through Pushary, reachable from your phone even when idle",
+    detail: [
+      "Send an instruction and it drives a fully idle agent. Ctrl-] takes the terminal back.",
+      "Add --remote to start headless."
+    ]
+  },
+  {
+    name: "daemon",
+    module: "pushary-daemon",
+    summary: "Keep this machine reachable so your phone can START a new session",
+    detail: [
+      "Leave it running in a project dir; it launches a headless",
+      "'pushary claude --remote' when you send a prompt from the app."
+    ]
+  },
+  {
+    name: "status",
+    module: "pushary-status",
+    summary: "One screen: which key is in force, whether the server accepts it, what can receive an approval"
+  },
+  {
+    name: "login",
+    module: "pushary-login",
+    summary: "Sign in from this terminal, no key to copy (--with-token to pipe one in)"
+  },
+  {
+    name: "logout",
+    module: "pushary-logout",
+    summary: "Remove the key this machine stores, and say what it does not remove"
+  },
+  {
+    name: "connect",
+    module: "pushary-connect",
+    summary: "Connect a phone without re-running setup (--app for the Pushary app)"
+  },
+  { name: "doctor", module: "pushary-doctor", summary: "Verify your Pushary installation is working" },
+  { name: "clean", module: "pushary-clean", summary: "Remove all Pushary configuration (--yes for non-interactive)" },
+  { name: "mode", module: "pushary-mode", summary: "Switch approval mode (push_only, push_first, terminal_only)" },
+  { name: "wait", module: "pushary-wait", summary: 'Show or set the "wait for your phone" ladder (pushary wait 45)' },
+  { name: "stats", module: "pushary-stats", summary: "Show the approval moments your agents hit while not connected" },
+  {
+    name: "suggestions",
+    module: "pushary-suggestions",
+    summary: "List rules mined from your own approvals",
+    detail: ["Accept one with 'pushary suggestions accept <id>' to always-allow that pattern."]
+  },
+  { name: "upgrade", module: "pushary-upgrade", summary: "Update the globally installed hooks to the latest version" },
+  {
+    name: "hook",
+    module: "pushary-hook",
+    summary: "Run as a PreToolUse hook (reads stdin, writes stdout)"
+  }
+];
+var COMMANDS = COMMAND_LIST;
+var findCommand = (name) => COMMANDS.find((command) => command.name === name);
+var isCommandName = (name) => COMMANDS.some((command) => command.name === name);
+var COMMAND_OPTIONS = {
+  clean: [["--yes", "Remove everything without asking"]],
+  mode: [
+    ["<mode>", "One of: push_only, push_first, terminal_only, notify_only"],
+    ["status", "Show the current override"],
+    ["clear", "Drop the override and go back to per-tool policies"],
+    ["--for <30m|2h>", "Expire the override after this long"]
+  ],
+  wait: [
+    ["<seconds>", `Default push window, 0-300`],
+    ["status", "Show the whole ladder"],
+    ["clear", "Reset the default window"]
+  ],
+  status: [["--json", "Emit the whole report as one object instead of the screen"]],
+  doctor: [
+    ["--json", "Emit every check as one object instead of the screen"],
+    ["--roundtrip", "Also send a real question and wait for you to answer it on your phone"],
+    ["--no-push", "Run every check without waking a device"]
+  ],
+  suggestions: [["accept <id>", "Turn a mined suggestion into an always-allow rule"]],
+  claude: [
+    ["--remote", "Start headless and drive it entirely from your phone"],
+    ["-p <prompt>", "Initial prompt"]
+  ]
+};
+var SETUP_OPTIONS = [
+  ["--key <pk_xxx.xxx>", "Use this API key instead of prompting. Visible in the process list; prefer --key-stdin in CI."],
+  ["--key-stdin", "Read the API key from the first line of stdin, so it never appears in argv or shell history"],
+  ["--agents <list>", 'Comma-separated agent ids, or "auto" for everything detected, or "none" to save the key only'],
+  ["--yes, -y", "Accept every default and ask nothing. Implies --agents auto unless --agents is given"],
+  ["--connect app", "Pair the native Pushary app, no key to paste"],
+  ["--connect web", "Connect your phone via the browser subscribe page (default)"],
+  ["--skip-phone", "Skip the phone connect step"],
+  ["--dry-run", "Print what would be written and change nothing"],
+  ["--json", "Emit one machine-readable object instead of the human report"]
+];
+var AGENT_IDS = "claude_code, codex, gemini_cli, hermes, cursor, custom";
+var USAGE_EXAMPLES = [
+  "npx @pushary/agent-hooks@latest setup",
+  "npx @pushary/agent-hooks@latest setup --agents auto --yes --skip-phone",
+  "npx @pushary/agent-hooks@latest setup --key-stdin --agents claude_code --yes < key.txt",
+  "npx @pushary/agent-hooks@latest doctor",
+  "npx @pushary/agent-hooks@latest mode push_only --for 30m",
+  "pushary claude                                    # native terminal, reachable from your phone",
+  'pushary claude --remote -p "start the refactor"   # start headless, drive from your phone',
+  "pushary daemon                                    # keep this machine ready to spawn a session"
+];
+var pad = (text, width) => text + " ".repeat(Math.max(0, width - text.length));
+var renderHelp = (version) => {
+  const width = Math.max(...COMMANDS.map((command) => command.name.length)) + 2;
+  const commandLines = COMMANDS.flatMap((command) => [
+    `  ${pad(command.name, width)}${command.summary}`,
+    ...(command.detail ?? []).map((line) => `  ${" ".repeat(width)}${line}`)
+  ]);
+  const optionWidth = Math.max(...SETUP_OPTIONS.map(([flag]) => flag.length)) + 2;
+  const optionLines = SETUP_OPTIONS.map(([flag, text]) => `  ${pad(flag, optionWidth)}${text}`);
+  return [
+    "",
+    `Pushary Agent Hooks v${version}`,
+    "",
+    "Usage: pushary <command> [options]",
+    "",
+    "Commands:",
+    ...commandLines,
+    "",
+    "Setup options:",
+    ...optionLines,
+    "",
+    `Agent ids: ${AGENT_IDS}`,
+    "",
+    "Examples:",
+    ...USAGE_EXAMPLES.map((line) => `  ${line}`),
+    "",
+    "Run `pushary <command> --help` for a single command.",
+    ""
+  ].join("\n");
+};
+var renderCommandHelp = (name, version) => {
+  const spec = findCommand(name);
+  const options = name === "setup" ? SETUP_OPTIONS : COMMAND_OPTIONS[name] ?? [];
+  const width = options.length > 0 ? Math.max(...options.map(([flag]) => flag.length)) + 2 : 0;
+  return [
+    "",
+    `pushary ${name} ${version ? `(v${version})` : ""}`.trimEnd(),
+    "",
+    ...spec ? [`  ${spec.summary}`, ...(spec.detail ?? []).map((line) => `  ${line}`), ""] : [],
+    ...options.length > 0 ? ["Options:", ...options.map(([flag, text]) => `  ${pad(flag, width)}${text}`), ""] : [],
+    ...name === "setup" ? [
+      `Agent ids: ${AGENT_IDS}`,
+      "",
+      "Non-interactive runs need --agents or --yes. Without a terminal on stdin,",
+      "setup takes the defaults rather than waiting for a keypress that can never arrive.",
+      ""
+    ] : []
+  ].join("\n");
+};
+
+// src/cli/version.ts
+import { readFileSync } from "fs";
+import { dirname, join, parse } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "@pushary/agent-hooks";
+var findOwnPackageJson = (start) => {
+  const { root } = parse(start);
+  let dir = start;
+  while (true) {
+    const candidate = join(dir, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+      if (pkg.name === PACKAGE_NAME) return candidate;
+    } catch {
+    }
+    if (dir === root) return void 0;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+};
+var getPackageVersion = () => {
+  try {
+    const found = findOwnPackageJson(dirname(fileURLToPath(import.meta.url)));
+    if (!found) return "0.0.0";
+    const pkg = JSON.parse(readFileSync(found, "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+};
+
+// src/exit.ts
+var EXIT = {
+  OK: 0,
+  FAILED: 1,
+  USAGE: 2,
+  NOT_CONFIGURED: 3,
+  UNAUTHENTICATED: 4,
+  PROBLEMS_FOUND: 5,
+  NO_DEVICE: 6,
+  INPUT_REQUIRED: 7,
+  UNREACHABLE: 8
+};
+
+export {
+  COMMANDS,
+  isCommandName,
+  renderHelp,
+  renderCommandHelp,
+  getPackageVersion,
+  EXIT
+};

package/dist/chunk-TX7KBKT7.js

@@ -0,0 +1,79 @@
+// src/cli/io.ts
+var truthyLevel = (value) => {
+  if (value === void 0) return void 0;
+  if (value === "" || value === "false") return 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 1;
+};
+var useColor = (context = {}, stream = process.stdout) => {
+  const forced = truthyLevel(process.env.FORCE_COLOR);
+  if (forced !== void 0) return forced > 0;
+  if (context.color === false) return false;
+  if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "") return false;
+  if (process.env.TERM === "dumb") return false;
+  if (context.json) return false;
+  return stream.isTTY === true;
+};
+var SPINNER_FRAMES = ["   ", ".  ", ".. ", "..."];
+var SPINNER_INTERVAL_MS = 200;
+var describeError = (err) => {
+  if (err instanceof Error) {
+    const signalled = err;
+    if (signalled.killed && signalled.signal === "SIGTERM") {
+      return "timed out, check your network connection";
+    }
+    return err.message;
+  }
+  return String(err);
+};
+var createIo = (stream = process.stdout, context = {}) => {
+  const color = useColor(context, stream);
+  const wrap = (open) => (s) => color ? `${open}${s}\x1B[0m` : s;
+  const bold = wrap("\x1B[1m");
+  const dim = wrap("\x1B[2m");
+  const green = wrap("\x1B[32m");
+  const yellow = wrap("\x1B[33m");
+  const red = wrap("\x1B[31m");
+  const cyan = wrap("\x1B[36m");
+  const check = () => green("\u2713");
+  const line = (s = "") => {
+    stream.write(`${s}
+`);
+  };
+  const warn = (s) => {
+    process.stderr.write(`${yellow("!")} ${s}
+`);
+  };
+  const spinner = async (label, fn, options = {}) => {
+    if (!color) {
+      try {
+        await fn();
+        line(`  ${check()} ${label}`);
+      } catch (err) {
+        line(`  ${yellow("!")} ${label} ${dim(`(${describeError(err)})`)}`);
+        if (!options.optional) throw err;
+      }
+      return;
+    }
+    let frame = 0;
+    const timer = setInterval(() => {
+      stream.write(`\r  ${dim(SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length])} ${label}`);
+    }, SPINNER_INTERVAL_MS);
+    try {
+      await fn();
+      clearInterval(timer);
+      stream.write(`\r  ${check()} ${label}\x1B[K
+`);
+    } catch (err) {
+      clearInterval(timer);
+      stream.write(`\r  ${yellow("!")} ${label} ${dim(`(${describeError(err)})`)}\x1B[K
+`);
+      if (!options.optional) throw err;
+    }
+  };
+  return { color, bold, dim, green, yellow, red, cyan, check, line, warn, spinner };
+};
+
+export {
+  createIo
+};