@crewhaus/single-binary-cli 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/single-binary-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "bun build --compile wrapper producing self-contained crewhaus binaries for linux/macos/windows × x64/arm64; auto-generated Homebrew/apt/Scoop/Winget manifests (Section 32)",
   "main": "src/index.ts",
@@ -10,16 +10,17 @@
   },
   "scripts": {
     "test": "bun test src",
-    "build:binary": "bun src/cli.ts"
+    "build:binary": "bun src/cli.ts",
+    "manifests": "bun src/manifests.ts"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.1.1"
+    "@crewhaus/errors": "0.1.3"
   },
   "license": "Apache-2.0",
   "author": {
     "name": "Max Meier",
-    "email": "max@studiomax.io",
-    "url": "https://studiomax.io"
+    "email": "max@crewhaus.ai",
+    "url": "https://crewhaus.ai"
   },
   "repository": {
     "type": "git",
@@ -31,12 +32,7 @@
     "url": "https://github.com/crewhaus/factory/issues"
   },
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
-  "files": [
-    "src",
-    "README.md",
-    "LICENSE",
-    "NOTICE"
-  ]
+  "files": ["src", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.test.ts

@@ -15,6 +15,7 @@ import {
   bunCompileTarget,
   formatTarget,
   isBuildTarget,
+  packagingDir,
   renderDebianControl,
   renderHomebrewFormula,
   renderScoopManifest,
@@ -99,9 +100,25 @@ describe("buildBinary() (T2 dry-run)", () => {
     expect(captured).toContain("bun-linux-x64");
     expect(captured).toContain("--outfile");
     expect(captured).toContain("/tmp/dist/crewhaus-linux-x64-1.2.3");
+    expect(captured).toContain("--define");
+    expect(captured).toContain('CREWHAUS_EMBEDDED_VERSION="1.2.3"');
     expect(result.outPath).toBe("/tmp/dist/crewhaus-linux-x64-1.2.3");
   });
 
+  test("no version → no --define (the CLI falls back to its package.json read)", async () => {
+    let captured: readonly string[] = [];
+    const runner: BuildBinaryRunner = async (argv) => {
+      captured = argv;
+      return { exitCode: 0, stdout: "", stderr: "" };
+    };
+    await buildBinary({
+      target: { platform: "linux", arch: "x64" },
+      outDir: "/tmp/dist",
+      runner,
+    });
+    expect(captured).not.toContain("--define");
+  });
+
   test("rejects unsupported target windows-arm64", async () => {
     await expect(
       buildBinary({
@@ -147,6 +164,7 @@ describe("manifest rendering (T1)", () => {
     expect(formula).toContain('version "1.0.0"');
     expect(formula).toContain("on_macos");
     expect(formula).toContain("on_linux");
+    expect(formula).toContain('license "Apache-2.0"');
     expect(formula).toContain(sha256["macos-arm64"]);
     expect(formula).toContain(sha256["macos-x64"]);
     expect(formula).toContain(sha256["linux-arm64"]);
@@ -167,9 +185,11 @@ describe("manifest rendering (T1)", () => {
   test("Scoop manifest exposes 64bit url + hash", () => {
     const scoop = renderScoopManifest(inputs) as {
       version: string;
+      license: string;
       architecture: { "64bit": { url: string; hash: string } };
     };
     expect(scoop.version).toBe("1.0.0");
+    expect(scoop.license).toBe("Apache-2.0");
     expect(scoop.architecture["64bit"].hash).toBe(sha256["windows-x64"]);
     expect(scoop.architecture["64bit"].url).toContain("crewhaus-windows-x64-1.0.0.exe");
   });
@@ -178,6 +198,7 @@ describe("manifest rendering (T1)", () => {
     const winget = renderWingetManifest(inputs);
     expect(winget).toContain("PackageIdentifier: CrewHaus.CLI");
     expect(winget).toContain("PackageVersion: 1.0.0");
+    expect(winget).toContain("License: Apache-2.0");
     expect(winget).toContain(sha256["windows-x64"].toUpperCase());
   });
 
@@ -200,6 +221,11 @@ describe("manifest rendering (T1)", () => {
       '"hash": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"',
     );
   });
+
+  test("packagingDir() points at the package's packaging/ directory (default root)", () => {
+    // The default on-disk root used by writeAllManifests when no dir is given.
+    expect(packagingDir()).toMatch(/single-binary-cli[/\\]packaging$/);
+  });
 });
 
 describe("sha256OfFile", () => {

package/src/index.ts

@@ -105,6 +105,10 @@ export async function buildBinary(opts: BuildBinaryOptions): Promise<BuildBinary
     "--compile",
     "--target",
     bunCompileTarget(t),
+    // Embed the version: inside a compiled binary import.meta.url points
+    // into the virtual /$bunfs tree, so the CLI's runtime ../package.json
+    // read cannot work — `crewhaus --version` uses this constant instead.
+    ...(version ? ["--define", `CREWHAUS_EMBEDDED_VERSION=${JSON.stringify(version)}`] : []),
     CLI_ENTRYPOINT_REL,
     "--outfile",
     outPath,
@@ -174,7 +178,7 @@ export function renderHomebrewFormula(inputs: ManifestInputs): string {
   desc "Modular meta-harness — compile a single spec into multiple agent runtimes"
   homepage "${homepage}"
   version "${version}"
-  license "MIT"
+  license "Apache-2.0"
 
   on_macos do
     on_arm do
@@ -216,7 +220,7 @@ Version: ${version}
 Section: utils
 Priority: optional
 Architecture: any
-Maintainer: CrewHaus Maintainers <maintainers@crewhaus.io>
+Maintainer: CrewHaus Maintainers <maintainers@crewhaus.ai>
 Depends: libc6 (>= 2.31)
 Description: Modular meta-harness — compile a single spec into multiple agent runtimes
  CrewHaus compiles a single high-level harness spec into multiple
@@ -233,7 +237,7 @@ export function renderScoopManifest(inputs: ManifestInputs): unknown {
     version,
     description: "Modular meta-harness — compile a single spec into multiple agent runtimes",
     homepage,
-    license: "MIT",
+    license: "Apache-2.0",
     architecture: {
       "64bit": {
         url: `${downloadBaseUrl}/crewhaus-windows-x64-${version}.exe`,
@@ -254,7 +258,7 @@ Publisher: CrewHaus
 Author: CrewHaus
 PackageName: crewhaus
 PackageUrl: ${homepage}
-License: MIT
+License: Apache-2.0
 ShortDescription: Modular meta-harness — compile a single spec into multiple agent runtimes
 Description: |
   CrewHaus compiles a single high-level harness spec into multiple runtime targets.

package/src/manifests.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env bun
+/**
+ * Generate the Homebrew / apt / Scoop / Winget package manifests from the
+ * binaries already built into `dist/` by `build:binary`. Run AFTER the build.
+ * Used by the release workflow (.github/workflows/release.yml) so the manifest
+ * generation is a single, unit-tested command rather than inline YAML.
+ *
+ *   bun src/manifests.ts --version 1.2.3 \
+ *     --download-base-url https://github.com/crewhaus/factory/releases/download/v1.2.3 \
+ *     --dist <repo>/dist --out <repo>/packaging
+ *
+ * Prints a JSON summary ({version, downloadBaseUrl, sha256, written}) to stdout
+ * so CI can capture the sha map and the written paths.
+ */
+import { join, resolve } from "node:path";
+import {
+  BUILD_MATRIX,
+  type ShaByTarget,
+  binaryName,
+  formatTarget,
+  packagingDir,
+  sha256OfFile,
+  writeAllManifests,
+} from "./index";
+
+function flag(name: string, argv: string[]): string | undefined {
+  const i = argv.indexOf(`--${name}`);
+  return i >= 0 ? argv[i + 1] : undefined;
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const version = flag("version", argv);
+  if (!version) {
+    console.error("✗ --version is required (e.g. --version 1.2.3)");
+    process.exit(1);
+  }
+  const homepage = flag("homepage", argv) ?? "https://github.com/crewhaus/factory";
+  const downloadBaseUrl =
+    flag("download-base-url", argv) ??
+    `https://github.com/crewhaus/factory/releases/download/v${version}`;
+  const distDir = resolve(flag("dist", argv) ?? join(import.meta.dir, "..", "..", "..", "dist"));
+  const outArg = flag("out", argv);
+  const outDir = outArg ? resolve(outArg) : packagingDir();
+
+  // sha256 every built binary. A missing file is a hard error — the manifests
+  // must never reference an asset that was not actually built and uploaded.
+  const sha256: Record<string, string> = {};
+  for (const t of BUILD_MATRIX) {
+    const file = join(distDir, binaryName(t, version));
+    sha256[formatTarget(t)] = await sha256OfFile(file);
+  }
+
+  const inputs = { version, homepage, downloadBaseUrl, sha256: sha256 as ShaByTarget };
+  const written = writeAllManifests(inputs, outDir);
+
+  console.log(JSON.stringify({ version, downloadBaseUrl, sha256, written }, null, 2));
+}
+
+main().catch((err) => {
+  console.error(`✗ manifest generation failed: ${(err as Error).message}`);
+  process.exit(1);
+});

package/src/runner.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Coverage for the default `child_process`-backed build runner.
+ *
+ * Every other test injects a fake `runner`, so the real `defaultRunner`
+ * (which spawns `bun build --compile`) is never exercised. Here we drive it
+ * by calling `buildBinary` WITHOUT a runner and mocking `node:child_process`
+ * so `spawn` returns a fake child emitter — no real process, no real timers.
+ *
+ * The fake child fires its stdout/stderr/close|error listeners on a
+ * microtask (queueMicrotask), which is deterministic and needs no fake clock.
+ * NOTE: `mock.restore()` does NOT undo `mock.module`, and Bun shares one
+ * module registry across all test files (nondeterministic order) — the
+ * `afterAll` below reinstalls the real `node:child_process` so the per-test
+ * spawn fakes can't leak into the sibling suite.
+ */
+import { afterAll, afterEach, describe, expect, mock, test } from "bun:test";
+import { EventEmitter } from "node:events";
+import { resolve } from "node:path";
+import { SingleBinaryError, buildBinary } from "./index";
+
+// Mirror REPO_ROOT from ./index — two levels above the package root,
+// whatever the checkout or worktree happens to be named. (`tsc -b` also
+// runs this file from dist/, hence the src|dist strip.)
+const REPO_ROOT = resolve(import.meta.dir.replace(/[/\\](src|dist)$/, ""), "..", "..");
+
+// Captured before any mock.module call so afterAll can reinstall the real module.
+const realChildProcess = require("node:child_process") as typeof import("node:child_process");
+
+afterAll(() => {
+  mock.module("node:child_process", () => realChildProcess);
+});
+
+type FakeOpts = {
+  readonly stdout?: string;
+  readonly stderr?: string;
+  readonly code?: number | null;
+  readonly emitError?: Error;
+};
+
+function fakeChild(opts: FakeOpts): EventEmitter & { stdout: EventEmitter; stderr: EventEmitter } {
+  const child = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+  };
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  // Emit after the caller has attached its listeners (next microtask).
+  queueMicrotask(() => {
+    if (opts.stdout) child.stdout.emit("data", Buffer.from(opts.stdout, "utf8"));
+    if (opts.stderr) child.stderr.emit("data", Buffer.from(opts.stderr, "utf8"));
+    if (opts.emitError) {
+      child.emit("error", opts.emitError);
+    } else {
+      // Emit the code verbatim — including an explicit `null` — so the
+      // `code ?? 1` branch in defaultRunner is exercised, not masked here.
+      child.emit("close", opts.code === undefined ? 0 : opts.code);
+    }
+  });
+  return child;
+}
+
+describe("defaultRunner (real child_process path, mocked spawn)", () => {
+  afterEach(() => mock.restore());
+
+  test("spawns `bun` with the compile argv and resolves on clean exit", async () => {
+    let captured: { head?: string; rest?: string[]; cwd?: string } = {};
+    mock.module("node:child_process", () => ({
+      spawn: (head: string, rest: string[], optsArg: { cwd: string }) => {
+        captured = { head, rest, cwd: optsArg.cwd };
+        return fakeChild({ stdout: "compiled ok", code: 0 });
+      },
+    }));
+
+    const result = await buildBinary({
+      target: { platform: "linux", arch: "x64" },
+      version: "9.9.9",
+      outDir: "/tmp/sbc-runner-dist",
+    });
+
+    expect(captured.head).toBe("bun");
+    expect(captured.rest).toContain("build");
+    expect(captured.rest).toContain("--compile");
+    expect(captured.rest).toContain("bun-linux-x64");
+    // cwd is REPO_ROOT (two levels above the package).
+    expect(captured.cwd).toBe(REPO_ROOT);
+    expect(result.outPath).toBe("/tmp/sbc-runner-dist/crewhaus-linux-x64-9.9.9");
+    expect(result.buildArgv[0]).toBe("bun");
+  });
+
+  test("accumulates multiple stdout/stderr chunks before close", async () => {
+    mock.module("node:child_process", () => ({
+      spawn: () => {
+        const child = new EventEmitter() as EventEmitter & {
+          stdout: EventEmitter;
+          stderr: EventEmitter;
+        };
+        child.stdout = new EventEmitter();
+        child.stderr = new EventEmitter();
+        queueMicrotask(() => {
+          child.stdout.emit("data", Buffer.from("part1-", "utf8"));
+          child.stdout.emit("data", Buffer.from("part2", "utf8"));
+          child.stderr.emit("data", Buffer.from("warn", "utf8"));
+          child.emit("close", 0);
+        });
+        return child;
+      },
+    }));
+    // exit 0 → resolves; the multi-chunk buffers exercise the data handlers.
+    const result = await buildBinary({
+      target: { platform: "macos", arch: "x64" },
+      outDir: "/tmp/sbc-runner-dist",
+    });
+    expect(result.target.platform).toBe("macos");
+  });
+
+  test("non-zero exit code surfaces stderr in a SingleBinaryError", async () => {
+    mock.module("node:child_process", () => ({
+      spawn: () => fakeChild({ stderr: "bun: compile failed", code: 7 }),
+    }));
+    await expect(
+      buildBinary({ target: { platform: "macos", arch: "arm64" }, outDir: "/tmp/sbc-runner-dist" }),
+    ).rejects.toThrow(/exited with 7: bun: compile failed/);
+  });
+
+  test("a null exit code is treated as failure (exitCode 1)", async () => {
+    mock.module("node:child_process", () => ({
+      spawn: () => fakeChild({ stderr: "killed", code: null }),
+    }));
+    await expect(
+      buildBinary({ target: { platform: "windows", arch: "x64" }, outDir: "/tmp/sbc-runner-dist" }),
+    ).rejects.toBeInstanceOf(SingleBinaryError);
+  });
+
+  test("a spawn `error` event resolves to exitCode 1 → SingleBinaryError", async () => {
+    mock.module("node:child_process", () => ({
+      spawn: () => fakeChild({ emitError: new Error("spawn ENOENT: bun not on PATH") }),
+    }));
+    await expect(
+      buildBinary({ target: { platform: "linux", arch: "arm64" }, outDir: "/tmp/sbc-runner-dist" }),
+    ).rejects.toThrow(/spawn ENOENT: bun not on PATH/);
+  });
+});