@basaltkit/cli 1.1.0 → 1.2.1

package/dist/index.js

@@ -1,420 +1,9 @@
-// src/command.ts
-function defineCommand(command) {
-  return command;
-}
-
-// src/runner.ts
-import { ensureMetadata } from "@basaltkit/core";
-
-// src/builtins.ts
-import { METADATA } from "@basaltkit/core";
-
-// src/dev.ts
-var DEV_ENTRY_CANDIDATES = ["src/main.ts", "src/server.ts", "src/index.ts", "src/main.js", "src/index.js"];
-function resolveDevEntry(candidates, exists) {
-  return candidates.find(exists);
-}
-function resolveDevRunner(entry, options = {}) {
-  const isTs = /\.tsx?$/.test(entry);
-  if (isTs && options.tsx) return { command: "tsx", args: ["watch", entry] };
-  if (isTs) return { command: "node", args: ["--watch", "--experimental-strip-types", entry] };
-  return { command: "node", args: ["--watch", entry] };
-}
-var devCommand = defineCommand({
-  name: "dev",
-  description: "Run the app with file watching and auto-restart",
-  async handle({ io, flags }) {
-    const { existsSync } = await import("fs");
-    const entry = typeof flags["entry"] === "string" ? flags["entry"] : resolveDevEntry(DEV_ENTRY_CANDIDATES, existsSync);
-    if (!entry) {
-      io.error(
-        `No entry file found. Looked for ${DEV_ENTRY_CANDIDATES.join(", ")}. Pass --entry=<file>.`
-      );
-      return 1;
-    }
-    const tsx = await canResolve("tsx");
-    const runner = resolveDevRunner(entry, { tsx });
-    io.log(`Starting: ${runner.command} ${runner.args.join(" ")}`);
-    const { spawn } = await import("child_process");
-    return await new Promise((resolve) => {
-      const child = spawn(runner.command, runner.args, { stdio: "inherit" });
-      const stop = () => child.kill("SIGINT");
-      process.once("SIGINT", stop);
-      child.on("exit", (code) => {
-        process.removeListener("SIGINT", stop);
-        resolve(code ?? 0);
-      });
-      child.on("error", (error) => {
-        io.error(`Failed to start dev runner: ${error.message}`);
-        resolve(1);
-      });
-    });
-  }
-});
-async function canResolve(specifier) {
-  try {
-    const { createRequire } = await import("module");
-    createRequire(`${process.cwd()}/`).resolve(specifier);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/upgrade.ts
-var renameMachizeScope = {
-  id: "rename-machize-scope",
-  description: "Rewrite the deprecated @machize/* scope to @basaltkit/*",
-  async plan(fs, dir) {
-    const files = (await fs.list(dir)).filter((p) => /\.(t|j)sx?$|\.json$/.test(p));
-    const edits = [];
-    for (const path of files) {
-      const before = await fs.read(path);
-      if (!before.includes("@machize/")) continue;
-      const after = before.split("@machize/").join("@basaltkit/");
-      if (after !== before) edits.push({ path, before, after });
-    }
-    return edits;
-  }
-};
-var MIGRATIONS = [renameMachizeScope];
-async function runUpgrade(migrations, fs, options) {
-  const selected = options.only ? migrations.filter((m) => m.id === options.only) : migrations;
-  const reports = [];
-  for (const migration of selected) {
-    const edits = await migration.plan(fs, options.dir);
-    if (!options.dry) {
-      for (const edit of edits) await fs.write(edit.path, edit.after);
-    }
-    reports.push({ migration: migration.id, changed: edits.map((e) => e.path) });
-  }
-  return reports;
-}
-function nodeUpgradeFs() {
-  const SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".next", "build", "coverage"]);
-  return {
-    async list(dir) {
-      const { readdir } = await import("fs/promises");
-      const { join, relative } = await import("path");
-      const out = [];
-      const walk = async (current) => {
-        const entries = await readdir(current, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            if (!SKIP.has(entry.name)) await walk(join(current, entry.name));
-          } else {
-            out.push(relative(dir, join(current, entry.name)));
-          }
-        }
-      };
-      await walk(dir);
-      return out;
-    },
-    async read(path) {
-      const { readFile } = await import("fs/promises");
-      const { isAbsolute, join } = await import("path");
-      return readFile(isAbsolute(path) ? path : join(process.cwd(), path), "utf8");
-    },
-    async write(path, content) {
-      const { writeFile } = await import("fs/promises");
-      const { isAbsolute, join } = await import("path");
-      await writeFile(isAbsolute(path) ? path : join(process.cwd(), path), content, "utf8");
-    }
-  };
-}
-var upgradeCommand = defineCommand({
-  name: "upgrade",
-  description: "Apply framework upgrade codemods (--dry to preview, --only=<id>)",
-  async handle({ io, flags }) {
-    const dir = typeof flags["dir"] === "string" ? flags["dir"] : process.cwd();
-    const dry = flags["dry"] === true;
-    const only = typeof flags["only"] === "string" ? flags["only"] : void 0;
-    if (only && !MIGRATIONS.some((m) => m.id === only)) {
-      io.error(`Unknown migration "${only}". Available: ${MIGRATIONS.map((m) => m.id).join(", ")}.`);
-      return 1;
-    }
-    const reports = await runUpgrade(MIGRATIONS, nodeUpgradeFs(), {
-      dir,
-      dry,
-      ...only ? { only } : {}
-    });
-    let total = 0;
-    for (const report of reports) {
-      if (report.changed.length === 0) continue;
-      total += report.changed.length;
-      io.log(`${dry ? "[dry] " : ""}${report.migration}: ${report.changed.length} file(s)`);
-      for (const path of report.changed) io.log(`  ${path}`);
-    }
-    if (total === 0) io.log("Nothing to upgrade \u2014 everything is up to date.");
-    else if (dry) io.log(`
-${total} file(s) would change. Re-run without --dry to apply.`);
-    else io.log(`
-Applied ${total} change(s).`);
-    return 0;
-  }
-});
-
-// src/publish.ts
-var DOCKERFILE = `# syntax=docker/dockerfile:1
-FROM node:22-slim AS base
-ENV NODE_ENV=production
-WORKDIR /app
-
-FROM base AS deps
-COPY package.json pnpm-lock.yaml* ./
-RUN corepack enable && pnpm install --prod --frozen-lockfile
-
-FROM base AS run
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-EXPOSE 3000
-CMD ["node", "dist/main.js"]
-`;
-var CI_WORKFLOW = `name: ci
-on:
-  push: { branches: [main] }
-  pull_request:
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: 22, cache: pnpm }
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm run build
-      - run: pnpm run test
-`;
-var EDITORCONFIG = `root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = true
-`;
-var PUBLISHABLES = [
-  { id: "dockerfile", description: "Production multi-stage Dockerfile", files: () => [{ path: "Dockerfile", content: DOCKERFILE }] },
-  { id: "ci", description: "GitHub Actions CI workflow", files: () => [{ path: ".github/workflows/ci.yml", content: CI_WORKFLOW }] },
-  { id: "editorconfig", description: "Shared .editorconfig", files: () => [{ path: ".editorconfig", content: EDITORCONFIG }] }
-];
-async function runPublish(publishable, fs, options = {}) {
-  const written = [];
-  const skipped = [];
-  for (const file of publishable.files()) {
-    if (!options.force && await fs.exists(file.path)) {
-      skipped.push(file.path);
-      continue;
-    }
-    await fs.write(file.path, file.content);
-    written.push(file.path);
-  }
-  return { written, skipped };
-}
-function nodePublishFs(dir) {
-  return {
-    async exists(path) {
-      const { access } = await import("fs/promises");
-      const { join } = await import("path");
-      return access(join(dir, path)).then(
-        () => true,
-        () => false
-      );
-    },
-    async write(path, content) {
-      const { mkdir, writeFile } = await import("fs/promises");
-      const { dirname, join } = await import("path");
-      const target = join(dir, path);
-      await mkdir(dirname(target), { recursive: true });
-      await writeFile(target, content, "utf8");
-    }
-  };
-}
-var publishCommand = defineCommand({
-  name: "publish",
-  description: "Copy a publishable stub group into the app (run with no id to list)",
-  async handle({ io, args, flags }) {
-    const id = args[0];
-    if (!id) {
-      io.log("Publishable groups:");
-      io.table(PUBLISHABLES.map((p) => ({ id: p.id, description: p.description })));
-      return 0;
-    }
-    const publishable = PUBLISHABLES.find((p) => p.id === id);
-    if (!publishable) {
-      io.error(`Unknown publishable "${id}". Available: ${PUBLISHABLES.map((p) => p.id).join(", ")}.`);
-      return 1;
-    }
-    const dir = typeof flags["dir"] === "string" ? flags["dir"] : process.cwd();
-    const result = await runPublish(publishable, nodePublishFs(dir), { force: flags["force"] === true });
-    for (const path of result.written) io.log(`  wrote ${path}`);
-    for (const path of result.skipped) io.log(`  skipped ${path} (exists \u2014 use --force to overwrite)`);
-    if (result.written.length === 0 && result.skipped.length > 0) {
-      io.log("Nothing written. Re-run with --force to overwrite existing files.");
-    }
-    return 0;
-  }
-});
-
-// src/builtins.ts
-var routesCommand = defineCommand({
-  name: "routes",
-  description: "List the HTTP routes registered by the app",
-  handle({ container, io }) {
-    const routes = container.has(METADATA) ? container.get(METADATA).get("http:routes") : [];
-    if (routes.length === 0) {
-      io.log("No routes registered.");
-      return;
-    }
-    io.table(routes.map(({ method, url }) => ({ method, url })));
-  }
-});
-var scheduleListCommand = defineCommand({
-  name: "schedule:list",
-  description: "List scheduled tasks and their cron expressions",
-  handle({ container, io }) {
-    const entries = container.has(METADATA) ? container.get(METADATA).get("schedule:entries") : [];
-    if (entries.length === 0) {
-      io.log("No scheduled tasks.");
-      return;
-    }
-    io.table(entries.map(({ name, cron, timezone }) => ({ name, cron, timezone })));
-  }
-});
-function builtinCommands() {
-  return [routesCommand, scheduleListCommand, devCommand, upgradeCommand, publishCommand];
-}
-
-// src/io.ts
-import { createInterface } from "readline/promises";
-function renderTable(rows) {
-  if (rows.length === 0) return "(empty)";
-  const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
-  const cell = (value) => value === void 0 || value === null ? "" : String(value);
-  const widths = columns.map(
-    (column) => Math.max(column.length, ...rows.map((row) => cell(row[column]).length))
-  );
-  const line = (values) => values.map((value, index) => value.padEnd(widths[index])).join("  ");
-  return [
-    line(columns),
-    line(widths.map((width) => "-".repeat(width))),
-    ...rows.map((row) => line(columns.map((column) => cell(row[column]))))
-  ].join("\n");
-}
-function consoleIo() {
-  return {
-    log: (message) => console.log(message),
-    error: (message) => console.error(message),
-    table: (rows) => console.log(renderTable(rows)),
-    confirm: async (question) => {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      try {
-        const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
-        return answer === "y" || answer === "yes";
-      } finally {
-        rl.close();
-      }
-    }
-  };
-}
-function memoryIo(options = {}) {
-  const lines = [];
-  const errors = [];
-  const answers = [...options.answers ?? []];
-  return {
-    lines,
-    errors,
-    log: (message) => void lines.push(message),
-    error: (message) => void errors.push(message),
-    table: (rows) => void lines.push(renderTable(rows)),
-    confirm: async () => answers.shift() ?? true
-  };
-}
-
-// src/parse.ts
-function parseArgv(argv) {
-  let command;
-  const args = [];
-  const flags = {};
-  for (const token of argv) {
-    if (token.startsWith("--")) {
-      const body = token.slice(2);
-      const eq = body.indexOf("=");
-      if (eq === -1) flags[body] = true;
-      else flags[body.slice(0, eq)] = body.slice(eq + 1);
-    } else if (command === void 0) {
-      command = token;
-    } else {
-      args.push(token);
-    }
-  }
-  return { command, args, flags };
-}
-
-// src/runner.ts
-async function runCli(options) {
-  const { app } = options;
-  const io = options.io ?? consoleIo();
-  const { command, args, flags } = parseArgv(options.argv ?? process.argv.slice(2));
-  if (app.phase === "created") await app.boot();
-  try {
-    const registered = ensureMetadata(app.container).get("commands");
-    const commands = [...builtinCommands(), ...registered];
-    if (command === void 0 || command === "list") {
-      io.log("Available commands:");
-      io.table(
-        commands.map(({ name, description }) => ({ command: name, description: description ?? "" }))
-      );
-      return 0;
-    }
-    const found = commands.find((candidate) => candidate.name === command);
-    if (!found) {
-      io.error(`Unknown command "${command}". Run "basalt list" to see what is available.`);
-      return 1;
-    }
-    const code = await found.handle({ app, container: app.container, io, args, flags });
-    return code ?? 0;
-  } finally {
-    await app.shutdown();
-  }
-}
-
-// src/plugin.ts
-import { definePlugin, ensureMetadata as ensureMetadata2 } from "@basaltkit/core";
-function commandsPlugin(commands) {
-  return definePlugin({
-    name: "basalt:commands",
-    register({ container }) {
-      const metadata = ensureMetadata2(container);
-      for (const command of commands) metadata.add("commands", command);
-    }
-  });
-}
-export {
-  DEV_ENTRY_CANDIDATES,
-  MIGRATIONS,
-  PUBLISHABLES,
-  builtinCommands,
-  commandsPlugin,
-  consoleIo,
-  defineCommand,
-  devCommand,
-  memoryIo,
-  nodePublishFs,
-  nodeUpgradeFs,
-  parseArgv,
-  publishCommand,
-  renameMachizeScope,
-  renderTable,
-  resolveDevEntry,
-  resolveDevRunner,
-  routesCommand,
-  runCli,
-  runPublish,
-  runUpgrade,
-  scheduleListCommand,
-  upgradeCommand
-};
+export { defineCommand } from './command.js';
+export { runCli } from './runner.js';
+export { commandsPlugin } from './plugin.js';
+export { consoleIo, memoryIo, renderTable } from './io.js';
+export { parseArgv } from './parse.js';
+export { builtinCommands, routesCommand, scheduleListCommand, } from './builtins.js';
+export { devCommand, resolveDevEntry, resolveDevRunner, devRouteRows, DEV_ENTRY_CANDIDATES, } from './dev.js';
+export { upgradeCommand, runUpgrade, MIGRATIONS, renameMachizeScope, nodeUpgradeFs, } from './upgrade.js';
+export { publishCommand, runPublish, PUBLISHABLES, nodePublishFs, } from './publish.js';

package/dist/io.d.ts

@@ -0,0 +1,14 @@
+import type { CommandIo } from './command.js';
+/** Renders rows as an aligned text table (no external dependencies). */
+export declare function renderTable(rows: Record<string, unknown>[]): string;
+export declare function consoleIo(): CommandIo;
+/**
+ * In-memory IO for tests. `answers` feeds `confirm()` in order (defaults to yes
+ * once the queue is drained), so a test can drive an interactive command.
+ */
+export declare function memoryIo(options?: {
+    answers?: boolean[];
+}): CommandIo & {
+    lines: string[];
+    errors: string[];
+};

package/dist/io.js

@@ -0,0 +1,49 @@
+import { createInterface } from 'node:readline/promises';
+/** Renders rows as an aligned text table (no external dependencies). */
+export function renderTable(rows) {
+    if (rows.length === 0)
+        return '(empty)';
+    const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+    const cell = (value) => value === undefined || value === null ? '' : String(value);
+    const widths = columns.map((column) => Math.max(column.length, ...rows.map((row) => cell(row[column]).length)));
+    const line = (values) => values.map((value, index) => value.padEnd(widths[index])).join('  ');
+    return [
+        line(columns),
+        line(widths.map((width) => '-'.repeat(width))),
+        ...rows.map((row) => line(columns.map((column) => cell(row[column])))),
+    ].join('\n');
+}
+export function consoleIo() {
+    return {
+        log: (message) => console.log(message),
+        error: (message) => console.error(message),
+        table: (rows) => console.log(renderTable(rows)),
+        confirm: async (question) => {
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            try {
+                const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+                return answer === 'y' || answer === 'yes';
+            }
+            finally {
+                rl.close();
+            }
+        },
+    };
+}
+/**
+ * In-memory IO for tests. `answers` feeds `confirm()` in order (defaults to yes
+ * once the queue is drained), so a test can drive an interactive command.
+ */
+export function memoryIo(options = {}) {
+    const lines = [];
+    const errors = [];
+    const answers = [...(options.answers ?? [])];
+    return {
+        lines,
+        errors,
+        log: (message) => void lines.push(message),
+        error: (message) => void errors.push(message),
+        table: (rows) => void lines.push(renderTable(rows)),
+        confirm: async () => answers.shift() ?? true,
+    };
+}

package/dist/parse.d.ts

@@ -0,0 +1,7 @@
+export interface ParsedArgv {
+    command: string | undefined;
+    args: string[];
+    flags: Record<string, string | boolean>;
+}
+/** Minimal argv parser: first bare word is the command; `--key=value` and `--flag` become flags. */
+export declare function parseArgv(argv: string[]): ParsedArgv;

package/dist/parse.js

@@ -0,0 +1,23 @@
+/** Minimal argv parser: first bare word is the command; `--key=value` and `--flag` become flags. */
+export function parseArgv(argv) {
+    let command;
+    const args = [];
+    const flags = {};
+    for (const token of argv) {
+        if (token.startsWith('--')) {
+            const body = token.slice(2);
+            const eq = body.indexOf('=');
+            if (eq === -1)
+                flags[body] = true;
+            else
+                flags[body.slice(0, eq)] = body.slice(eq + 1);
+        }
+        else if (command === undefined) {
+            command = token;
+        }
+        else {
+            args.push(token);
+        }
+    }
+    return { command, args, flags };
+}

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { CommandDefinition } from './command.js';
+/** Registers app-defined commands into the 'commands' metadata bucket. */
+export declare function commandsPlugin(commands: CommandDefinition[]): import("@basaltkit/core").BasaltPlugin<unknown>;

package/dist/plugin.js

@@ -0,0 +1,12 @@
+import { definePlugin, ensureMetadata } from '@basaltkit/core';
+/** Registers app-defined commands into the 'commands' metadata bucket. */
+export function commandsPlugin(commands) {
+    return definePlugin({
+        name: 'basalt:commands',
+        register({ container }) {
+            const metadata = ensureMetadata(container);
+            for (const command of commands)
+                metadata.add('commands', command);
+        },
+    });
+}

package/dist/publish.d.ts

@@ -0,0 +1,35 @@
+import { type CommandDefinition } from './command.js';
+/** One file a publishable drops into the app. */
+export interface PublishableFile {
+    /** Path relative to the target dir, e.g. `Dockerfile` or `.github/workflows/ci.yml`. */
+    path: string;
+    content: string;
+}
+/** A named group of stub files an app can copy in and then own (à la vendor:publish). */
+export interface Publishable {
+    id: string;
+    description: string;
+    files(): PublishableFile[];
+}
+/** Filesystem surface for publishing — injected so `runPublish` is testable. */
+export interface PublishFs {
+    exists(path: string): Promise<boolean>;
+    write(path: string, content: string): Promise<void>;
+}
+export interface PublishResult {
+    written: string[];
+    skipped: string[];
+}
+/** Stubs bundled with the CLI. Apps can register more via the metadata bucket. */
+export declare const PUBLISHABLES: Publishable[];
+/**
+ * Copies a publishable's files into the target, skipping any that already exist
+ * unless `force` is set. Returns which files were written vs skipped.
+ */
+export declare function runPublish(publishable: Publishable, fs: PublishFs, options?: {
+    force?: boolean;
+}): Promise<PublishResult>;
+/** Node-backed {@link PublishFs} rooted at `dir` (creates parent directories). */
+export declare function nodePublishFs(dir: string): PublishFs;
+/** `basalt publish [<id>] [--dir=<path>] [--force]` — list, or copy a stub group. */
+export declare const publishCommand: CommandDefinition;

package/dist/publish.js

@@ -0,0 +1,110 @@
+import { defineCommand } from './command.js';
+const DOCKERFILE = `# syntax=docker/dockerfile:1
+FROM node:22-slim AS base
+ENV NODE_ENV=production
+WORKDIR /app
+
+FROM base AS deps
+COPY package.json pnpm-lock.yaml* ./
+RUN corepack enable && pnpm install --prod --frozen-lockfile
+
+FROM base AS run
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+EXPOSE 3000
+CMD ["node", "dist/main.js"]
+`;
+const CI_WORKFLOW = `name: ci
+on:
+  push: { branches: [main] }
+  pull_request:
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 22, cache: pnpm }
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm run build
+      - run: pnpm run test
+`;
+const EDITORCONFIG = `root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+`;
+/** Stubs bundled with the CLI. Apps can register more via the metadata bucket. */
+export const PUBLISHABLES = [
+    { id: 'dockerfile', description: 'Production multi-stage Dockerfile', files: () => [{ path: 'Dockerfile', content: DOCKERFILE }] },
+    { id: 'ci', description: 'GitHub Actions CI workflow', files: () => [{ path: '.github/workflows/ci.yml', content: CI_WORKFLOW }] },
+    { id: 'editorconfig', description: 'Shared .editorconfig', files: () => [{ path: '.editorconfig', content: EDITORCONFIG }] },
+];
+/**
+ * Copies a publishable's files into the target, skipping any that already exist
+ * unless `force` is set. Returns which files were written vs skipped.
+ */
+export async function runPublish(publishable, fs, options = {}) {
+    const written = [];
+    const skipped = [];
+    for (const file of publishable.files()) {
+        if (!options.force && (await fs.exists(file.path))) {
+            skipped.push(file.path);
+            continue;
+        }
+        await fs.write(file.path, file.content);
+        written.push(file.path);
+    }
+    return { written, skipped };
+}
+/** Node-backed {@link PublishFs} rooted at `dir` (creates parent directories). */
+export function nodePublishFs(dir) {
+    return {
+        async exists(path) {
+            const { access } = await import('node:fs/promises');
+            const { join } = await import('node:path');
+            return access(join(dir, path)).then(() => true, () => false);
+        },
+        async write(path, content) {
+            const { mkdir, writeFile } = await import('node:fs/promises');
+            const { dirname, join } = await import('node:path');
+            const target = join(dir, path);
+            await mkdir(dirname(target), { recursive: true });
+            await writeFile(target, content, 'utf8');
+        },
+    };
+}
+/** `basalt publish [<id>] [--dir=<path>] [--force]` — list, or copy a stub group. */
+export const publishCommand = defineCommand({
+    name: 'publish',
+    description: 'Copy a publishable stub group into the app (run with no id to list)',
+    async handle({ io, args, flags }) {
+        const id = args[0];
+        if (!id) {
+            io.log('Publishable groups:');
+            io.table(PUBLISHABLES.map((p) => ({ id: p.id, description: p.description })));
+            return 0;
+        }
+        const publishable = PUBLISHABLES.find((p) => p.id === id);
+        if (!publishable) {
+            io.error(`Unknown publishable "${id}". Available: ${PUBLISHABLES.map((p) => p.id).join(', ')}.`);
+            return 1;
+        }
+        const dir = typeof flags['dir'] === 'string' ? flags['dir'] : process.cwd();
+        const result = await runPublish(publishable, nodePublishFs(dir), { force: flags['force'] === true });
+        for (const path of result.written)
+            io.log(`  wrote ${path}`);
+        for (const path of result.skipped)
+            io.log(`  skipped ${path} (exists — use --force to overwrite)`);
+        if (result.written.length === 0 && result.skipped.length > 0) {
+            io.log('Nothing written. Re-run with --force to overwrite existing files.');
+        }
+        return 0;
+    },
+});