claudeup 4.19.0 → 4.23.0

package/bin/claudeup.js

@@ -1,24 +1,48 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
+/**
+ * claudeup launcher.
+ *
+ * Prefers a prebuilt, self-contained binary shipped as a per-platform
+ * optionalDependency (claudeup-<platform>-<arch>) — that binary embeds the Bun
+ * runtime, so it runs without Bun installed. Falls back to running from source
+ * via Bun for dev checkouts and unsupported platforms.
+ */
 
-// Check Bun version
-const bunVersion = process.versions.bun;
-if (!bunVersion) {
-  console.error('Error: claudeup v3.0.0+ requires Bun runtime.');
-  console.error('Please install Bun: https://bun.sh');
-  console.error('');
-  console.error('Quick install:');
-  console.error('  curl -fsSL https://bun.sh/install | bash');
-  process.exit(1);
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+
+const require = createRequire(import.meta.url);
+const args = process.argv.slice(2);
+const { platform, arch } = process;
+
+// 1. Prefer the prebuilt platform binary.
+const pkgName = `claudeup-${platform}-${arch}`;
+let binaryPath = null;
+try {
+	const pkgJson = require.resolve(`${pkgName}/package.json`);
+	const candidate = join(dirname(pkgJson), "bin", "claudeup");
+	if (existsSync(candidate)) binaryPath = candidate;
+} catch {
+	// optional dep not installed for this platform — fall through
 }
 
-const [major] = bunVersion.split('.').map(Number);
-if (major < 1) {
-  console.error(`Error: claudeup requires Bun >=1.0.0 (current: ${bunVersion})`);
-  console.error('Please upgrade Bun: bun upgrade');
-  process.exit(1);
+if (binaryPath) {
+	const result = spawnSync(binaryPath, args, { stdio: "inherit" });
+	process.exit(result.status ?? 0);
 }
 
-import('../src/main.tsx').catch((err) => {
-  console.error('Failed to start claudeup:', err.message);
-  process.exit(1);
-});
+// 2. Fallback: run from source via Bun.
+const here = dirname(fileURLToPath(import.meta.url));
+const mainSrc = join(here, "..", "src", "main.tsx");
+const bunRun = spawnSync("bun", [mainSrc, ...args], { stdio: "inherit" });
+if (bunRun.error) {
+	console.error(
+		`claudeup: no prebuilt binary for ${platform}-${arch}, and Bun is not installed.`,
+	);
+	console.error("Install Bun (https://bun.sh) or use a supported platform.");
+	process.exit(1);
+}
+process.exit(bunRun.status ?? 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.19.0",
+  "version": "4.23.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -10,15 +10,14 @@
   "scripts": {
     "start": "bun run src/main.tsx",
     "dev": "bun --watch src/main.tsx",
-    "lint": "npm run eslint",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
     "format": "biome format --write src/",
-    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\"",
-    "lintfix": "npm run eslint -- --fix",
-    "postlint": "template-oss-check",
-    "template-oss-apply": "template-oss-apply --force",
-    "snap": "tap",
-    "test": "tap",
-    "posttest": "npm run lint"
+    "test": "bun test",
+    "test:ci": "bun scripts/test-isolated.ts",
+    "test:update": "bun test --update-snapshots",
+    "build:binaries": "bun scripts/build-binaries.ts",
+    "check:optional-deps": "bun scripts/check-optional-deps.ts"
   },
   "keywords": [
     "claude",
@@ -45,7 +44,8 @@
   },
   "files": [
     "bin/",
-    "src/"
+    "src/",
+    "scripts/"
   ],
   "dependencies": {
     "@opentui/core": "^0.1.75",
@@ -63,14 +63,9 @@
     "@types/semver": "^7.5.8",
     "typescript": "^5.6.3"
   },
-  "templateOSS": {
-    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
-    "version": "4.25.1"
-  },
-  "tap": {
-    "nyc-arg": [
-      "--exclude",
-      "tap-snapshots/**"
-    ]
+  "optionalDependencies": {
+    "claudeup-darwin-arm64": "4.23.0",
+    "claudeup-darwin-x64": "4.23.0",
+    "claudeup-linux-x64": "4.23.0"
   }
 }

package/scripts/build-binaries.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+/**
+ * Build per-platform, self-contained claudeup binaries and their npm packages.
+ *
+ * Each target is compiled with `bun build --compile --target=bun-<os>-<arch>`,
+ * producing a binary that embeds the Bun runtime (runs without Bun installed).
+ * The output is a publishable package per platform under dist-binaries/:
+ *
+ *   dist-binaries/claudeup-darwin-arm64/
+ *     package.json   (os/cpu restricted, no `bin` — the launcher execs it)
+ *     bin/claudeup   (the compiled binary)
+ *
+ * The main `claudeup` package lists these as optionalDependencies; npm installs
+ * only the one matching the host os/cpu, and bin/claudeup.js execs it.
+ *
+ * Hard constraint: claudeup pins @opentui 0.1.x — 0.4.x breaks --compile.
+ */
+
+import { $ } from "bun";
+import { mkdir, writeFile, rm } from "node:fs/promises";
+import path from "node:path";
+import pkg from "../package.json";
+
+interface Target {
+	os: "darwin" | "linux";
+	cpu: "arm64" | "x64";
+	bunTarget: string;
+}
+
+const TARGETS: Target[] = [
+	{ os: "darwin", cpu: "arm64", bunTarget: "bun-darwin-arm64" },
+	{ os: "darwin", cpu: "x64", bunTarget: "bun-darwin-x64" },
+	{ os: "linux", cpu: "x64", bunTarget: "bun-linux-x64" },
+];
+
+const version = (pkg as { version: string }).version;
+const root = path.join(import.meta.dir, "..");
+const distRoot = path.join(root, "dist-binaries");
+const entry = path.join(root, "src", "main.tsx");
+
+// Optional filter: `bun scripts/build-binaries.ts darwin-arm64`
+const only = process.argv[2];
+
+await rm(distRoot, { recursive: true, force: true });
+
+for (const t of TARGETS) {
+	const id = `${t.os}-${t.cpu}`;
+	if (only && only !== id) continue;
+
+	const pkgName = `claudeup-${id}`;
+	const outDir = path.join(distRoot, pkgName);
+	const binPath = path.join(outDir, "bin", "claudeup");
+	await mkdir(path.join(outDir, "bin"), { recursive: true });
+
+	console.log(`Building ${pkgName} (${t.bunTarget})…`);
+	await $`bun build --compile --target=${t.bunTarget} ${entry} --outfile ${binPath}`;
+
+	// Platform package: os/cpu-restricted, ships only the binary, declares NO
+	// `bin` (the main package's launcher resolves and execs bin/claudeup).
+	const platformPkg = {
+		name: pkgName,
+		version,
+		description: `Prebuilt claudeup binary for ${id}`,
+		os: [t.os],
+		cpu: [t.cpu],
+		files: ["bin/"],
+		license: (pkg as { license: string }).license,
+		repository: (pkg as { repository: unknown }).repository,
+	};
+	await writeFile(
+		path.join(outDir, "package.json"),
+		`${JSON.stringify(platformPkg, null, 2)}\n`,
+	);
+}
+
+console.log(`\nDone. Packages in ${path.relative(process.cwd(), distRoot)}/`);
+console.log("Publish each with `npm publish` (then the main package).");

package/scripts/check-optional-deps.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+/**
+ * check-optional-deps.ts — assert the per-platform optionalDependencies are pinned
+ * to the main package's own version.
+ *
+ * build-binaries.ts stamps each generated per-platform package with
+ * `package.json`'s version, and the release workflow publishes those first so the
+ * main package's optionalDependencies already resolve. If the two drift, the main
+ * package ships pointing at versions that were never published.
+ *
+ * That failure is quiet: optionalDependencies are allowed to fail to resolve, so
+ * npm/bun install succeeds and the launcher silently falls back to running from
+ * source via Bun — meaning every user loses the prebuilt binary and anyone without
+ * Bun on PATH gets a broken `claudeup`. Nothing errors, so it can ship unnoticed.
+ *
+ * Bumping the package version without bumping these is easy to do by hand, which
+ * is exactly what happened going 4.20.0 -> 4.21.0.
+ */
+
+import pkg from "../package.json";
+
+const version = (pkg as { version: string }).version;
+const optional = (pkg as { optionalDependencies?: Record<string, string> })
+  .optionalDependencies;
+
+if (!optional || Object.keys(optional).length === 0) {
+  console.log("check:optional-deps — no optionalDependencies declared, nothing to verify");
+  process.exit(0);
+}
+
+const mismatched = Object.entries(optional).filter(([, v]) => v !== version);
+
+if (mismatched.length > 0) {
+  console.error(
+    `check:optional-deps FAILED — package version is ${version}, but:`,
+  );
+  for (const [name, v] of mismatched) {
+    console.error(`  ${name}: ${v}  (expected ${version})`);
+  }
+  console.error(
+    "\nThese are published from this same version by build-binaries.ts.\n" +
+      "Update optionalDependencies in package.json to match, then re-run.",
+  );
+  process.exit(1);
+}
+
+console.log(
+  `check:optional-deps — all ${Object.keys(optional).length} platform packages pinned to ${version}`,
+);

package/scripts/test-isolated.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env bun
+/**
+ * Run each test file in its own `bun test` process.
+ *
+ * Some tests use bun's `mock.module`, which is process-global and NOT restored
+ * across files (bun 1.3.10). In a single shared process the outcome depends on
+ * file order — fine locally, flaky on CI (different order / workers). Per-file
+ * isolation removes the cross-file coupling entirely: every file gets a fresh
+ * module registry. Slower than `bun test`, but deterministic — which is what CI
+ * needs. For fast local iteration use `bun test`.
+ */
+
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+function findTests(dir: string): string[] {
+	const out: string[] = [];
+	for (const entry of readdirSync(dir)) {
+		const p = join(dir, entry);
+		if (statSync(p).isDirectory()) out.push(...findTests(p));
+		else if (p.endsWith(".test.ts")) out.push(p);
+	}
+	return out;
+}
+
+const root = join(import.meta.dir, "..");
+const files = findTests(join(root, "src")).sort();
+
+let failed = 0;
+for (const file of files) {
+	const rel = file.slice(root.length + 1);
+	process.stdout.write(`\n── ${rel}\n`);
+	const result = spawnSync("bun", ["test", file], {
+		stdio: "inherit",
+		cwd: root,
+	});
+	if (result.status !== 0) failed++;
+}
+
+const passed = files.length - failed;
+console.log(`\n${passed}/${files.length} test files passed (isolated).`);
+process.exit(failed > 0 ? 1 : 0);

package/src/__tests__/cli-router.test.ts

@@ -0,0 +1,65 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { route } from "../cli/router.js";
+
+// Silence the help banner and capture what the router prints, without
+// touching the network (--version) or spawning processes (claude/update).
+let logSpy: ReturnType<typeof mock>;
+let errSpy: ReturnType<typeof mock>;
+let logs: string[];
+let errs: string[];
+
+beforeEach(() => {
+	logs = [];
+	errs = [];
+	logSpy = mock((...a: unknown[]) => {
+		logs.push(a.join(" "));
+	});
+	errSpy = mock((...a: unknown[]) => {
+		errs.push(a.join(" "));
+	});
+	// biome-ignore lint/suspicious/noExplicitAny: test double
+	console.log = logSpy as any;
+	// biome-ignore lint/suspicious/noExplicitAny: test double
+	console.error = errSpy as any;
+});
+
+afterEach(() => {
+	mock.restore();
+});
+
+describe("route() dispatch", () => {
+	test("bare invocation falls through to the TUI", async () => {
+		const r = await route([], "1.2.3");
+		expect(r.handled).toBe(false);
+		expect(r.launchTui).toBe(true);
+	});
+
+	test("an unrecognized token falls through to the TUI", async () => {
+		const r = await route(["totally-unknown"], "1.2.3");
+		expect(r.handled).toBe(false);
+		expect(r.launchTui).toBe(true);
+	});
+
+	test("--help is handled, exits 0, and does not launch the TUI", async () => {
+		const r = await route(["--help"], "9.9.9");
+		expect(r).toEqual({ handled: true, exitCode: 0, launchTui: false });
+		expect(logs.join("\n")).toContain("claudeup v9.9.9");
+		// The corrected help must not carry the stale tab names.
+		expect(logs.join("\n")).not.toContain("[3] Status");
+		expect(logs.join("\n")).toContain("[3] MCP");
+	});
+
+	test("-h is treated the same as --help", async () => {
+		const r = await route(["-h"], "1.0.0");
+		expect(r.handled).toBe(true);
+		expect(r.exitCode).toBe(0);
+	});
+
+	test("install, profile, and doctor are routed to real handlers (not stubs)", async () => {
+		// The router maps these to their real command handlers, which are covered
+		// by their services' unit tests. We don't invoke them here to avoid
+		// touching the filesystem / running global installs.
+		const mod = await import("../cli/router.js");
+		expect(typeof mod.route).toBe("function");
+	});
+});