claudeup 4.42.0 → 4.42.1

package/bin/claudeup.js

@@ -6,6 +6,11 @@
  * 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.
+ *
+ * Set CLAUDEUP_NO_BINARY=1 to skip the prebuilt binary and force the source
+ * path. That escape hatch exists because the launcher PREFERS the binary: when
+ * a shipped binary cannot start on a given machine, without it claudeup is a
+ * hard block rather than a slow start.
  */
 
 import { spawnSync } from "node:child_process";
@@ -18,7 +23,8 @@ const require = createRequire(import.meta.url);
 const args = process.argv.slice(2);
 const { platform, arch } = process;
 
-// 1. Prefer the prebuilt platform binary.
+// 1. Prefer the prebuilt platform binary, unless the source path is forced.
+const forceSource = process.env.CLAUDEUP_NO_BINARY === "1";
 const pkgName = `claudeup-${platform}-${arch}`;
 let binaryPath = null;
 try {
@@ -29,9 +35,16 @@ try {
 	// optional dep not installed for this platform — fall through
 }
 
-if (binaryPath) {
+if (binaryPath && !forceSource) {
 	const result = spawnSync(binaryPath, args, { stdio: "inherit" });
-	process.exit(result.status ?? 0);
+	// A binary that could not be executed AT ALL (ENOENT, EACCES, bad arch)
+	// leaves status null, and `status ?? 0` then reported SUCCESS for a run that
+	// never happened — the worst answer available. Only trust the status when the
+	// process actually ran; otherwise say so and fall through to the source path.
+	if (!result.error) process.exit(result.status ?? 0);
+	console.error(
+		`claudeup: prebuilt binary could not start (${result.error.message}); falling back to source.`,
+	);
 }
 
 // 2. Fallback: run from source via Bun.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.42.0",
+  "version": "4.42.1",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "4.42.0",
-    "claudeup-darwin-x64": "4.42.0",
-    "claudeup-linux-x64": "4.42.0"
+    "claudeup-darwin-arm64": "4.42.1",
+    "claudeup-darwin-x64": "4.42.1",
+    "claudeup-linux-x64": "4.42.1"
   }
 }

package/scripts/build-binaries.ts

@@ -14,6 +14,16 @@
  * 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.
+ *
+ * Hard constraint: the two --no-compile-autoload flags below must stay. A Bun
+ * standalone executable autoloads .env and bunfig.toml from its CURRENT
+ * DIRECTORY by default, and claudeup reads neither on purpose. Bun 1.4.0 dies
+ * in the .env path when that file is a symlink pointing at a FIFO — exactly how
+ * 1Password serves secrets into a git worktree — exiting 1 with nothing on
+ * stdout or stderr, because the crash lands before any JS runs and therefore
+ * before any error handler exists. A FIFO also hands its bytes to whoever opens
+ * it first, so an autoloading claudeup can swallow the secrets a dev server was
+ * waiting for. Dropping the flags re-arms both failures.
  */
 
 import { $ } from "bun";
@@ -53,7 +63,8 @@ for (const t of TARGETS) {
 	await mkdir(path.join(outDir, "bin"), { recursive: true });
 
 	console.log(`Building ${pkgName} (${t.bunTarget})…`);
-	await $`bun build --compile --target=${t.bunTarget} ${entry} --outfile ${binPath}`;
+	// The --no-compile-autoload flags are load-bearing; see the header.
+	await $`bun build --compile --no-compile-autoload-dotenv --no-compile-autoload-bunfig --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).

package/src/__tests__/dotenv.test.ts

@@ -0,0 +1,190 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadProjectDotenv, parseDotenv } from "../services/dotenv";
+
+function mkfifo(path: string): void {
+	const r = spawnSync("mkfifo", [path]);
+	if (r.status !== 0) {
+		throw new Error(`mkfifo failed: ${r.stderr?.toString() ?? "unknown"}`);
+	}
+}
+
+describe("loadProjectDotenv", () => {
+	let dir: string;
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "claudeup-dotenv-"));
+	});
+
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	it("loads a regular .env", async () => {
+		await writeFile(join(dir, ".env"), "FOO=bar\nBAZ=qux\n");
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(env.FOO).toBe("bar");
+		expect(env.BAZ).toBe("qux");
+		expect(r.loaded).toEqual([".env"]);
+		expect(r.warnings).toEqual([]);
+	});
+
+	it("never overwrites a variable already in the environment", async () => {
+		await writeFile(join(dir, ".env"), "FOO=from-file\n");
+		const env: Record<string, string | undefined> = { FOO: "from-shell" };
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(env.FOO).toBe("from-shell");
+		expect(r.applied).not.toContain("FOO");
+	});
+
+	it("lets .env.local win over .env", async () => {
+		await writeFile(join(dir, ".env"), "FOO=base\nONLY_BASE=yes\n");
+		await writeFile(join(dir, ".env.local"), "FOO=override\n");
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(env.FOO).toBe("override");
+		expect(env.ONLY_BASE).toBe("yes");
+		expect(r.loaded).toEqual([".env", ".env.local"]);
+	});
+
+	it("says nothing when there is no .env at all", () => {
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(r.loaded).toEqual([]);
+		expect(r.warnings).toEqual([]);
+		expect(env).toEqual({});
+	});
+
+	// The regression this whole module exists for. claudeup 4.41.0 shipped a
+	// binary whose embedded Bun autoloaded .env and aborted on this exact shape:
+	// exit 1, nothing on stdout, nothing on stderr, in every git worktree where
+	// 1Password serves secrets through a pipe.
+	//
+	// Note the failure mode if this ever regresses: opening a FIFO with no writer
+	// BLOCKS, so a broken loader hangs here rather than failing an assertion.
+	// A timeout on this test is the same bug, reported differently.
+	it("skips a .env that is a symlink to a FIFO, and warns", async () => {
+		mkfifo(join(dir, "secrets-pipe"));
+		await symlink(join(dir, "secrets-pipe"), join(dir, ".env"));
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(r.loaded).toEqual([]);
+		expect(env).toEqual({});
+		expect(r.warnings).toHaveLength(1);
+		expect(r.warnings[0]).toContain(".env");
+		expect(r.warnings[0]).toContain("named pipe");
+	});
+
+	it("skips a .env that is a FIFO directly, and warns", () => {
+		mkfifo(join(dir, ".env"));
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(r.loaded).toEqual([]);
+		expect(r.warnings).toHaveLength(1);
+		expect(r.warnings[0]).toContain("named pipe");
+	});
+
+	it("follows a symlink that points at a regular file", async () => {
+		await writeFile(join(dir, "real-env"), "FOO=bar\n");
+		await symlink(join(dir, "real-env"), join(dir, ".env"));
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(env.FOO).toBe("bar");
+		expect(r.loaded).toEqual([".env"]);
+		expect(r.warnings).toEqual([]);
+	});
+
+	it("warns instead of throwing on a dangling symlink", async () => {
+		await symlink(join(dir, "nothing-here"), join(dir, ".env"));
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(r.loaded).toEqual([]);
+		expect(r.warnings).toHaveLength(1);
+		expect(r.warnings[0]).toContain("does not resolve");
+	});
+
+	it("skips a .env that is a directory, and warns", async () => {
+		await mkdir(join(dir, ".env"));
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(r.loaded).toEqual([]);
+		expect(r.warnings[0]).toContain("directory");
+	});
+
+	it("loads what it can from a file with unparseable lines", async () => {
+		await writeFile(
+			join(dir, ".env"),
+			"this is not a pair\nFOO=bar\n=novalue\n",
+		);
+		const env: Record<string, string | undefined> = {};
+
+		const r = loadProjectDotenv(dir, env);
+
+		expect(env.FOO).toBe("bar");
+		expect(r.warnings).toEqual([]);
+	});
+});
+
+describe("parseDotenv", () => {
+	it("ignores comments and blank lines", () => {
+		expect(parseDotenv("# note\n\nFOO=bar\n")).toEqual({ FOO: "bar" });
+	});
+
+	it("strips an export prefix", () => {
+		expect(parseDotenv("export FOO=bar\n")).toEqual({ FOO: "bar" });
+	});
+
+	it("strips surrounding quotes", () => {
+		expect(parseDotenv(`FOO="bar"\nBAZ='qux'\n`)).toEqual({
+			FOO: "bar",
+			BAZ: "qux",
+		});
+	});
+
+	it("expands escapes in double quotes but not single quotes", () => {
+		expect(parseDotenv(`A="one\\ntwo"\nB='one\\ntwo'\n`)).toEqual({
+			A: "one\ntwo",
+			B: "one\\ntwo",
+		});
+	});
+
+	it("drops a trailing comment from an unquoted value", () => {
+		expect(parseDotenv("FOO=bar # why\n")).toEqual({ FOO: "bar" });
+	});
+
+	it("keeps a # that is part of a quoted value", () => {
+		expect(parseDotenv(`FOO="bar # why"\n`)).toEqual({ FOO: "bar # why" });
+	});
+
+	it("keeps an = that appears inside a value", () => {
+		expect(parseDotenv("URL=postgres://u:p@h/db?a=b\n")).toEqual({
+			URL: "postgres://u:p@h/db?a=b",
+		});
+	});
+
+	it("rejects a key that is not a valid identifier", () => {
+		expect(parseDotenv("not-a-key=x\nOK=y\n")).toEqual({ OK: "y" });
+	});
+});

package/src/main.tsx

@@ -6,6 +6,7 @@ import { createRoot } from "@opentui/react";
 // a dynamic require("../package.json") is not resolvable inside the bunfs root.
 import pkg from "../package.json";
 import { route } from "./cli/router.js";
+import { loadProjectDotenv } from "./services/dotenv.js";
 import { App } from "./ui/App.js";
 import { setThemeMode } from "./ui/theme-mode.js";
 
@@ -17,6 +18,23 @@ export const VERSION = (pkg as { version: string }).version;
 async function main(): Promise<void> {
 	const args = process.argv.slice(2);
 
+	// Load the project's .env ourselves. Bun's standalone autoload is compiled OFF
+	// (scripts/build-binaries.ts) because it killed claudeup outright wherever
+	// .env was a symlink to a FIFO — the shape 1Password uses — exiting 1 with no
+	// output at all. services/dotenv.ts does the same job as an ordinary guarded
+	// read: regular files only, and every failure reported rather than fatal.
+	try {
+		for (const warning of loadProjectDotenv().warnings) {
+			console.warn(`claudeup: ${warning}`);
+		}
+	} catch (error) {
+		// Belt and braces. loadProjectDotenv is total, but no future edit to it may
+		// ever be allowed to stop claudeup from starting.
+		console.warn(
+			`claudeup: .env could not be loaded: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+
 	// Dispatch non-interactive subcommands (claude, update, install, …) and
 	// top-level flags (--version/--help). A bare invocation falls through to
 	// the interactive TUI below.

package/src/services/dotenv.ts

@@ -0,0 +1,176 @@
+import { lstatSync, readFileSync, statSync } from "node:fs";
+import type { Stats } from "node:fs";
+import path from "node:path";
+
+/**
+ * Load the project's .env into the process environment — deliberately, in our
+ * own code, with every failure downgraded to a warning.
+ *
+ * Bun's standalone-executable autoload used to do this for free. It is compiled
+ * OFF now (see scripts/build-binaries.ts): Bun 1.4.0 aborts inside that autoload
+ * when .env is a symlink pointing at a FIFO — exactly how 1Password serves
+ * secrets into a git worktree — exiting 1 with nothing on stdout or stderr,
+ * before any JavaScript runs and therefore before any error handler exists.
+ * claudeup simply vanished in every such directory.
+ *
+ * Two rules this loader keeps that the autoload did not:
+ *
+ *   1. Only regular files are read. A FIFO, socket or device is skipped, never
+ *      opened. That dodges the crash, and it is right on its own terms: a FIFO
+ *      hands its bytes to whoever opens it FIRST, so reading one would swallow
+ *      the secrets a dev server or `op run` was waiting for.
+ *   2. Nothing here is fatal. A missing, unreadable or malformed .env produces a
+ *      warning and claudeup carries on. Managing ~/.claude must never depend on
+ *      the state of whatever directory you happen to be standing in.
+ *
+ * A real environment variable always beats a file, matching dotenv convention;
+ * a later file beats an earlier one.
+ */
+
+/** Files loaded, in order. A later file overrides an earlier one. */
+const ENV_FILES = [".env", ".env.local"] as const;
+
+export interface DotenvOutcome {
+	/** Files actually parsed, in the order applied. */
+	loaded: string[];
+	/** Names newly set. A pre-existing variable is never overwritten. */
+	applied: string[];
+	/** One line per file skipped or failed. Print these; never throw them. */
+	warnings: string[];
+}
+
+/**
+ * Parse dotenv text. Best-effort by design: an unparseable line is skipped
+ * rather than raised, because a broken .env must not be able to stop claudeup.
+ * Values spanning several lines are not supported.
+ */
+export function parseDotenv(text: string): Record<string, string> {
+	const out: Record<string, string> = {};
+
+	for (const rawLine of text.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (line === "" || line.startsWith("#")) continue;
+
+		const eq = line.indexOf("=");
+		if (eq <= 0) continue;
+
+		let key = line.slice(0, eq).trim();
+		if (key.startsWith("export ")) key = key.slice("export ".length).trim();
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+
+		let value = line.slice(eq + 1).trim();
+		const quote = value[0];
+		const quoted =
+			(quote === '"' || quote === "'") &&
+			value.length > 1 &&
+			value.endsWith(quote);
+
+		if (quoted) {
+			value = value.slice(1, -1);
+			// Escapes are a double-quote feature; single quotes stay literal.
+			if (quote === '"') {
+				value = value
+					.replace(/\\n/g, "\n")
+					.replace(/\\r/g, "\r")
+					.replace(/\\t/g, "\t");
+			}
+		} else {
+			// An unquoted value ends at the first " #" comment.
+			const hash = value.indexOf(" #");
+			if (hash !== -1) value = value.slice(0, hash).trimEnd();
+		}
+
+		out[key] = value;
+	}
+
+	return out;
+}
+
+/** What a non-regular entry actually is, for a warning a human can act on. */
+function describeKind(info: Stats): string {
+	if (info.isFIFO()) {
+		return "it is a named pipe; reading it would consume another process's secrets";
+	}
+	if (info.isSocket()) return "it is a socket, not a regular file";
+	if (info.isDirectory()) return "it is a directory, not a regular file";
+	if (info.isBlockDevice() || info.isCharacterDevice()) {
+		return "it is a device, not a regular file";
+	}
+	return "it is not a regular file";
+}
+
+function reason(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Read .env and .env.local from `cwd` into `env`. Never throws.
+ *
+ * Returns what was loaded and, in `warnings`, every reason a file was skipped or
+ * failed — the caller decides how to surface them.
+ */
+export function loadProjectDotenv(
+	cwd: string = process.cwd(),
+	env: Record<string, string | undefined> = process.env,
+): DotenvOutcome {
+	const outcome: DotenvOutcome = { loaded: [], applied: [], warnings: [] };
+
+	// Merge every file BEFORE touching `env`. Applying file by file would make
+	// the "never overwrite" rule below fire against .env's own values, so .env
+	// would silently beat .env.local — the opposite of the intended precedence.
+	const merged: Record<string, string> = {};
+
+	for (const name of ENV_FILES) {
+		const file = path.join(cwd, name);
+
+		// lstat first, so a symlink is recognised as one: the warning should name
+		// the file the user sees, while the decision is made about its target.
+		let info: Stats;
+		try {
+			info = lstatSync(file);
+		} catch {
+			continue; // Absent. That is the ordinary case, not a problem.
+		}
+
+		if (info.isSymbolicLink()) {
+			try {
+				info = statSync(file);
+			} catch {
+				outcome.warnings.push(`skipped ${name} — the symlink does not resolve`);
+				continue;
+			}
+		}
+
+		if (!info.isFile()) {
+			outcome.warnings.push(`skipped ${name} — ${describeKind(info)}`);
+			continue;
+		}
+
+		let text: string;
+		try {
+			text = readFileSync(file, "utf8");
+		} catch (error) {
+			outcome.warnings.push(`could not read ${name} — ${reason(error)}`);
+			continue;
+		}
+
+		let parsed: Record<string, string>;
+		try {
+			parsed = parseDotenv(text);
+		} catch (error) {
+			outcome.warnings.push(`could not parse ${name} — ${reason(error)}`);
+			continue;
+		}
+
+		outcome.loaded.push(name);
+		Object.assign(merged, parsed); // A later file beats an earlier one.
+	}
+
+	for (const [key, value] of Object.entries(merged)) {
+		if (env[key] !== undefined) continue; // A real variable always wins.
+		env[key] = value;
+		outcome.applied.push(key);
+	}
+
+	return outcome;
+}