@clanker-code/c2c 0.8.5 → 0.8.6

package/bin/c2c-deliver-inbox-js-wrapper.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+
+const path = require("node:path");
+const childProcess = require("node:child_process");
+const { resolveC2cBinary } = require("..");
+
+function executableForWrapper(argv1) {
+  const basename = path.basename(argv1 || "c2c");
+  return basename.startsWith("c2c-deliver-inbox") ? "c2c-deliver-inbox" : "c2c";
+}
+
+function main() {
+  const executable = executableForWrapper(process.argv[1]);
+  let binary;
+  try {
+    binary = resolveC2cBinary({ selfPath: __filename, executable });
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+
+  const result = childProcess.spawnSync(binary, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  if (result.error) {
+    console.error(`failed to execute ${binary}: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    process.exit(1);
+  }
+
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+main();

package/bin/c2c-js-wrapper.js

@@ -1,9 +1,41 @@
 #!/usr/bin/env node
-const { spawnSync } = require("child_process");
-const { resolveC2cBinary } = require("../index.js");
-
-const binary = resolveC2cBinary();
-const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
-if (result.error) throw result.error;
-if (result.signal) process.kill(process.pid, result.signal);
-process.exit(result.status === null ? 1 : result.status);
+"use strict";
+
+const path = require("node:path");
+const childProcess = require("node:child_process");
+const { resolveC2cBinary } = require("..");
+
+function executableForWrapper(argv1) {
+  const basename = path.basename(argv1 || "c2c");
+  return basename.startsWith("c2c-deliver-inbox") ? "c2c-deliver-inbox" : "c2c";
+}
+
+function main() {
+  const executable = executableForWrapper(process.argv[1]);
+  let binary;
+  try {
+    binary = resolveC2cBinary({ selfPath: __filename, executable });
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+
+  const result = childProcess.spawnSync(binary, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  if (result.error) {
+    console.error(`failed to execute ${binary}: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    process.exit(1);
+  }
+
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+main();

package/index.js

@@ -1,70 +1,186 @@
-const fs = require("fs");
-const path = require("path");
-const { spawnSync } = require("child_process");
-
-const PACKAGE_BY_PLATFORM = {
-  "linux-x64": "@clanker-code/c2c-linux-x64",
-  "linux-arm64": "@clanker-code/c2c-linux-arm64",
-  "darwin-x64": "@clanker-code/c2c-darwin-x64",
-  "darwin-arm64": "@clanker-code/c2c-darwin-arm64",
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const TARGETS = {
+  "linux-x64": {
+    packageName: "@clanker-code/c2c-linux-x64",
+  },
+  "linux-arm64": {
+    packageName: "@clanker-code/c2c-linux-arm64",
+  },
+  "darwin-x64": {
+    packageName: "@clanker-code/c2c-darwin-x64",
+  },
+  "darwin-arm64": {
+    packageName: "@clanker-code/c2c-darwin-arm64",
+  },
 };
 
-function isExecutable(file) {
+const EXECUTABLES = new Set(["c2c", "c2c-deliver-inbox"]);
+
+function normalizeExecutable(executable = "c2c") {
+  if (!EXECUTABLES.has(executable)) {
+    throw new Error(`unsupported c2c executable: ${executable}`);
+  }
+  return executable;
+}
+
+function envOverrideName(executable) {
+  return executable === "c2c-deliver-inbox" ? "C2C_DELIVER_INBOX_BIN" : "C2C_BIN";
+}
+
+function canExecute(file) {
   try {
     fs.accessSync(file, fs.constants.X_OK);
     return true;
-  } catch (_) {
+  } catch {
     return false;
   }
 }
 
-function pathEntries() {
-  return (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+function sameFile(left, right) {
+  if (!left || !right) {
+    return false;
+  }
+
+  try {
+    return fs.realpathSync(left) === fs.realpathSync(right);
+  } catch {
+    return path.resolve(left) === path.resolve(right);
+  }
 }
 
-function resolveOnPath(name) {
-  let currentWrapper = null;
+function pathCandidates(env, platform, executable) {
+  const pathValue = env.PATH || "";
+  const dirs = pathValue.split(path.delimiter).filter(Boolean);
+  const names =
+    platform === "win32"
+      ? [`${executable}.exe`, `${executable}.cmd`, `${executable}.bat`, executable]
+      : [executable];
+
+  return dirs.flatMap((dir) => names.map((name) => path.join(dir, name)));
+}
+
+function looksLikeSelfNpmShim(candidate, selfPath) {
+  if (!candidate.match(/\.(cmd|bat)$/i)) {
+    return false;
+  }
+
   try {
-    currentWrapper = process.argv[1] ? fs.realpathSync(process.argv[1]) : null;
-  } catch (_) {}
-  for (const dir of pathEntries()) {
-    const candidate = path.join(dir, name);
-    if (!isExecutable(candidate)) continue;
-    try {
-      if (currentWrapper && fs.realpathSync(candidate) === currentWrapper) continue;
-    } catch (_) {}
-    return candidate;
+    const body = fs.readFileSync(candidate, "utf8");
+    const normalizedBody = body.replace(/\\/g, "/").toLowerCase();
+    const normalizedSelf = selfPath.replace(/\\/g, "/").toLowerCase();
+    return normalizedBody.includes(normalizedSelf) || normalizedBody.includes("c2c-js-wrapper.js");
+  } catch {
+    return false;
+  }
+}
+
+function findSystemExecutable(env, selfPath, platform, executable) {
+  for (const candidate of pathCandidates(env, platform, executable)) {
+    if (canExecute(candidate) && !sameFile(candidate, selfPath) && !looksLikeSelfNpmShim(candidate, selfPath)) {
+      return candidate;
+    }
   }
   return null;
 }
 
-function resolvePlatformPackage() {
-  const key = `${process.platform}-${process.arch}`;
-  const pkg = PACKAGE_BY_PLATFORM[key];
-  if (!pkg) return null;
+function platformTarget(platform, arch) {
+  return TARGETS[`${platform}-${arch}`] || null;
+}
+
+function platformPackageName(platform = process.platform, arch = process.arch) {
+  const target = platformTarget(platform, arch);
+  return target ? target.packageName : null;
+}
+
+function resolvePlatformPackage(target, requireFrom, executable) {
   try {
-    return require.resolve(`${pkg}/bin/${process.platform === "win32" ? "c2c.exe" : "c2c"}`);
-  } catch (_) {
-    return null;
+    const packageJson = require.resolve(`${target.packageName}/package.json`, {
+      paths: [requireFrom],
+    });
+    return path.join(path.dirname(packageJson), "bin", executable);
+  } catch (error) {
+    const directRoot = findDirectPackageRoot(requireFrom, target, executable);
+    if (directRoot) {
+      return path.join(directRoot, "bin", executable);
+    }
+    throw error;
+  }
+}
+
+function findDirectPackageRoot(requireFrom, target, executable) {
+  let current = path.resolve(requireFrom);
+  const parts = target.packageName.split("/");
+
+  while (true) {
+    const candidate = path.join(current, "node_modules", ...parts);
+    const bin = path.join(candidate, "bin", executable);
+    if (fs.existsSync(bin)) {
+      return candidate;
+    }
+
+    const next = path.dirname(current);
+    if (next === current) {
+      return null;
+    }
+    current = next;
   }
 }
 
-function resolveC2cBinary() {
-  if (process.env.C2C_BIN) {
-    if (!isExecutable(process.env.C2C_BIN)) {
-      throw new Error(`C2C_BIN is set but is not executable: ${process.env.C2C_BIN}`);
+function resolveC2cBinary(options = {}) {
+  const executable = normalizeExecutable(options.executable || "c2c");
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+  const requireFrom = options.requireFrom || __dirname;
+  const selfPath = options.selfPath || path.join(__dirname, "bin", "c2c-js-wrapper.js");
+  const overrideName = envOverrideName(executable);
+
+  if (env[overrideName]) {
+    if (!canExecute(env[overrideName])) {
+      throw new Error(`${overrideName} is set but is not executable: ${env[overrideName]}`);
+    }
+    return env[overrideName];
+  }
+
+  const target = platformTarget(platform, arch);
+  let platformError = null;
+
+  if (target) {
+    try {
+      const resolved = resolvePlatformPackage(target, requireFrom, executable);
+      if (canExecute(resolved)) {
+        return resolved;
+      }
+      throw new Error(`resolved package binary is not executable: ${resolved}`);
+    } catch (error) {
+      platformError = error;
     }
-    return process.env.C2C_BIN;
   }
-  const system = resolveOnPath(process.platform === "win32" ? "c2c.exe" : "c2c");
-  if (system) return system;
-  const packaged = resolvePlatformPackage();
-  if (packaged && isExecutable(packaged)) return packaged;
+
+  const systemExecutable = findSystemExecutable(env, selfPath, platform, executable);
+  if (systemExecutable) {
+    return systemExecutable;
+  }
+
+  if (!target) {
+    throw new Error(
+      `No c2c npm binary package is available for ${platform}-${arch}. ` +
+        `Install ${executable} system-wide, choose a supported platform, or set ${overrideName} to a ${executable} executable.`
+    );
+  }
+
   throw new Error(
-    `No c2c binary is available for ${process.platform}-${process.arch}. ` +
-    "Install c2c system-wide, install a supported @clanker-code/c2c platform package, " +
-    "or set C2C_BIN=/path/to/c2c."
+    `Unable to find executable ${executable} in ${target.packageName} for ${platform}-${arch}. ` +
+      `Install @clanker-code/c2c with optional dependencies enabled, install ${executable} system-wide, or set ${overrideName}. ` +
+      `Cause: ${platformError.message}`
   );
 }
 
-module.exports = { resolveC2cBinary };
+module.exports = {
+  resolveC2cBinary,
+  _platformPackageName: platformPackageName,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clanker-code/c2c",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "description": "Resolver and CLI wrapper for the c2c agent messaging binary",
   "license": "MIT",
   "repository": {
@@ -9,16 +9,17 @@
   },
   "main": "index.js",
   "bin": {
-    "c2c": "bin/c2c-js-wrapper.js"
+    "c2c": "bin/c2c-js-wrapper.js",
+    "c2c-deliver-inbox": "bin/c2c-deliver-inbox-js-wrapper.js"
   },
   "files": [
     "bin/",
     "index.js"
   ],
   "optionalDependencies": {
-    "@clanker-code/c2c-linux-x64": "0.8.5",
-    "@clanker-code/c2c-linux-arm64": "0.8.5",
-    "@clanker-code/c2c-darwin-x64": "0.8.5",
-    "@clanker-code/c2c-darwin-arm64": "0.8.5"
+    "@clanker-code/c2c-linux-x64": "0.8.6",
+    "@clanker-code/c2c-linux-arm64": "0.8.6",
+    "@clanker-code/c2c-darwin-x64": "0.8.6",
+    "@clanker-code/c2c-darwin-arm64": "0.8.6"
   }
 }