@cfbender/cesium 0.5.2 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,89 @@
 # Changelog
 
+## v0.6.1 — 2026-05-13
+
+Fixes a regression introduced by the v0.4 blocks refactor: the README's
+"self-contained HTML file" claim had quietly become false. Block-based
+artifacts (cards, callouts, compare-tables, timelines, code) rendered as
+broken-looking plain HTML when opened via `file://` because the inline
+fallback CSS only covered basic typography — all the block styling lived
+in the server-side `theme.css`. Sharing an artifact required either the
+running cesium server or a recipient who happened to have it.
+
+- **feat:** Artifacts now embed the full `theme.css` (~21KB) in an inline
+  `<style>` block at generation time. Opening any artifact via `file://`
+  or on any other machine now renders correctly with zero external
+  dependencies — typography, blocks, tables, controls, diff renderer, all
+  of it. The `<link rel="stylesheet" href=".../theme.css">` is preserved
+  so served artifacts still pick up live theme changes (the link rules
+  override the earlier inline `<style>` in cascade order).
+- **feat:** New `cesium export <id-prefix>` command emits an artifact's
+  self-contained HTML to stdout, or to `--out file.html`. Resolves the id
+  prefix against the global index the same way `cesium open` does. With
+  the baked-in CSS, export is now a near-trivial file copy — pipe it
+  anywhere, attach it to email, drop it in a chat, commit it to a repo.
+- **refactor:** Removed `src/render/fallback.ts` and the matching test
+  file. The 8-line fallback CSS it produced is no longer needed; the
+  inline `<style>` carries the full framework directly.
+- **chore:** README "Share an artifact" section now leads with
+  `cesium export` and explains the bake-and-override model.
+
+Old artifacts on disk are not retroactively re-baked — they keep their
+generation-time fallback + link, which means they continue to render
+fine when served by cesium but look plain when opened standalone.
+Historical fidelity is preserved. New artifacts written from v0.6.1
+onward are genuinely portable.
+
+## v0.6.0 — 2026-05-13
+
+Internal cleanup release. Two hand-rolled server and CLI layers swapped
+for small, well-fit libraries (Hono and Citty) that delete the regex and
+dispatcher boilerplate without changing user-visible behavior. No new
+features and no protocol changes — artifacts written by older versions
+continue rendering unchanged.
+
+- **refactor:** Migrate the cesium HTTP server from a hand-rolled
+  `Bun.serve` fetch handler with a custom `preHandlers` middleware chain
+  to a Hono app fronted by Bun.serve. Routes for `/api/sessions/*` and
+  `/favicon.ico` now use Hono's typed `:param` syntax instead of regex
+  match + manual narrowing. The static file handler is preserved verbatim
+  and mounted as `app.notFound` so all 11 existing static-serve tests
+  pass unchanged. `ServerHandle.app: Hono` replaces `addHandler` for
+  callers that need to register additional routes.
+- **refactor:** Migrate the `cesium` CLI from `node:util parseArgs` +
+  a hand-rolled subcommand dispatcher to Citty. Each command file now
+  exports a typed `runX(args, ctx)` inner function (kept directly
+  testable with injected `{stdout, stderr, loadConfig}`) plus an outer
+  `xxxCmd = defineCommand(...)` that Citty consumes. Subcommands load
+  lazily via dynamic `import()` so cold-start cost is paid only for the
+  command the user actually invoked. `cesium theme show|apply` is now
+  expressed as native Citty sub-subcommands rather than the previous
+  manual routing.
+- **fix:** `cesium restart` no longer fails on serve-only flags. The
+  previous implementation passed argv through to both `stopCommand` and
+  `serveCommand` under `strict: true`, so `cesium restart --port 4000`
+  would have errored. Restart now defines its own arg schema covering
+  both stop and serve options.
+- **chore:** Clean up all 25 oxlint warnings:
+  - Restructure `src/server/api.ts` regex matching to remove four
+    `!` non-null assertions.
+  - Replace `match![1]!` patterns in tests with a local `unwrap(value,
+    name)` helper for proper type narrowing.
+  - Replace `handle!.url` in tests with an explicit null check.
+  - Add targeted `eslint-disable-next-line no-await-in-loop` comments
+    (with `--` reason annotations matching the existing repo convention)
+    in places where sequential execution is required: middleware chain,
+    poll-with-backoff retry, short-circuit search.
+- **chore:** Add `hono@4.12.18` and `citty@0.2.2` to dependencies.
+  Removes a meaningful amount of hand-rolled routing / arg-parsing code
+  for ~50KB total install footprint.
+- **chore:** `cesium --version` output format changes from
+  `cesium 0.6.0` to plain `0.6.0` (Citty's default). The `cesium version`
+  subcommand is removed — use `cesium --version` or `cesium -v`. Auto-
+  generated help text for each command also follows Citty's formatting
+  (uppercase USAGE/OPTIONS, color codes, default annotations) rather
+  than the previous hand-aligned `Usage: cesium ls` strings.
+
 ## v0.5.2 — 2026-05-12
 
 A 16th block type — `diff` — that renders a beautiful side-by-side

package/README.md

@@ -48,8 +48,8 @@ unreleased changes).
 ### CLI
 
 The CLI puts a `cesium` binary on your `PATH` for browsing, opening, and
-managing artifacts (`cesium ls`, `cesium open`, `cesium serve`, `cesium prune`,
-`cesium theme`).
+managing artifacts (`cesium ls`, `cesium open`, `cesium export`, `cesium serve`,
+`cesium prune`, `cesium theme`).
 
 **Recommended: install with [mise](https://mise.jdx.dev/)** so cesium is pinned
 in your config and tracks with the rest of your toolchain. Add to your
@@ -292,15 +292,24 @@ cesium open a7K9 --print  # just print the URL
 
 ### Share an artifact
 
-Each artifact is a single self-contained `.html` file — no external resources.
-Three ways to share:
+Each artifact is a single self-contained `.html` file — the full theme CSS is
+baked into a `<style>` tag at generation time, so it renders correctly when
+opened anywhere. Four ways to share:
 
+- **Pipe it anywhere** — `cesium export <id-prefix>` dumps the file to stdout;
+  `cesium export <id-prefix> --out plan.html` writes it to disk. The output
+  is a portable HTML file you can attach to email, drop in a chat, or commit
+  to a repo. Opens correctly with no server running.
 - **Same machine** — copy or attach the `file://` path printed in the terminal.
 - **Over SSH** — forward the port with `ssh -L 3030:localhost:3030 your-host`,
   then send the `http://localhost:3030/...` URL.
 - **On a trusted LAN** — set `"hostname": "0.0.0.0"` in `cesium.json` and share
   the LAN URL. Only do this on networks you trust.
 
+When an artifact is served by the cesium HTTP server, a `<link>` to the live
+`theme.css` overrides the baked-in `<style>` so theme changes apply retroactively
+to served pages. Standalone copies keep their generation-time look forever.
+
 ### Clean up old artifacts
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfbender/cesium",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "Beautiful self-contained HTML artifacts from your opencode agent.",
   "keywords": [
     "agent",
@@ -46,6 +46,8 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "latest",
+    "citty": "^0.2.2",
+    "hono": "^4.12.18",
     "nanoid": "^5.0.0",
     "parse5": "^7.1.0",
     "shiki": "^4.0.2"

package/src/cli/commands/export.ts

@@ -0,0 +1,143 @@
+// cesium export — emit an artifact's HTML to stdout (or a file).
+//
+// Because cesium artifacts are written with the full theme CSS baked into a
+// <style> tag at generation time, an artifact file on disk is already a
+// fully self-contained HTML document. Export is therefore a thin wrapper:
+// resolve by id-prefix, read the file, write to stdout or --out.
+//
+// (When served by the cesium HTTP server, the <link rel="stylesheet"
+// href=".../theme.css"> in the same artifact still loads and overrides the
+// baked CSS in cascade order, so live theme changes apply server-side. The
+// baked CSS only acts as the standalone fallback.)
+
+import { defineCommand } from "citty";
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { loadConfig, type CesiumConfig } from "../../config.ts";
+import { loadIndex } from "../../storage/index-cache.ts";
+import { pathsFor } from "../../storage/paths.ts";
+import { atomicWrite } from "../../storage/write.ts";
+
+export interface ExportArgs {
+  idPrefix: string;
+  out: string | null;
+}
+
+export interface ExportContext {
+  stdout: { write: (s: string) => void };
+  stderr: { write: (s: string) => void };
+  loadConfig?: () => CesiumConfig;
+}
+
+function defaultCtx(): ExportContext {
+  return {
+    stdout: process.stdout,
+    stderr: process.stderr,
+  };
+}
+
+export async function runExport(
+  args: ExportArgs,
+  ctxOverride?: Partial<ExportContext>,
+): Promise<number> {
+  const ctx: ExportContext = { ...defaultCtx(), ...ctxOverride };
+
+  if (args.idPrefix.length === 0) {
+    ctx.stderr.write(`cesium export: missing required argument <id-prefix>\n`);
+    return 1;
+  }
+
+  const prefixLower = args.idPrefix.toLowerCase();
+  const cfg = (ctx.loadConfig ?? loadConfig)();
+
+  // Resolve artifact via global index (same matching as `open`)
+  const globalJsonPath = join(cfg.stateDir, "index.json");
+  let allEntries;
+  try {
+    allEntries = await loadIndex(globalJsonPath);
+  } catch (err) {
+    const e = err as Error;
+    ctx.stderr.write(`cesium export: failed to read index: ${e.message}\n`);
+    return 1;
+  }
+
+  const matches = allEntries.filter((e) => e.id.toLowerCase().startsWith(prefixLower));
+
+  if (matches.length === 0) {
+    ctx.stderr.write(`cesium export: no artifact found with id prefix "${args.idPrefix}"\n`);
+    return 1;
+  }
+
+  if (matches.length > 1) {
+    ctx.stderr.write(
+      `cesium export: ambiguous prefix "${args.idPrefix}" — ${matches.length} matches:\n`,
+    );
+    for (const m of matches) {
+      ctx.stderr.write(`  ${m.id}  ${m.title}  (${m.kind})\n`);
+    }
+    return 2;
+  }
+
+  const entry = matches[0];
+  if (entry === undefined) {
+    // Unreachable; satisfies type checker
+    ctx.stderr.write(`cesium export: internal error — no match\n`);
+    return 1;
+  }
+
+  const paths = pathsFor({
+    stateDir: cfg.stateDir,
+    projectSlug: entry.projectSlug,
+    filename: entry.filename,
+  });
+
+  let html: string;
+  try {
+    html = await readFile(paths.artifactPath, "utf8");
+  } catch (err) {
+    const e = err as Error;
+    ctx.stderr.write(`cesium export: failed to read artifact: ${e.message}\n`);
+    return 1;
+  }
+
+  if (args.out !== null) {
+    try {
+      await atomicWrite(args.out, html);
+    } catch (err) {
+      const e = err as Error;
+      ctx.stderr.write(`cesium export: failed to write ${args.out}: ${e.message}\n`);
+      return 1;
+    }
+    ctx.stderr.write(`Wrote ${args.out}\n`);
+    return 0;
+  }
+
+  ctx.stdout.write(html);
+  return 0;
+}
+
+export const exportCmd = defineCommand({
+  meta: {
+    name: "export",
+    description: "Emit an artifact's self-contained HTML to stdout (or --out file).",
+  },
+  args: {
+    idPrefix: {
+      type: "positional",
+      description: "Artifact id prefix (any unique substring of the id)",
+      required: true,
+    },
+    out: {
+      type: "string",
+      alias: "o",
+      description: "Write to this file path instead of stdout",
+    },
+  },
+  async run({ args }) {
+    const code = await runExport({
+      idPrefix: args.idPrefix,
+      out: args.out ?? null,
+    });
+    if (code !== 0) process.exit(code);
+  },
+});

package/src/cli/commands/ls.ts

@@ -1,12 +1,18 @@
 // cesium ls — list artifacts for current project (or all).
 
-import { parseArgs } from "node:util";
+import { defineCommand } from "citty";
 import { join } from "node:path";
 import { execSync } from "node:child_process";
 import { loadConfig, type CesiumConfig } from "../../config.ts";
 import { loadIndex, type IndexEntry } from "../../storage/index-cache.ts";
 import { deriveProjectIdentity } from "../../storage/paths.ts";
 
+export interface LsArgs {
+  all: boolean;
+  json: boolean;
+  limit: number;
+}
+
 export interface LsContext {
   stdout: { write: (s: string) => void };
   stderr: { write: (s: string) => void };
@@ -58,69 +64,27 @@ function getGitRemote(cwd: string): string | null {
   }
 }
 
-export async function lsCommand(argv: string[], ctx?: Partial<LsContext>): Promise<number> {
-  const resolved: LsContext = { ...defaultCtx(), ...ctx };
-
-  let values: {
-    all: boolean;
-    json: boolean;
-    limit: string | undefined;
-    help: boolean;
-  };
-
-  try {
-    const parsed = parseArgs({
-      args: argv,
-      options: {
-        all: { type: "boolean", short: "a", default: false },
-        json: { type: "boolean", default: false },
-        limit: { type: "string", short: "n" },
-        help: { type: "boolean", short: "h", default: false },
-      },
-      allowPositionals: false,
-      strict: true,
-    });
-    values = parsed.values as typeof values;
-  } catch (err) {
-    const e = err as Error;
-    resolved.stderr.write(`cesium ls: ${e.message}\n`);
-    resolved.stderr.write(`Usage: cesium ls [--all] [--json] [--limit N]\n`);
-    return 1;
-  }
-
-  if (values.help) {
-    resolved.stdout.write(
-      [
-        "Usage: cesium ls [options]",
-        "",
-        "Options:",
-        "  --all, -a      Show artifacts for all projects (default: current project only)",
-        "  --json         Output as JSON array",
-        "  --limit, -n N  Show at most N most recent artifacts (default: 50)",
-        "  --help, -h     Show this help message",
-        "",
-      ].join("\n"),
-    );
-    return 0;
-  }
+/**
+ * Inner command logic. Tests call this directly with typed args + injected
+ * context for fast feedback; the Citty wrapper handles argv parsing.
+ */
+export async function runLs(args: LsArgs, ctxOverride?: Partial<LsContext>): Promise<number> {
+  const ctx: LsContext = { ...defaultCtx(), ...ctxOverride };
 
-  const limitRaw = values.limit !== undefined ? parseInt(values.limit, 10) : 50;
-  if (isNaN(limitRaw) || limitRaw < 1) {
-    resolved.stderr.write(`cesium ls: --limit must be a positive integer\n`);
+  if (args.limit < 1) {
+    ctx.stderr.write(`cesium ls: --limit must be a positive integer\n`);
     return 1;
   }
-  const limit = limitRaw;
 
-  // Load config
-  const cfg = (resolved.loadConfig ?? loadConfig)();
+  const cfg = (ctx.loadConfig ?? loadConfig)();
 
   // Determine which index.json to read
   let jsonPath: string;
-  if (values.all) {
+  if (args.all) {
     jsonPath = join(cfg.stateDir, "index.json");
   } else {
-    const gitRemote = getGitRemote(resolved.cwd);
-    const identity = deriveProjectIdentity({ cwd: resolved.cwd, gitRemote });
+    const gitRemote = getGitRemote(ctx.cwd);
+    const identity = deriveProjectIdentity({ cwd: ctx.cwd, gitRemote });
     jsonPath = join(cfg.stateDir, "projects", identity.slug, "index.json");
   }
 
@@ -129,21 +93,19 @@ export async function lsCommand(argv: string[], ctx?: Partial<LsContext>): Promi
     entries = await loadIndex(jsonPath);
   } catch (err) {
     const e = err as Error;
-    resolved.stderr.write(`cesium ls: failed to read index: ${e.message}\n`);
+    ctx.stderr.write(`cesium ls: failed to read index: ${e.message}\n`);
     return 1;
   }
 
-  // Already sorted newest-first by loadIndex / appendEntry; apply limit
-  const limited = entries.slice(0, limit);
+  const limited = entries.slice(0, args.limit);
 
-  if (values.json) {
-    resolved.stdout.write(JSON.stringify(limited, null, 2) + "\n");
+  if (args.json) {
+    ctx.stdout.write(JSON.stringify(limited, null, 2) + "\n");
     return 0;
   }
 
-  // Table output
   if (limited.length === 0) {
-    resolved.stdout.write("No artifacts found.\n");
+    ctx.stdout.write("No artifacts found.\n");
     return 0;
   }
 
@@ -165,8 +127,8 @@ export async function lsCommand(argv: string[], ctx?: Partial<LsContext>): Promi
 
   const sep = "─".repeat(header.length);
 
-  resolved.stdout.write(header + "\n");
-  resolved.stdout.write(sep + "\n");
+  ctx.stdout.write(header + "\n");
+  ctx.stdout.write(sep + "\n");
 
   for (const e of limited) {
     const row =
@@ -179,8 +141,43 @@ export async function lsCommand(argv: string[], ctx?: Partial<LsContext>): Promi
       fmtDate(e.createdAt).padEnd(COL_DATE) +
       "  " +
       superCol(e);
-    resolved.stdout.write(row + "\n");
+    ctx.stdout.write(row + "\n");
   }
 
   return 0;
 }
+
+export const lsCmd = defineCommand({
+  meta: {
+    name: "ls",
+    description: "List artifacts in the current project (or all with --all).",
+  },
+  args: {
+    all: {
+      type: "boolean",
+      alias: "a",
+      default: false,
+      description: "Show artifacts for all projects (default: current project only)",
+    },
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output as JSON array",
+    },
+    limit: {
+      type: "string",
+      alias: "n",
+      default: "50",
+      description: "Show at most N most recent artifacts",
+    },
+  },
+  async run({ args }) {
+    const limit = parseInt(args.limit, 10);
+    if (isNaN(limit) || limit < 1) {
+      process.stderr.write(`cesium ls: --limit must be a positive integer\n`);
+      process.exit(1);
+    }
+    const code = await runLs({ all: args.all, json: args.json, limit });
+    if (code !== 0) process.exit(code);
+  },
+});

package/src/cli/commands/open.ts

@@ -1,6 +1,6 @@
 // cesium open — find an artifact by id prefix and open it in the browser.
 
-import { parseArgs } from "node:util";
+import { defineCommand } from "citty";
 import { join } from "node:path";
 import { spawn } from "node:child_process";
 import { platform } from "node:os";
@@ -15,6 +15,11 @@ import {
 } from "../../server/lifecycle.ts";
 import { resolveDisplayHost } from "../../tools/publish.ts";
 
+export interface OpenArgs {
+  idPrefix: string;
+  print: boolean;
+}
+
 export interface OpenContext {
   stdout: { write: (s: string) => void };
   stderr: { write: (s: string) => void };
@@ -90,59 +95,16 @@ async function tryGetHttpUrl(
   return null;
 }
 
-export async function openCommand(argv: string[], ctx?: Partial<OpenContext>): Promise<number> {
-  const resolved: OpenContext = { ...defaultCtx(), ...ctx };
-
-  let values: { print: boolean; help: boolean };
-  let positionals: string[];
-
-  try {
-    const parsed = parseArgs({
-      args: argv,
-      options: {
-        print: { type: "boolean", default: false },
-        help: { type: "boolean", short: "h", default: false },
-      },
-      allowPositionals: true,
-      strict: true,
-    });
-    values = parsed.values as typeof values;
-    positionals = parsed.positionals;
-  } catch (err) {
-    const e = err as Error;
-    resolved.stderr.write(`cesium open: ${e.message}\n`);
-    resolved.stderr.write(`Usage: cesium open <id-prefix> [--print]\n`);
-    return 1;
-  }
-
-  if (values.help) {
-    resolved.stdout.write(
-      [
-        "Usage: cesium open <id-prefix> [options]",
-        "",
-        "Options:",
-        "  --print     Print the URL instead of opening in the browser",
-        "  --help, -h  Show this help message",
-        "",
-        "Notes:",
-        "  Browser launch is supported on macOS (open) and Linux (xdg-open).",
-        "  On Windows, use --print to get the URL.",
-        "",
-      ].join("\n"),
-    );
-    return 0;
-  }
+export async function runOpen(args: OpenArgs, ctxOverride?: Partial<OpenContext>): Promise<number> {
+  const ctx: OpenContext = { ...defaultCtx(), ...ctxOverride };
 
-  const idPrefix = positionals[0];
-  if (idPrefix === undefined || idPrefix.length === 0) {
-    resolved.stderr.write(`cesium open: missing required argument <id-prefix>\n`);
-    resolved.stderr.write(`Usage: cesium open <id-prefix> [--print]\n`);
+  if (args.idPrefix.length === 0) {
+    ctx.stderr.write(`cesium open: missing required argument <id-prefix>\n`);
     return 1;
   }
 
-  const prefixLower = idPrefix.toLowerCase();
-
-  const cfg = (resolved.loadConfig ?? loadConfig)();
+  const prefixLower = args.idPrefix.toLowerCase();
+  const cfg = (ctx.loadConfig ?? loadConfig)();
 
   // Search global index for matches
   const globalJsonPath = join(cfg.stateDir, "index.json");
@@ -151,23 +113,23 @@ export async function openCommand(argv: string[], ctx?: Partial<OpenContext>): P
     allEntries = await loadIndex(globalJsonPath);
   } catch (err) {
     const e = err as Error;
-    resolved.stderr.write(`cesium open: failed to read index: ${e.message}\n`);
+    ctx.stderr.write(`cesium open: failed to read index: ${e.message}\n`);
     return 1;
   }
 
   const matches = allEntries.filter((e) => e.id.toLowerCase().startsWith(prefixLower));
 
   if (matches.length === 0) {
-    resolved.stderr.write(`cesium open: no artifact found with id prefix "${idPrefix}"\n`);
+    ctx.stderr.write(`cesium open: no artifact found with id prefix "${args.idPrefix}"\n`);
     return 1;
   }
 
   if (matches.length > 1) {
-    resolved.stderr.write(
-      `cesium open: ambiguous prefix "${idPrefix}" — ${matches.length} matches:\n`,
+    ctx.stderr.write(
+      `cesium open: ambiguous prefix "${args.idPrefix}" — ${matches.length} matches:\n`,
     );
     for (const m of matches) {
-      resolved.stderr.write(`  ${m.id}  ${m.title}  (${m.kind})\n`);
+      ctx.stderr.write(`  ${m.id}  ${m.title}  (${m.kind})\n`);
     }
     return 2;
   }
@@ -175,7 +137,7 @@ export async function openCommand(argv: string[], ctx?: Partial<OpenContext>): P
   const entry = matches[0];
   if (entry === undefined) {
     // Unreachable: guarded by matches.length === 1, but satisfies the type checker
-    resolved.stderr.write(`cesium open: internal error — no match\n`);
+    ctx.stderr.write(`cesium open: internal error — no match\n`);
     return 1;
   }
   const paths = pathsFor({
@@ -185,24 +147,47 @@ export async function openCommand(argv: string[], ctx?: Partial<OpenContext>): P
   });
 
   // Resolve URL
-  const runEnsureRunning = resolved.ensureRunning ?? ensureRunning;
+  const runEnsureRunning = ctx.ensureRunning ?? ensureRunning;
   const httpUrl = await tryGetHttpUrl(cfg, paths.serverPath, runEnsureRunning);
   const url = httpUrl ?? paths.fileUrl;
 
-  if (values.print) {
-    resolved.stdout.write(url + "\n");
+  if (args.print) {
+    ctx.stdout.write(url + "\n");
     return 0;
   }
 
-  const open = resolved.opener ?? defaultOpener;
+  const open = ctx.opener ?? defaultOpener;
   try {
     await open(url);
   } catch (err) {
     const e = err as Error;
-    resolved.stderr.write(`cesium open: ${e.message}\n`);
-    resolved.stdout.write(`URL: ${url}\n`);
+    ctx.stderr.write(`cesium open: ${e.message}\n`);
+    ctx.stdout.write(`URL: ${url}\n`);
     return 1;
   }
 
   return 0;
 }
+
+export const openCmd = defineCommand({
+  meta: {
+    name: "open",
+    description: "Open an artifact by id prefix in the browser.",
+  },
+  args: {
+    idPrefix: {
+      type: "positional",
+      description: "Artifact id prefix (any unique substring of the id)",
+      required: true,
+    },
+    print: {
+      type: "boolean",
+      default: false,
+      description: "Print the URL instead of opening in the browser",
+    },
+  },
+  async run({ args }) {
+    const code = await runOpen({ idPrefix: args.idPrefix, print: args.print });
+    if (code !== 0) process.exit(code);
+  },
+});