@raysonmeng/agentbridge 0.1.5 → 0.1.7

package/scripts/install-safety.cjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+/**
+ * Shared install-time safety checks.
+ *
+ * This intentionally stays CommonJS so both the ESM local installer and npm's
+ * CommonJS postinstall hook can use the same stop/verify behavior.
+ */
+
+const { spawnSync } = require("node:child_process");
+const { existsSync, readFileSync, statSync } = require("node:fs");
+const path = require("node:path");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+
+const REQUIRED_ARTIFACTS = Object.freeze([
+  "dist/cli.js",
+  "dist/daemon.js",
+  ".claude-plugin/marketplace.json",
+  "plugins/agentbridge/.claude-plugin/plugin.json",
+  "plugins/agentbridge/.mcp.json",
+  "plugins/agentbridge/README.md",
+  "plugins/agentbridge/commands/init.md",
+  "plugins/agentbridge/hooks/hooks.json",
+  "plugins/agentbridge/scripts/health-check.sh",
+  "plugins/agentbridge/scripts/plugin-update-notice.mjs",
+  "plugins/agentbridge/server/bridge-server.js",
+  "plugins/agentbridge/server/daemon.js",
+  "package.json",
+  "README.md",
+  "scripts/install-safety.cjs",
+  "scripts/postinstall.cjs",
+]);
+
+function quote(arg) {
+  return /^[A-Za-z0-9_@%+=:,./<>-]+$/.test(arg) ? arg : JSON.stringify(arg);
+}
+
+function commandLine(cmd, args) {
+  return [cmd, ...args].map(quote).join(" ");
+}
+
+function fail(message, details = []) {
+  process.stderr.write(`install-safety: ${message}\n`);
+  for (const detail of details) {
+    process.stderr.write(`  - ${detail}\n`);
+  }
+  process.exit(1);
+}
+
+function readPackageJson() {
+  return JSON.parse(readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf-8"));
+}
+
+function requiredPackagePaths() {
+  const pkg = readPackageJson();
+  const binTargets = Object.values(pkg.bin ?? {});
+  return [...new Set([...REQUIRED_ARTIFACTS, ...binTargets])];
+}
+
+function buildStopCommand() {
+  const sourceCli = path.join(PACKAGE_ROOT, "src", "cli.ts");
+  const bundledCli = path.join(PACKAGE_ROOT, "dist", "cli.js");
+  if (existsSync(sourceCli)) return ["bun", ["run", "src/cli.ts", "kill", "--all"]];
+  return ["bun", ["run", bundledCli, "kill", "--all"]];
+}
+
+function agentBridgeInstallEnv(baseEnv = process.env) {
+  const env = { ...baseEnv };
+  for (const key of Object.keys(env)) {
+    if (key.startsWith("AGENTBRIDGE_")) delete env[key];
+  }
+  delete env.CODEX_WS_PORT;
+  delete env.CODEX_PROXY_PORT;
+  return env;
+}
+
+function stopRunningAgentBridge(options = {}) {
+  const { dryRun = false, bestEffort = false } = options;
+  const [cmd, args] = buildStopCommand();
+  if (dryRun) {
+    process.stdout.write(`$ ${commandLine(cmd, args)}  # stop running AgentBridge daemons/TUIs\n`);
+    return { status: 0 };
+  }
+
+  process.stdout.write(`$ ${commandLine(cmd, args)}\n`);
+  const res = spawnSync(cmd, args, {
+    cwd: PACKAGE_ROOT,
+    env: agentBridgeInstallEnv(),
+    stdio: "inherit",
+  });
+
+  if (res.error || res.status !== 0) {
+    const message = res.error
+      ? `failed to start stop command: ${res.error.message}`
+      : `stop command exited with ${res.status}`;
+    if (bestEffort) {
+      process.stdout.write(`install-safety: ${message}; continuing because this hook is best-effort\n`);
+      return res;
+    }
+    fail(message);
+  }
+  return res;
+}
+
+function verifyBuiltArtifacts() {
+  const missing = [];
+  const empty = [];
+  const notExecutable = [];
+  const pkg = readPackageJson();
+  const required = requiredPackagePaths();
+  const binTargets = new Set(Object.values(pkg.bin ?? {}));
+
+  for (const rel of required) {
+    const absolute = path.join(PACKAGE_ROOT, rel);
+    if (!existsSync(absolute)) {
+      missing.push(rel);
+      continue;
+    }
+    const stat = statSync(absolute);
+    if (stat.size <= 0) empty.push(rel);
+    if (binTargets.has(rel) && (stat.mode & 0o111) === 0) {
+      notExecutable.push(rel);
+    }
+  }
+
+  const problems = [
+    ...missing.map((rel) => `missing: ${rel}`),
+    ...empty.map((rel) => `empty: ${rel}`),
+    ...notExecutable.map((rel) => `not executable: ${rel}`),
+  ];
+  if (problems.length > 0) {
+    fail("built artifact verification failed", problems);
+  }
+
+  process.stdout.write(`install-safety: verified ${required.length} built artifact(s)\n`);
+}
+
+function verifyTarball(tarballPath) {
+  if (!tarballPath) fail("verify-tarball requires a tarball path");
+  if (!existsSync(tarballPath)) fail(`tarball does not exist: ${tarballPath}`);
+
+  const res = spawnSync("tar", ["-tf", tarballPath], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (res.error) fail(`failed to inspect tarball: ${res.error.message}`);
+  if (res.status !== 0) {
+    fail(`tar -tf failed with ${res.status}`, [res.stderr?.trim()].filter(Boolean));
+  }
+
+  const packed = new Set(
+    res.stdout
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => line.replace(/^package\//, "")),
+  );
+  const required = requiredPackagePaths();
+  const missing = required.filter((rel) => !packed.has(rel));
+  if (missing.length > 0) {
+    fail("packed tarball is missing required artifact(s)", missing);
+  }
+
+  process.stdout.write(`install-safety: verified ${required.length} artifact(s) in ${tarballPath}\n`);
+}
+
+function usage() {
+  process.stderr.write(`Usage:
+  node scripts/install-safety.cjs stop-running [--dry-run] [--best-effort]
+  node scripts/install-safety.cjs verify-built
+  node scripts/install-safety.cjs verify-tarball <tarball>
+`);
+}
+
+function main() {
+  const [command, ...args] = process.argv.slice(2);
+  if (command === "stop-running") {
+    stopRunningAgentBridge({
+      dryRun: args.includes("--dry-run"),
+      bestEffort: args.includes("--best-effort"),
+    });
+    return;
+  }
+  if (command === "verify-built") {
+    verifyBuiltArtifacts();
+    return;
+  }
+  if (command === "verify-tarball") {
+    verifyTarball(args[0]);
+    return;
+  }
+  usage();
+  process.exit(1);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  REQUIRED_ARTIFACTS,
+  agentBridgeInstallEnv,
+  commandLine,
+  requiredPackagePaths,
+  stopRunningAgentBridge,
+  verifyBuiltArtifacts,
+  verifyTarball,
+};

package/scripts/postinstall.cjs

@@ -1,18 +1,86 @@
 #!/usr/bin/env node
 
 /**
- * postinstall check: verify that Bun is available.
- * This runs after `npm install -g agentbridge` to warn users early
- * rather than letting them hit a cryptic "bun: No such file or directory".
+ * postinstall: verify Bun, register marketplace, install plugin.
+ * Runs after `npm install -g @raysonmeng/agentbridge`.
+ *
+ * All steps are best-effort — a failure here does not block the npm install.
+ * Users can always fall back to `abg init` for manual setup.
  */
 
 const { execFileSync } = require("child_process");
+const { existsSync } = require("fs");
+const path = require("path");
+const { stopRunningAgentBridge } = require("./install-safety.cjs");
 
-try {
-  const version = execFileSync("bun", ["--version"], { encoding: "utf-8" }).trim();
-  console.log(`\x1b[32m✔\x1b[0m AgentBridge: Bun ${version} detected.`);
-} catch {
-  console.warn(`
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const MARKETPLACE_NAME = "agentbridge";
+const PLUGIN_NAME = "agentbridge";
+// Every external command gets a hard timeout: postinstall runs inside the
+// user's `npm install`, and a hung `claude` CLI (auth prompt, broken update)
+// previously hung the whole install with it. Timeouts fall through to the
+// existing warn-and-continue paths (`abg init` is always the fallback).
+const VERSION_PROBE_TIMEOUT_MS = 10_000;
+const PLUGIN_STEP_TIMEOUT_MS = 30_000;
+
+/**
+ * Declarative opt-out of the marketplace/plugin registration steps (CI image
+ * builds, air-gapped installs) — symmetric with AGENTBRIDGE_POSTINSTALL_STOP.
+ */
+function skipPluginRegistration(env = process.env) {
+  return env.AGENTBRIDGE_POSTINSTALL_PLUGIN === "0";
+}
+/**
+ * Decide whether postinstall should stop ALL running AgentBridge pairs.
+ *
+ * Stop-the-world is destructive (it kills every running daemon/TUI), so it is
+ * gated to INTENTIONAL global self-installs only. The intentional installer
+ * (scripts/install-global.mjs) already calls install-safety stop-running
+ * directly, so postinstall only needs to react to an explicit global signal.
+ *
+ * Pure + injectable for unit testing.
+ *
+ * @param {{ env?: NodeJS.ProcessEnv, hasSourceCli?: boolean }} [opts]
+ * @returns {boolean}
+ */
+function shouldStopRunningDaemons({
+  env = process.env,
+  hasSourceCli = existsSync(path.join(PACKAGE_ROOT, "src", "cli.ts")),
+} = {}) {
+  // hasSourceCli is accepted for symmetry/future use; intentionally unused so
+  // that a packed (no-src) install no longer triggers stop-the-world on its own.
+  void hasSourceCli;
+  if (env.AGENTBRIDGE_POSTINSTALL_STOP === "0") return false;
+  if (env.AGENTBRIDGE_POSTINSTALL_STOP === "1") return true;
+  if (env.npm_config_global === "true") return true;
+  if (env.npm_config_location === "global") return true;
+  return false;
+}
+
+function runPostinstall() {
+  const dryRun = process.argv.includes("--dry-run");
+
+  if (dryRun) {
+    stopRunningAgentBridge({ dryRun: true });
+    console.log("$ claude --version");
+    console.log(`$ claude plugin marketplace add ${PACKAGE_ROOT}`);
+    console.log(`$ claude plugin install ${PLUGIN_NAME}@${MARKETPLACE_NAME}`);
+    process.exit(0);
+  }
+
+  // Step 1: Check Bun
+  let bunOk = false;
+  try {
+    const version = execFileSync("bun", ["--version"], { encoding: "utf-8", timeout: VERSION_PROBE_TIMEOUT_MS }).trim();
+    console.log(`\x1b[32m✔\x1b[0m AgentBridge: Bun ${version} detected.`);
+    bunOk = true;
+  } catch (e) {
+    // A timeout means bun exists but hung — "install Bun" advice would be
+    // misleading there; tell the truth and point at the abg init fallback.
+    if (e && e.code === "ETIMEDOUT") {
+      console.warn(`\x1b[33m⚠\x1b[0m AgentBridge: \`bun --version\` timed out — run \`abg init\` after the install completes.`);
+    } else {
+      console.warn(`
 \x1b[33m⚠ AgentBridge requires Bun (v1.0+) as its runtime.\x1b[0m
 
 The CLI was installed, but it won't work without Bun.
@@ -22,6 +90,58 @@ Install Bun with:
 
 Then restart your terminal and run:
 
-  abg --help
+  abg init
 `);
+    }
+  }
+
+  // Step 2: Register marketplace + install plugin (requires Claude Code)
+  if (bunOk && !skipPluginRegistration()) {
+    if (shouldStopRunningDaemons()) {
+      try {
+        stopRunningAgentBridge({ bestEffort: true });
+      } catch {
+        console.log(`\x1b[33m⚠\x1b[0m AgentBridge: could not stop running daemons — run \`abg kill --all\` before relying on this install.`);
+      }
+    } else {
+      console.log(`\x1b[33m⚠\x1b[0m AgentBridge: not an explicit global self-install — leaving running daemons untouched (use \`abg kill --all\` or install-global to stop).`);
+    }
+
+    try {
+      execFileSync("claude", ["--version"], { encoding: "utf-8", timeout: VERSION_PROBE_TIMEOUT_MS });
+    } catch {
+      console.log(`\x1b[33m⚠\x1b[0m AgentBridge: Claude Code not found — skipping plugin install.`);
+      console.log(`  After installing Claude Code, run: abg init`);
+      process.exit(0);
+    }
+
+    try {
+      execFileSync("claude", ["plugin", "marketplace", "add", PACKAGE_ROOT], {
+        stdio: "pipe",
+        timeout: PLUGIN_STEP_TIMEOUT_MS,
+      });
+      console.log(`\x1b[32m✔\x1b[0m AgentBridge: Marketplace registered.`);
+    } catch (e) {
+      console.log(`\x1b[33m⚠\x1b[0m AgentBridge: Marketplace registration failed — run \`abg init\` to retry.`);
+      process.exit(0);
+    }
+
+    try {
+      execFileSync("claude", ["plugin", "install", `${PLUGIN_NAME}@${MARKETPLACE_NAME}`], {
+        stdio: "pipe",
+        timeout: PLUGIN_STEP_TIMEOUT_MS,
+      });
+      console.log(`\x1b[32m✔\x1b[0m AgentBridge: Plugin installed. Run \`abg claude\` to start.`);
+    } catch (e) {
+      console.log(`\x1b[33m⚠\x1b[0m AgentBridge: Plugin install failed — run \`abg init\` to retry.`);
+    }
+  }
+}
+
+module.exports = { shouldStopRunningDaemons, skipPluginRegistration };
+
+// Only run install side effects when invoked directly (not when require()'d
+// from a unit test).
+if (require.main === module) {
+  runPostinstall();
 }