@ganglia/cli 0.9.190 → 0.9.192

package/bin/gng.js

@@ -6,8 +6,8 @@
 // silently. At runtime we locate that package and spawn its binary.
 
 const { spawnSync } = require('child_process');
-const path = require('path');
 
+const WRAPPER_VERSION = require('../package.json').version;
 const PLATFORM = `${process.platform}-${process.arch}`;
 
 const PKG = {
@@ -41,6 +41,171 @@ try {
   process.exit(1);
 }
 
+const argv = process.argv.slice(2);
+
+// ── Stale-binary notice ────────────────────────────────────────────────────
+// The wrapper is pure JS and republishes on every release; a platform package
+// only republishes when that platform's binary is rebuilt (today: linux). So
+// `npx @ganglia/cli@latest` can hand a user a wrapper at X and a binary from
+// an older release — which reads as "npm keeps installing the old version"
+// with nothing on screen to explain it. Say it out loud, once, on the
+// commands a human is watching (never on the stdio protocols).
+const PROTOCOL_CMDS = new Set(['mcp', 'serve', 'daemon', 'watch']);
+let binaryVersion = null;
+try {
+  binaryVersion = require(`${PKG}/package.json`).version;
+} catch (_) { /* version unknown — skip the notice */ }
+
+if (binaryVersion && binaryVersion !== WRAPPER_VERSION && !PROTOCOL_CMDS.has(argv[0])) {
+  console.error(
+    `[ganglia] ${PKG} is at ${binaryVersion}, but @ganglia/cli is ${WRAPPER_VERSION} — ` +
+    `no ${WRAPPER_VERSION} binary has been published for ${PLATFORM} yet, so \`gng --version\` ` +
+    `reports ${binaryVersion}.`,
+  );
+}
+
+// ── install / uninstall: register through the claude CLI from here ─────────
+// `gng install` shells out to `claude mcp add`, and where `--scope` may sit
+// in that command line is not stable across claude releases: 2.1.x parses
+// `add <name> <cmd> --scope user -- <args>` but rejects the same flag placed
+// before the positionals ("error: unknown option '--scope'") whenever a `--`
+// tail is present; other builds want the flags first. The binary is the part
+// we can't rebuild for every platform, so own the registration here and try
+// both orders instead of betting the install on one of them.
+if ((argv[0] === 'install' || argv[0] === 'uninstall') && !argv.includes('-h') && !argv.includes('--help')) {
+  process.exit(argv[0] === 'install' ? runInstall(argv) : runUninstall(argv));
+}
+
+function optValue(args, name, fallback) {
+  const i = args.indexOf(`--${name}`);
+  if (i !== -1 && args[i + 1] !== undefined) return args[i + 1];
+  const inline = args.find((a) => a.startsWith(`--${name}=`));
+  return inline ? inline.slice(name.length + 3) : fallback;
+}
+
+function claude(args) {
+  return spawnSync('claude', args, { encoding: 'utf8', env: process.env });
+}
+
+function claudeMissing(r) {
+  return r.error && r.error.code === 'ENOENT';
+}
+
+function help(args) {
+  const r = spawnSync(binary, args, { encoding: 'utf8', env: process.env });
+  return `${r.stdout || ''}${r.stderr || ''}`;
+}
+
+// The binary's own MCP entry point: older builds took `--redis-port`, current
+// ones `--graph-port`. Ask the binary we are about to register which it knows.
+function portFlag() {
+  return help(['--help']).includes('--graph-port') ? '--graph-port' : '--redis-port';
+}
+
+// Path form: current builds take the project dir positionally, older ones only
+// via `-p`. Prefer the positional — `-p` anywhere on the line breaks claude's
+// own parse (see below).
+function pathArgs() {
+  return /Usage: gng mcp .*\[PATH\]/.test(help(['mcp', '--help'])) ? ['.'] : ['-p', '.'];
+}
+
+function runInstall(args) {
+  const global = args.includes('--global');
+  const port = optValue(args, 'redis-port', '6381');
+  const compress = optValue(args, 'compress', 'smart');
+  const scopeArgs = global ? ['--scope', 'user'] : [];
+
+  console.log('');
+  console.log('  Ganglia · MCP Install');
+  console.log('');
+  console.log(`  scope        ${global ? 'global (all projects)' : 'current project'}`);
+  console.log(`  compression  ${compress}`);
+  console.log('');
+
+  // Drop any existing entry first — the current name and the legacy
+  // "code-graph" one — so re-running install is idempotent.
+  for (const name of ['ganglia', 'code-graph']) {
+    const r = claude(['mcp', 'remove', ...scopeArgs, name]);
+    if (claudeMissing(r)) return notFound();
+  }
+
+  // No `-p` in the server's own args: claude scans the whole command line for
+  // its global `-p/--print` flag before `mcp add` parses, and that re-parse
+  // rejects our `--scope` wherever it sits. `gng mcp` takes the project path
+  // positionally (default "."), so a bare `.` does the same job.
+  const serverArgs = ['--', portFlag(), String(port), 'mcp', ...pathArgs(), '--compress', compress];
+
+  // Order 1 works on claude 2.1.x; order 2 is what older builds expect.
+  const forms = [
+    ['mcp', 'add', 'ganglia', binary, ...scopeArgs, ...serverArgs],
+    ['mcp', 'add', ...scopeArgs, 'ganglia', binary, ...serverArgs],
+  ];
+
+  let r;
+  let ok = false;
+  for (const form of forms) {
+    r = claude(form);
+    if (claudeMissing(r)) return notFound();
+    if (r.status !== 0) continue;
+    // A zero exit isn't proof: a CLI that took the flag positionally echoes it
+    // back as part of the server's command line, which means it landed in the
+    // args instead of setting the scope. Undo that and try the other order.
+    if (`${r.stdout || ''}`.includes('--scope')) {
+      claude(['mcp', 'remove', ...scopeArgs, 'ganglia']);
+      continue;
+    }
+    ok = true;
+    break;
+  }
+
+  if (!ok) {
+    const err = `${r.stdout || ''}${r.stderr || ''}`.trim();
+    console.error(`  ✗  Installation failed: ${err}`);
+    console.error('');
+    console.error('  Register the server directly instead (writes ~/.claude.json):');
+    console.error(`    ${binary} register`);
+    console.error('');
+    return 1;
+  }
+
+  console.log('  ✓  MCP server   registered (ganglia)');
+  console.log('');
+  console.log('  Restart your AI client to activate.');
+  console.log('  Then: cd your-project && gng init   (installs per-project hooks)');
+  console.log('');
+  return 0;
+}
+
+function runUninstall(args) {
+  const global = args.includes('--global');
+  const scopeArgs = global ? ['--scope', 'user'] : [];
+
+  console.log('Uninstalling the Ganglia MCP server...');
+  console.log(`  Scope: ${global ? 'global' : 'current project'}`);
+
+  let removed = false;
+  for (const name of ['ganglia', 'code-graph']) {
+    const r = claude(['mcp', 'remove', ...scopeArgs, name]);
+    if (claudeMissing(r)) return notFound();
+    if (r.status === 0) removed = true;
+  }
+
+  console.log(removed
+    ? '\n✓ MCP server uninstalled.'
+    : '\n✓ MCP server was not registered (nothing to remove).');
+
+  // Per-project hooks are the binary's business — it knows which files it
+  // wrote. Best-effort; an old binary without the flag just no-ops.
+  spawnSync(binary, ['hooks', '--off'], { stdio: 'ignore', env: process.env });
+  return 0;
+}
+
+function notFound() {
+  console.error("  ✗  'claude' not found — install the CLI and add it to PATH.");
+  console.error('');
+  return 1;
+}
+
 // spawnSync is used intentionally:
 // - It blocks the Node process synchronously, so there is no event loop
 //   running and no async child/close event handlers can fire.
@@ -49,7 +214,7 @@ try {
 //   the Rust process, which reaps it via libc::waitpid in a background thread.
 // - Do NOT switch to spawn() with a close-handler; that would make the
 //   wrapper exit when any grandchild exits, collapsing the MCP stdio bridge.
-const result = spawnSync(binary, process.argv.slice(2), {
+const result = spawnSync(binary, argv, {
   stdio: 'inherit',
   env: process.env,
   windowsHide: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglia/cli",
-  "version": "0.9.190",
+  "version": "0.9.192",
   "description": "Ganglia — MCP tools + Code Mode for every major AI coding assistant (Claude Code, Cursor, Windsurf, Cline, OpenCode, Continue, Zed, Codex CLI, Gemini CLI)",
   "keywords": [
     "mcp",
@@ -37,8 +37,8 @@
     "arm64"
   ],
   "optionalDependencies": {
-    "@ganglia/cli-linux-x64": "0.9.190",
-    "@ganglia/cli-linux-arm64": "0.9.190",
+    "@ganglia/cli-linux-x64": "0.9.192",
+    "@ganglia/cli-linux-arm64": "0.9.192",
     "@ganglia/cli-darwin-x64": "0.9.78",
     "@ganglia/cli-darwin-arm64": "0.9.78",
     "@ganglia/cli-win32-x64": "0.9.78"