@kabmo-labs/kabmo 0.0.0-stage → 0.0.1

package/src/cli/lib/build.js

@@ -0,0 +1,52 @@
+// Production-bundle build for the CLI.
+//
+// `serve` defaults to production and the published tarball ships `dist/client`,
+// but a source checkout has to build once. Doing it on demand (rather than
+// refusing with "run `bun run build` first") is what makes the default mode work
+// in a fresh clone: `bun install` provides Bun and the build script, and every
+// bundler dependency is already declared.
+//
+// Kept apart from runtime.js, which owns process lifecycle and instance
+// discovery: this is the one place the CLI executes the bundler.
+
+import fs from 'node:fs';
+
+import { joinPath } from '@/cli/lib/path-utils.js';
+import { resolveBunBin } from '@/cli/lib/runtime.js';
+
+/**
+ * Build the production bundle when it is missing.
+ *
+ * The script runs as a child rather than being imported so it uses the
+ * package's own bundler options (`bunfig.toml` plugins, the `dist/client`
+ * outdir) and prints its own progress, exactly as a manual `bun run build`.
+ */
+export function buildProductionBundle(pkgRoot, { onLine } = {}) {
+  const script = joinPath(pkgRoot, 'scripts', 'build-client.ts');
+  if (!fs.existsSync(script)) {
+    throw new Error(
+      `No production build and no build script at ${script}.\n`
+      + 'This install is incomplete — reinstall Kabmo, or run `kabmo serve --dev`.',
+    );
+  }
+
+  const result = Bun.spawnSync({
+    cmd: [resolveBunBin(), script],
+    cwd: pkgRoot,
+    env: { ...Bun.env },
+    stdin: 'ignore',
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+
+  const output = `${result.stdout?.toString() ?? ''}${result.stderr?.toString() ?? ''}`;
+  if (typeof onLine === 'function' && output.length > 0) onLine(output);
+
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Production build failed (exit ${result.exitCode}).\n${output.trim() || 'No output from the build.'}`,
+    );
+  }
+
+  return { file: joinPath(pkgRoot, 'dist', 'client', 'index.js'), output };
+}

package/src/cli/lib/commands/logs.js

@@ -0,0 +1,150 @@
+// `kabmo logs` — print or follow the server logs.
+//
+// Scoping matches `status`/`stop`/`restart`: without `--port` the logs of every
+// live instance are shown, each behind a `==> path <==` header, and `--port
+// <port>` restricts the output to that instance. With nothing running, the log
+// of the requested (or default) port is shown so a stopped server's output is
+// still readable.
+
+import { findLiveInstance, listLiveInstances } from '@/cli/lib/runtime.js';
+import { getLogFilePath } from '@/cli/lib/paths.js';
+import { log, warn, printJson, fail, isJson, isQuiet } from '@/cli/lib/output.js';
+const DEFAULT_LINES = 50;
+const FOLLOW_INTERVAL_MS = 300;
+
+function resolvePort(options) {
+  const raw = options?.port;
+  if (raw !== null && raw !== undefined) {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  const env = Bun.env.KABMO_PORT;
+  if (typeof env === 'string' && env.trim().length > 0) {
+    const parsed = Number(env.trim());
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 3000;
+}
+
+function explicitPort(options) {
+  const raw = options?.port;
+  if (raw === null || raw === undefined) return null;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function splitLines(content) {
+  const lines = content.split('\n');
+  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+function writeLines(lines) {
+  for (const line of lines) {
+    process.stdout.write(`${line}\n`);
+  }
+}
+
+async function readTail(target, lineCount) {
+  const content = await Bun.file(target.logFile).text();
+  return { port: target.port, logFile: target.logFile, lines: splitLines(content).slice(-lineCount) };
+}
+
+/** Per-file read position, so following several logs keeps them independent. */
+async function followFiles(targets, multiple) {
+  const state = [];
+  for (const target of targets) {
+    let position = 0;
+    try {
+      position = (await Bun.file(target.logFile).stat()).size;
+    } catch {
+      position = 0;
+    }
+    state.push({ target, position });
+  }
+
+  let running = true;
+  const stop = () => { running = false; };
+  process.once('SIGINT', stop);
+  process.once('SIGTERM', stop);
+
+  try {
+    while (running) {
+      await Bun.sleep(FOLLOW_INTERVAL_MS);
+      for (const entry of state) {
+        let size;
+        try {
+          size = (await Bun.file(entry.target.logFile).stat()).size;
+        } catch {
+          continue;
+        }
+        if (size < entry.position) entry.position = 0;
+        if (size === entry.position) continue;
+
+        if (multiple) process.stdout.write(`==> ${entry.target.logFile} <==\n`);
+        const chunk = await Bun.file(entry.target.logFile).slice(entry.position, size).text();
+        entry.position = size;
+        process.stdout.write(chunk);
+      }
+    }
+  } finally {
+    process.removeListener('SIGINT', stop);
+    process.removeListener('SIGTERM', stop);
+  }
+}
+
+export async function run(options) {
+  const json = isJson();
+  const quiet = isQuiet();
+  const requested = explicitPort(options);
+  const fallbackPort = requested ?? resolvePort(options);
+
+  const instances = requested !== null
+    ? [await findLiveInstance(requested)].filter(Boolean)
+    : await listLiveInstances();
+
+  const candidates = instances.length > 0
+    ? instances.map((entry) => ({ port: entry.port, logFile: entry.logFile ?? getLogFilePath(entry.port) }))
+    : [{ port: fallbackPort, logFile: getLogFilePath(fallbackPort) }];
+
+  const targets = [];
+  const skipped = [];
+  for (const candidate of candidates) {
+    if (await Bun.file(candidate.logFile).exists()) targets.push(candidate);
+    else skipped.push(candidate);
+  }
+  if (targets.length === 0) {
+    // A server started outside the CLI (`bun run dev`) logs to its own terminal,
+    // so its recorded port has no file here even though it is very much alive.
+    fail(skipped.length > 0 && instances.length > 0
+      ? `No log file at ${skipped[0].logFile}.\nPort ${skipped[0].port} was not started by the CLI — its output goes to the terminal that started it.`
+      : `No log file found at ${candidates[0].logFile}.\nStart the server first with \`kabmo serve\`.`);
+  }
+
+  const requestedLines = Number(options?.lines);
+  const lineCount = Number.isFinite(requestedLines) && requestedLines > 0
+    ? Math.trunc(requestedLines)
+    : DEFAULT_LINES;
+
+  if (json) {
+    const tails = [];
+    for (const target of targets) tails.push(await readTail(target, lineCount));
+    printJson({ instances: tails, skipped: skipped.map((entry) => ({ port: entry.port, logFile: entry.logFile })) });
+    return;
+  }
+
+  const multiple = targets.length > 1;
+  if (!quiet) {
+    log(multiple ? `Log files: ${targets.length} instances` : `Log file: ${targets[0].logFile}`);
+    if (skipped.length > 0) {
+      warn(`Skipped ${skipped.length} instance(s) without a CLI log file: port ${skipped.map((entry) => entry.port).join(', ')}`);
+    }
+  }
+
+  for (const target of targets) {
+    if (multiple) process.stdout.write(`==> ${target.logFile} <==\n`);
+    writeLines(splitLines(await Bun.file(target.logFile).text()).slice(-lineCount));
+  }
+
+  if (options?.follow) await followFiles(targets, multiple);
+}

package/src/cli/lib/commands/plugin.js

@@ -0,0 +1,285 @@
+// `kabmo plugin <subcommand>` — build, type and scaffold panel plugins.
+//
+// The CLI's own entry to the SAME build the server runs, and that is the point:
+// a plugin author must be able to run locally exactly what Kabmo will run
+// on install, or they are debugging a build they cannot see. `buildPanelPlugin`
+// is imported from the server's own module rather than reimplemented here.
+//
+// `types` emits the SDK's declarations so a plugin outside this repository can
+// typecheck without Kabmo's source on disk — a fork has no `@/` alias and
+// no `packages/`, and resolving the SDK's `.ts` directly is what a published
+// package must never require.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { error, fail, log, ok, printJson, isJson } from '@/cli/lib/output.js';
+import { joinPath, resolvePath } from '@/cli/lib/path-utils.js';
+import { buildPanelPlugin } from '@/server/lib/panels/build.server';
+import { discoverPanelPlugins } from '@/server/lib/panels/registry.server';
+
+const SUBCOMMANDS = ['build', 'types', 'new', 'list'];
+
+function usage() {
+  return `Usage: kabmo plugin <command> [options]
+
+COMMANDS:
+  build <dir>       Build a plugin's app and/or server bundle
+  types <dir>       Write bundled SDK declarations into <dir>/bundled-types
+  new <dir>         Scaffold a new plugin
+  list              List installed plugins and their build state
+
+OPTIONS:
+  --json            Machine-readable output
+`;
+}
+
+/**
+ * Read a plugin's manifest, or fail with the reason it could not be read.
+ */
+function readManifest(dir) {
+  const pkgPath = joinPath(dir, 'package.json');
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg && typeof pkg === 'object' ? pkg.kabmo ?? null : null;
+  } catch (cause) {
+    fail(`Could not parse ${pkgPath}: ${cause.message}`);
+  }
+}
+
+async function build(dir, ctx) {
+  const target = resolvePath(ctx.cwd, dir ?? '.');
+  if (!fs.existsSync(target)) fail(`No such directory: ${target}`);
+
+  const manifest = readManifest(target);
+  if (!manifest) fail(`${joinPath(target, 'package.json')} has no "kabmo" manifest block`);
+
+  const result = await buildPanelPlugin(target, manifest);
+
+  if (isJson()) {
+    printJson({ dir: target, ...result });
+  } else if (result.status === 'built') {
+    ok(`Built ${manifest.id} (${manifest.app ?? ''}${manifest.server ? `, ${manifest.server}` : ''})`);
+  } else {
+    error(`${result.status}: ${result.reason}`);
+  }
+  if (result.status === 'failed') process.exit(1);
+}
+
+/**
+ * Write the SDK's own sources as declarations.
+ *
+ * The SDK ships TypeScript SOURCE (the `source` export condition), which is
+ * what lets Kabmo bundle it. A plugin outside this repo cannot consume
+ * that — it has no `@/` alias and no workspace — so the types are emitted here
+ * from the same files, into a directory the plugin's tsconfig can point at.
+ */
+async function types(dir, ctx) {
+  const target = resolvePath(ctx.cwd, dir ?? '.');
+  if (!fs.existsSync(target)) fail(`No such directory: ${target}`);
+  const copied = writeBundledTypes(target, ctx.pkgRoot);
+  if (copied === 0) fail('This install has no SDK sources (packages/ is not shipped in a production tarball).');
+
+  if (isJson()) printJson({ dir: target, wrote: copied, out: joinPath(target, 'bundled-types') });
+  else ok(`Wrote ${copied} declaration set(s) to ${joinPath(target, 'bundled-types')}`);
+}
+
+/**
+ * Copy the SDK and kit sources into a plugin's own `bundled-types/`.
+ *
+ * Copied, not compiled: the sources ARE the declarations for a consumer that
+ * only imports types, and the plugin's own `tsc` reads them directly. Emitting
+ * `.d.ts` would mean running the compiler per plugin for a file the plugin's
+ * tsc reads either way.
+ *
+ * The packages' OWN tests are excluded — they import `bun:test`, which a
+ * plugin's tsconfig does not resolve, so copying them would fail every
+ * plugin's typecheck on a file it never asked for.
+ *
+ * Returns how many sets were written; 0 means this install has no sources.
+ */
+function writeBundledTypes(target, pkgRoot) {
+  const sources = [
+    [joinPath(pkgRoot, 'packages', 'kabmo-sdk', 'src'), 'kabmo-sdk'],
+    [joinPath(pkgRoot, 'packages', 'kabmo-ui', 'src'), 'kabmo-ui'],
+  ];
+  const out = joinPath(target, 'bundled-types');
+  const SKIP = /\.test\.tsx?$/;
+  let copied = 0;
+  for (const [from, name] of sources) {
+    if (!fs.existsSync(from)) continue;
+    fs.mkdirSync(out, { recursive: true });
+    const destination = joinPath(out, name);
+    fs.rmSync(destination, { recursive: true, force: true });
+    fs.cpSync(from, destination, { recursive: true, filter: (source) => !SKIP.test(source) });
+    copied += 1;
+  }
+  return copied;
+}
+
+/** Scaffold a plugin directory: manifest, app entry, tsconfig, a test. */
+async function scaffold(dir, ctx) {
+  const target = resolvePath(ctx.cwd, dir ?? '.');
+  if (fs.existsSync(target) && fs.readdirSync(target).length > 0) {
+    fail(`Refusing to scaffold into a non-empty directory: ${target}`);
+  }
+
+  const id = path.basename(target).replace(/[^a-z0-9._-]/gi, '-').toLowerCase();
+  const name = id.replace(/[-_]+/g, ' ').replace(/\b\w/g, (char) => char.toUpperCase());
+
+  fs.mkdirSync(joinPath(target, 'src'), { recursive: true });
+  fs.writeFileSync(
+    joinPath(target, 'package.json'),
+    `${JSON.stringify(
+      {
+        name: id,
+        version: '1.0.0',
+        private: true,
+        type: 'module',
+        kabmo: {
+          id,
+          name,
+          version: '1.0.0',
+          app: 'dist/app.js',
+          server: 'dist/server.js',
+        },
+        peerDependencies: {
+          '@kabmo-labs/kabmo-sdk': '*',
+          '@kabmo-labs/kabmo-ui': '*',
+          preact: '^10.29.8',
+        },
+        peerDependenciesMeta: {
+          '@kabmo-labs/kabmo-sdk': { optional: true },
+          '@kabmo-labs/kabmo-ui': { optional: true },
+          preact: { optional: true },
+        },
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  fs.writeFileSync(
+    joinPath(target, 'tsconfig.json'),
+    `${JSON.stringify(
+      {
+        compilerOptions: {
+          target: 'ESNext',
+          module: 'ESNext',
+          moduleResolution: 'bundler',
+          lib: ['ESNext', 'DOM', 'DOM.Iterable'],
+          jsx: 'react-jsx',
+          jsxImportSource: 'preact',
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true,
+          types: [],
+          // Pointed at the emitted declarations, so `tsc` works in this
+          // directory with no Kabmo source on disk. `baseUrl` is NOT set:
+          // TypeScript 7 deprecates it, and `paths` resolves relative to the
+          // tsconfig without it.
+          paths: {
+            '@kabmo-labs/kabmo-sdk': ['./bundled-types/kabmo-sdk/index.ts'],
+            '@kabmo-labs/kabmo-sdk/app': ['./bundled-types/kabmo-sdk/app.ts'],
+            '@kabmo-labs/kabmo-sdk/testing': ['./bundled-types/kabmo-sdk/testing/index.ts'],
+            '@kabmo-labs/kabmo-sdk/testing/app': ['./bundled-types/kabmo-sdk/testing/app.tsx'],
+            '@kabmo-labs/kabmo-ui': ['./bundled-types/kabmo-ui/index.tsx'],
+            '@kabmo-labs/kabmo-ui/components': ['./bundled-types/kabmo-ui/components.tsx'],
+          },
+        },
+        include: ['src'],
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  fs.writeFileSync(joinPath(target, 'src', 'app.tsx'), APP_TEMPLATE);
+  fs.writeFileSync(joinPath(target, 'src', 'server.ts'), SERVER_TEMPLATE);
+
+  // The declarations go in immediately: a scaffold whose `tsc` fails on the
+  // FIRST run is a scaffold that taught the author the tooling is broken.
+  // The SDK's packages ship source, so this is a copy rather than a build.
+  const copied = writeBundledTypes(target, ctx.pkgRoot);
+
+  if (isJson()) printJson({ dir: target, id, name, types: copied });
+  else ok(`Scaffolded ${name} in ${target}`);
+  if (copied === 0) {
+    log('No SDK sources in this install — run "kabmo plugin types ." from a checkout before typechecking.');
+  }
+  log('Typecheck with: bunx tsc --noEmit -p .');
+  log('Build with:     kabmo plugin build .');
+}
+
+const APP_TEMPLATE = `import { definePluginApp } from '@kabmo-labs/kabmo-sdk/app';
+import { usePanelInfo } from '@kabmo-labs/kabmo-ui';
+import { Panel, Field, FieldList } from '@kabmo-labs/kabmo-ui/components';
+
+function MyPanel() {
+  const info = usePanelInfo();
+  return (
+    <Panel title="My Panel">
+      <FieldList>
+        <Field label="session" value={info.sessionId ?? 'none'} />
+        <Field label="workspace" value={info.workspacePath ?? 'none'} />
+      </FieldList>
+    </Panel>
+  );
+}
+
+export default definePluginApp((app) => {
+  app.rightPanel({ id: 'main', title: 'My Panel', component: MyPanel });
+});
+`;
+
+const SERVER_TEMPLATE = `import type { KabmoPluginApi } from '@kabmo-labs/kabmo-sdk';
+
+export default function plugin(api: KabmoPluginApi) {
+  api.log.info('loaded');
+
+  api.rpc.register('ping', { handler: () => ({ pong: true }) });
+
+  api.onDispose(() => {
+    api.log.info('disposed');
+  });
+}
+`;
+
+/** List the plugins Kabmo has installed, with their build state. */
+async function list() {
+  const payload = await discoverPanelPlugins();
+  if (isJson()) {
+    printJson(payload.plugins);
+    return;
+  }
+  if (payload.plugins.length === 0) {
+    log('No panel plugins installed.');
+    return;
+  }
+  for (const plugin of payload.plugins) {
+    const flags = [plugin.enabled ? 'enabled' : 'disabled', plugin.built ? 'built' : 'not built'].join(', ');
+    log(`${plugin.pluginId}  ${plugin.name}  (${flags})${plugin.reason ? ` — ${plugin.reason}` : ''}`);
+  }
+}
+
+export async function run(options, ctx) {
+  const argv = Array.isArray(options.args) ? options.args : [];
+  const sub = argv[0] ?? null;
+  const rest = argv.slice(1);
+
+  if (options.help || !sub) {
+    process.stdout.write(usage());
+    if (!sub) process.exit(1);
+    return;
+  }
+  if (!SUBCOMMANDS.includes(sub)) {
+    error(`Unknown plugin subcommand: ${sub}`);
+    process.stdout.write(usage());
+    process.exit(1);
+  }
+
+  const dir = rest[0] ?? '.';
+  if (sub === 'build') await build(dir, ctx);
+  else if (sub === 'types') await types(dir, ctx);
+  else if (sub === 'new') await scaffold(dir, ctx);
+  else await list();
+}

package/src/cli/lib/commands/plugin.test.js

@@ -0,0 +1,125 @@
+// `kabmo plugin` — the subcommand surface and its path handling.
+//
+// Two things are pinned here, and both were real bugs before they were:
+//
+// 1. `resolvePath` with an ABSOLUTE segment. `joinPath` strips a leading slash
+//    (it is used to build a path FROM a root), so `joinPath(cwd, '/tmp/x')` is
+//    `<cwd>/tmp/x`. Measured: `kabmo plugin new /tmp/x` scaffolded into the
+//    repo. The suite is a CLI-level case because the bug was only reachable
+//    through an absolute argument.
+// 2. `new` produces a project that typechecks. The scaffold writes its own
+//    `bundled-types/` and the `paths` that map onto them, so a fresh directory
+//    is a working project rather than one that teaches the author the tooling
+//    is broken.
+//
+// Runs the CLI as a subprocess rather than importing `run`: the command writes
+// to stdout, shells out to the bundler and terminates on failure, none of which
+// is safe in-process.
+
+import { describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { resolvePath } from '@/cli/lib/path-utils.js';
+
+// `import.meta.dir` is `src/cli/lib/commands`, so the package root is four up.
+const PKG_ROOT = resolvePath(import.meta.dir, '..', '..', '..', '..');
+const CLI = join(PKG_ROOT, 'src', 'cli', 'kabmo.js');
+
+/** Run the CLI from the package root, so its own `pkgRoot` resolution is exercised. */
+function cli(args, cwd = PKG_ROOT) {
+  const result = Bun.spawnSync({
+    cmd: [process.execPath, CLI, ...args],
+    cwd,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+  return {
+    code: result.exitCode,
+    stdout: result.stdout.toString(),
+    stderr: result.stderr.toString(),
+  };
+}
+
+describe('resolvePath', () => {
+  test('an absolute segment discards everything before it', () => {
+    expect(resolvePath('/cwd/here', '/tmp/x')).toBe('/tmp/x');
+    expect(resolvePath('/cwd/here', '.')).toBe('/cwd/here');
+    expect(resolvePath('/cwd/here', 'rel')).toBe('/cwd/here/rel');
+  });
+});
+
+describe('kabmo plugin', () => {
+  test('bare `plugin` prints its own usage and exits non-zero', () => {
+    const result = cli(['plugin']);
+    expect(result.stdout).toContain('kabmo plugin <command>');
+    expect(result.code).not.toBe(0);
+  });
+
+  test('an unknown subcommand is refused by name', () => {
+    const result = cli(['plugin', 'bogus']);
+    expect(result.stderr).toContain('Unknown plugin subcommand: bogus');
+    expect(result.code).not.toBe(0);
+  });
+
+  test('build refuses a directory with no plugin manifest', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'omp-cli-plugin-'));
+    try {
+      const result = cli(['plugin', 'build', dir]);
+      expect(result.stderr).toContain('no "kabmo" manifest block');
+      expect(result.code).not.toBe(0);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('new scaffolds a project that carries its own declarations and paths', async () => {
+    const parent = await mkdtemp(join(tmpdir(), 'omp-cli-scaffold-'));
+    const target = join(parent, 'my-plugin');
+    try {
+      const result = cli(['plugin', 'new', target]);
+      expect(result.code).toBe(0);
+
+      // The manifest declares both halves, so the build has two targets.
+      const manifest = JSON.parse(await readFile(join(target, 'package.json'), 'utf8'));
+      expect(manifest.kabmo.id).toBe('my-plugin');
+      expect(manifest.kabmo.app).toBe('dist/app.js');
+      expect(manifest.kabmo.server).toBe('dist/server.js');
+
+      // The declarations and the mapping onto them are what make `tsc` work in
+      // a directory with no Kabmo source on disk.
+      expect(existsSync(join(target, 'bundled-types/kabmo-sdk/index.ts'))).toBe(true);
+      expect(existsSync(join(target, 'bundled-types/kabmo-ui/index.tsx'))).toBe(true);
+      // The SDK's own suites are NOT copied: they import `bun:test`, which the
+      // plugin's tsconfig does not resolve.
+      expect(existsSync(join(target, 'bundled-types/kabmo-sdk/app.test.ts'))).toBe(false);
+
+      const tsconfig = JSON.parse(await readFile(join(target, 'tsconfig.json'), 'utf8'));
+      expect(tsconfig.compilerOptions.paths['@kabmo-labs/kabmo-sdk/app']).toEqual([
+        './bundled-types/kabmo-sdk/app.ts',
+      ]);
+      // `baseUrl` is deliberately absent: TypeScript 7 deprecates it, and
+      // `paths` resolves relative to the tsconfig without it.
+      expect(tsconfig.compilerOptions.baseUrl).toBeUndefined();
+    } finally {
+      await rm(parent, { recursive: true, force: true });
+    }
+  }, 60_000);
+
+  test('new refuses a non-empty directory rather than mixing into it', async () => {
+    const parent = await mkdtemp(join(tmpdir(), 'omp-cli-scaffold-'));
+    try {
+      const existing = join(parent, 'occupied');
+      await Bun.write(join(existing, 'keep.txt'), 'something the user owns');
+      const result = cli(['plugin', 'new', existing]);
+      expect(result.stderr).toContain('Refusing to scaffold into a non-empty directory');
+      expect(result.code).not.toBe(0);
+      // And it did not touch what was there.
+      expect(await readFile(join(existing, 'keep.txt'), 'utf8')).toBe('something the user owns');
+    } finally {
+      await rm(parent, { recursive: true, force: true });
+    }
+  });
+});