@crewhaus/single-binary-cli 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/single-binary-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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,10 +10,11 @@
   },
   "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.2"
+    "@crewhaus/errors": "0.1.4"
   },
   "license": "Apache-2.0",
   "author": {

package/src/index.test.ts

@@ -100,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({
@@ -148,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"]);
@@ -168,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");
   });
@@ -179,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());
   });
 

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
@@ -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

@@ -15,8 +15,14 @@
  */
 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");
 
@@ -76,7 +82,7 @@ describe("defaultRunner (real child_process path, mocked spawn)", () => {
     expect(captured.rest).toContain("--compile");
     expect(captured.rest).toContain("bun-linux-x64");
     // cwd is REPO_ROOT (two levels above the package).
-    expect(captured.cwd).toMatch(/factory$/);
+    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");
   });