@cabane/companion 0.6.88 → 0.6.90

package/dist/pairing-config.js

@@ -182,9 +182,10 @@ var companionConfigSchema = z2.object({
   // The change this task exists for: Claude Code used to be the one harness a
   // device exposed with no configuration — a `claude --version` exit-0 was taken as
   // consent — and it is now the third config-driven harness, opted into exactly
-  // like codex. `claude` on PATH is still required (you can't run what isn't
-  // installed), but presence alone no longer exposes anything: the manifest
-  // advertises claude-code only when this block says so AND the binary is there.
+  // like codex. CT1379: the binary that must be there is the Agent SDK's own
+  // bundled executable — the file a turn actually launches — not the user's
+  // `claude` on PATH, which the SDK never runs. The manifest advertises
+  // claude-code only when this block says so AND that binary resolves.
   //
   // The block's PRESENCE is also the migration marker (see `migrateConnectedHarnesses`).
   // Absent means the config predates this task — a device whose user was never
@@ -204,9 +205,11 @@ var companionConfigSchema = z2.object({
   // not a server address. The operator installs Codex + logs in (`codex login`, or
   // `CODEX_API_KEY` — Cabane never sees the key) and sets `{ "codex": { "enabled":
   // true } }`. Presence of the block enables it (an explicit `enabled: false`
-  // keeps the block but turns it off). Enabling makes the device advertise the
-  // `codex` runtime on its heartbeat manifest AND registers the codex adapter in
-  // the dispatcher. Absent → the device doesn't offer codex, exactly as before.
+  // keeps the block but turns it off). Absent → the device doesn't offer codex.
+  // CT1379: enabling is now half the answer, not all of it — the manifest and the
+  // adapter registry additionally require the SDK's vendored `codex` binary to
+  // resolve, because the enable flag alone advertised a runtime a device with a
+  // half-installed platform package could not start.
   codex: z2.object({
     enabled: z2.boolean().optional()
   }).strict().optional()

package/dist/postinstall.js

@@ -0,0 +1,209 @@
+// src/bundled-binaries.ts
+import { realpathSync, statSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function nodeResolveSelf(specifier) {
+  const here = fileURLToPath(import.meta.url);
+  if (typeof import.meta.resolve === "function") {
+    try {
+      return fileURLToPath(import.meta.resolve(specifier));
+    } catch {
+    }
+  }
+  try {
+    return createRequire(here).resolve(specifier);
+  } catch {
+  }
+  return walkNodeModules(specifier, here);
+}
+function walkNodeModules(pkg, fromPath) {
+  let dir = dirname(fromPath);
+  for (; ; ) {
+    const manifest = join(dir, "node_modules", pkg, "package.json");
+    if (nodeIsFile(manifest)) {
+      try {
+        return realpathSync(manifest);
+      } catch {
+        return manifest;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function nodeResolve(specifier, fromPath) {
+  try {
+    return createRequire(fromPath).resolve(specifier);
+  } catch {
+    return null;
+  }
+}
+function nodeIsFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function detectPreferMusl(platform = process.platform) {
+  if (platform !== "linux") return false;
+  const report = typeof process.report?.getReport === "function" ? process.report.getReport() : null;
+  const header = report?.header;
+  return report != null && header?.glibcVersionRuntime === void 0;
+}
+function defaultResolveEnv() {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    preferMusl: detectPreferMusl(),
+    // Both resolutions start from this module, which tsup bundles into
+    // `dist/cli.js` and `dist/postinstall.js` — both at the package's `dist/`
+    // root — so one environment serves the runtime checks and the install
+    // verifier alike.
+    resolveSelf: nodeResolveSelf,
+    resolve: nodeResolve,
+    isFile: nodeIsFile
+  };
+}
+var CLAUDE_SDK = "@anthropic-ai/claude-agent-sdk";
+function claudePlatformPackages(platform, arch, preferMusl) {
+  if (platform === "android") return [`${CLAUDE_SDK}-linux-${arch}-android`];
+  if (platform === "linux") {
+    return preferMusl ? [`${CLAUDE_SDK}-linux-${arch}-musl`, `${CLAUDE_SDK}-linux-${arch}`] : [`${CLAUDE_SDK}-linux-${arch}`, `${CLAUDE_SDK}-linux-${arch}-musl`];
+  }
+  return [`${CLAUDE_SDK}-${platform}-${arch}`];
+}
+function resolveClaude(env) {
+  const candidates = claudePlatformPackages(env.platform, env.arch, env.preferMusl);
+  const base = {
+    runtime: "claude-code",
+    packageName: candidates[0] ?? null,
+    platform: env.platform,
+    arch: env.arch
+  };
+  const sdkEntry = env.resolveSelf(CLAUDE_SDK);
+  if (!sdkEntry) return { ...base, status: "platform_package_missing", path: null };
+  let sawPackage = null;
+  for (const pkg of candidates) {
+    const manifest = env.resolve(`${pkg}/package.json`, sdkEntry);
+    if (!manifest) continue;
+    sawPackage ??= pkg;
+    const exe = join(dirname(manifest), env.platform === "win32" ? "claude.exe" : "claude");
+    if (env.isFile(exe)) {
+      return { ...base, packageName: pkg, status: "present", path: exe };
+    }
+  }
+  return sawPackage ? { ...base, packageName: sawPackage, status: "executable_missing", path: null } : { ...base, status: "platform_package_missing", path: null };
+}
+var CODEX_SDK = "@openai/codex-sdk";
+var CODEX_CLI = "@openai/codex";
+function codexTargetTriple(platform, arch) {
+  if (platform === "linux" || platform === "android") {
+    if (arch === "x64") return "x86_64-unknown-linux-musl";
+    if (arch === "arm64") return "aarch64-unknown-linux-musl";
+    return null;
+  }
+  if (platform === "darwin") {
+    if (arch === "x64") return "x86_64-apple-darwin";
+    if (arch === "arm64") return "aarch64-apple-darwin";
+    return null;
+  }
+  if (platform === "win32") {
+    if (arch === "x64") return "x86_64-pc-windows-msvc";
+    if (arch === "arm64") return "aarch64-pc-windows-msvc";
+    return null;
+  }
+  return null;
+}
+var CODEX_PACKAGE_BY_TRIPLE = {
+  "x86_64-unknown-linux-musl": `${CODEX_CLI}-linux-x64`,
+  "aarch64-unknown-linux-musl": `${CODEX_CLI}-linux-arm64`,
+  "x86_64-apple-darwin": `${CODEX_CLI}-darwin-x64`,
+  "aarch64-apple-darwin": `${CODEX_CLI}-darwin-arm64`,
+  "x86_64-pc-windows-msvc": `${CODEX_CLI}-win32-x64`,
+  "aarch64-pc-windows-msvc": `${CODEX_CLI}-win32-arm64`
+};
+function resolveCodex(env) {
+  const triple = codexTargetTriple(env.platform, env.arch);
+  const pkg = triple ? CODEX_PACKAGE_BY_TRIPLE[triple] : void 0;
+  const base = {
+    runtime: "codex",
+    packageName: pkg ?? null,
+    platform: env.platform,
+    arch: env.arch
+  };
+  if (!triple || !pkg) return { ...base, status: "platform_package_missing", path: null };
+  const sdkEntry = env.resolveSelf(CODEX_SDK);
+  if (!sdkEntry) return { ...base, status: "platform_package_missing", path: null };
+  const cliManifest = env.resolve(`${CODEX_CLI}/package.json`, sdkEntry);
+  if (!cliManifest) return { ...base, status: "platform_package_missing", path: null };
+  const platformManifest = env.resolve(`${pkg}/package.json`, cliManifest);
+  if (!platformManifest) return { ...base, status: "platform_package_missing", path: null };
+  const packageRoot = join(dirname(platformManifest), "vendor", triple);
+  const exeName = env.platform === "win32" ? "codex.exe" : "codex";
+  const current = join(packageRoot, "bin", exeName);
+  if (env.isFile(current) && env.isFile(join(packageRoot, "codex-package.json"))) {
+    return { ...base, status: "present", path: current };
+  }
+  const legacy = join(packageRoot, "codex", exeName);
+  if (env.isFile(legacy)) return { ...base, status: "present", path: legacy };
+  return { ...base, status: "executable_missing", path: null };
+}
+function resolveBundledBinary(runtime, env = defaultResolveEnv()) {
+  try {
+    return runtime === "codex" ? resolveCodex(env) : resolveClaude(env);
+  } catch {
+    return {
+      runtime,
+      status: "platform_package_missing",
+      path: null,
+      packageName: null,
+      platform: env.platform,
+      arch: env.arch
+    };
+  }
+}
+function resolveBothBundledBinaries(env = defaultResolveEnv()) {
+  return {
+    "claude-code": resolveBundledBinary("claude-code", env),
+    codex: resolveBundledBinary("codex", env)
+  };
+}
+var HARNESS_LABEL = {
+  "claude-code": "Claude Code",
+  codex: "Codex"
+};
+function missingNoun(status) {
+  return status === "executable_missing" ? "executable" : "platform package";
+}
+function repairCommands() {
+  return ["npm i -g @cabane/companion --include=optional"];
+}
+function repairAction() {
+  return `Reinstall with \`${repairCommands()[0]}\`.`;
+}
+function installWarning(r) {
+  return `warning: @cabane/companion is incomplete: its bundled ${HARNESS_LABEL[r.runtime]} ${missingNoun(r.status)} for ${r.platform}-${r.arch} is missing. ${repairAction()}`;
+}
+
+// src/postinstall.ts
+function main(argv) {
+  const resolutions = resolveBothBundledBinaries();
+  if (argv.includes("--json")) {
+    process.stdout.write(`${JSON.stringify(resolutions, null, 2)}
+`);
+    return;
+  }
+  const missing = Object.values(resolutions).filter(
+    (r) => r.status !== "present"
+  );
+  for (const r of missing) process.stderr.write(`${installWarning(r)}
+`);
+}
+try {
+  main(process.argv.slice(2));
+} catch {
+}
+process.exitCode = 0;