@journeykit/canon 0.1.0

package/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+await import("./dist/index.js");

package/dist/index.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawnSync, execSync } from "node:child_process";
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { resolve, join, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+var binaryName = process.platform === "win32" ? "canon.exe" : "canon";
+var currentDir = fileURLToPath(new URL(".", import.meta.url));
+var dirName = basename(currentDir);
+var isSubDir = dirName === "dist" || dirName === "src";
+var cliDir = isSubDir ? resolve(currentDir, "..") : currentDir;
+var scopeDir = resolve(cliDir, "..");
+var workspaceRoot = resolve(scopeDir, "..");
+function detectLibcKind() {
+  const override = process.env.CANON_LIBC?.trim().toLowerCase();
+  if (override === "musl")
+    return "musl";
+  if (override === "gnu" || override === "glibc")
+    return "gnu";
+  const report = process.report?.getReport?.();
+  if (report?.header?.glibcVersionRuntime) {
+    return "gnu";
+  }
+  if (Array.isArray(report?.sharedObjects) && report.sharedObjects.some((obj) => obj.toLowerCase().includes("musl"))) {
+    return "musl";
+  }
+  if (report?.header?.release?.sourceUrl?.toLowerCase().includes("musl")) {
+    return "musl";
+  }
+  try {
+    const output = execSync("ldd --version", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).toLowerCase();
+    if (output.includes("musl"))
+      return "musl";
+    if (output.includes("glibc") || output.includes("gnu"))
+      return "gnu";
+  } catch (error) {
+    const { stdout, stderr } = error ?? {};
+    const combined = `${stdout ?? ""}
+${stderr ?? ""}`.toLowerCase();
+    if (combined.includes("musl"))
+      return "musl";
+    if (combined.includes("glibc") || combined.includes("gnu"))
+      return "gnu";
+  }
+  const hasGnuLoader = loaderPresent("ld-linux-");
+  const hasMuslLoader = loaderPresent("ld-musl-");
+  if (hasGnuLoader !== hasMuslLoader)
+    return hasMuslLoader ? "musl" : "gnu";
+  if (hasGnuLoader && hasMuslLoader) {
+    return existsSync("/etc/alpine-release") ? "musl" : "gnu";
+  }
+  return "gnu";
+}
+function loaderPresent(prefix) {
+  for (const dir of ["/lib", "/lib64"]) {
+    try {
+      if (readdirSync(dir).some((entry) => entry.startsWith(prefix))) {
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
+function resolveTargetPackageName() {
+  const arch = process.arch;
+  if (process.platform === "darwin") {
+    if (arch === "arm64")
+      return "core-darwin-arm64";
+    return null;
+  }
+  if (process.platform === "linux") {
+    const libc = detectLibcKind();
+    if (arch === "x64" && libc === "gnu")
+      return "core-linux-x64";
+    return null;
+  }
+  return null;
+}
+function resolveRustTargetTriple() {
+  const arch = process.arch;
+  if (process.platform === "darwin") {
+    if (arch === "arm64")
+      return "aarch64-apple-darwin";
+    if (arch === "x64")
+      return "x86_64-apple-darwin";
+    return null;
+  }
+  if (process.platform === "linux") {
+    const libc = detectLibcKind();
+    if (arch === "arm64") {
+      return libc === "musl" ? "aarch64-unknown-linux-musl" : "aarch64-unknown-linux-gnu";
+    }
+    if (arch === "x64") {
+      return libc === "musl" ? "x86_64-unknown-linux-musl" : "x86_64-unknown-linux-gnu";
+    }
+    return null;
+  }
+  if (process.platform === "win32") {
+    if (arch === "arm64")
+      return "aarch64-pc-windows-msvc";
+    if (arch === "x64")
+      return "x86_64-pc-windows-msvc";
+    return null;
+  }
+  return null;
+}
+var targetPackage = resolveTargetPackageName();
+var rustTargetTriple = resolveRustTargetTriple();
+var searchPaths = [];
+if (rustTargetTriple) {
+  searchPaths.push(join(workspaceRoot, "target", rustTargetTriple, "release", binaryName));
+}
+searchPaths.push(join(workspaceRoot, "target", "release", binaryName));
+searchPaths.push(join(cliDir, "bin", binaryName));
+var scope = "@journeykit";
+var platformBareName = targetPackage ? `canon-${targetPackage}` : null;
+var platformPkgName = platformBareName ? `${scope}/${platformBareName}` : null;
+if (targetPackage) {
+  searchPaths.push(join(workspaceRoot, "packages", targetPackage, "bin", binaryName));
+}
+if (platformBareName) {
+  searchPaths.push(join(scopeDir, platformBareName, "bin", binaryName), join(cliDir, "node_modules", scope, platformBareName, "bin", binaryName), join(scopeDir, "node_modules", scope, platformBareName, "bin", binaryName), join(workspaceRoot, "node_modules", scope, platformBareName, "bin", binaryName));
+}
+function tryRealpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+var selfPaths = new Set([
+  tryRealpath(fileURLToPath(import.meta.url)),
+  tryRealpath(join(cliDir, "bin.js"))
+]);
+if (process.argv[1]) {
+  selfPaths.add(tryRealpath(process.argv[1]));
+}
+var binary = searchPaths.find((p) => existsSync(p) && !selfPaths.has(tryRealpath(p)));
+if (!binary) {
+  console.error(`canon: no binary found for ${process.platform}/${process.arch}`);
+  if (platformPkgName) {
+    console.error(`  expected optional package: ${platformPkgName}`);
+  } else {
+    console.error("  no @journeykit/canon-core-<platform> package exists for this platform/arch yet");
+  }
+  console.error("  build from source: cargo build --release -p canon-cli");
+  process.exit(1);
+}
+var result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+process.exit(result.status ?? 1);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@journeykit/canon",
+  "version": "0.1.0",
+  "description": "canon — harness knowledge substrate. JS launcher: platform detection + native binary resolution.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "canon": "./bin.js"
+  },
+  "files": [
+    "bin.js",
+    "dist/**/*"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/journeyWorker/canon.git",
+    "directory": "packages/cli"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --format esm",
+    "dev": "bun src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {},
+  "optionalDependencies": {
+    "@journeykit/canon-core-darwin-arm64": "0.1.0",
+    "@journeykit/canon-core-linux-x64": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "canon",
+    "harness",
+    "spec-driven",
+    "cli"
+  ]
+}