blun-king-cli 9.1.561 → 9.1.562

package/agent-spine-plugin/scripts/check-hosts.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFile, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+async function json(root, path) {
+  return JSON.parse(await readFile(resolve(root, path), "utf8"));
+}
+
+function expand(value, variable, root) {
+  assert(typeof value === "string" && value.length > 0, "host command values must be non-empty strings");
+  return value.split(`\${${variable}}`).join(root);
+}
+
+async function validateEntrypoint(root, value) {
+  const target = resolve(value);
+  const within = relative(root, target);
+  assert(within && !within.startsWith("..") && !isAbsolute(within), "MCP entrypoint must remain inside the plugin");
+  const metadata = await stat(target);
+  assert(metadata.isFile(), "MCP entrypoint must be a regular file");
+}
+
+function validateHooks(root, hooks, { required, commandRoot }) {
+  assert(hooks && typeof hooks === "object" && !Array.isArray(hooks), "hook bundle is missing");
+  assert(Object.keys(hooks).every((key) => ["description", "hooks"].includes(key)), "hook bundle contains unsupported top-level metadata");
+  assert(hooks.description && typeof hooks.description === "string", "hook bundle description is missing");
+  for (const event of required) {
+    const registrations = hooks.hooks?.[event];
+    assert(Array.isArray(registrations) && registrations.length === 1, `${event} must have exactly one registration`);
+    assert(Array.isArray(registrations[0].hooks) && registrations[0].hooks.length === 1, `${event} must have exactly one hook command`);
+    const command = registrations[0].hooks[0];
+    assert(command.type === "command", `${event} must use a command hook`);
+    assert(command.command === `node "\${${commandRoot}}/src/hook.js"`, `${event} must use the bundled lifecycle adapter`);
+    assert(Number.isInteger(command.timeout) && command.timeout > 0 && command.timeout <= 15, `${event} timeout is unsafe`);
+  }
+  const extras = Object.keys(hooks.hooks || {}).filter((event) => !required.includes(event));
+  assert(extras.length === 0, `unknown hook events: ${extras.join(", ")}`);
+  return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
+}
+
+function validateBlunHooks(root, hooks) {
+  const required = [
+    "SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse",
+    "PreCompact", "PostCompact", "Stop", "SubagentStop"
+  ];
+  assert(Array.isArray(hooks), "BLUN hook bundle is missing");
+  assert(hooks.length === required.length, "BLUN must register exactly one command per lifecycle event");
+  assert(JSON.stringify(hooks.map(({ event }) => event)) === JSON.stringify(required),
+    "BLUN lifecycle events must remain complete and ordered");
+  for (const event of required) {
+    const registrations = hooks.filter((hook) => hook.event === event);
+    assert(registrations.length === 1, `${event} must have exactly one BLUN registration`);
+    const command = registrations[0];
+    assert(command.command === 'node "./src/hook.js"', `${event} must use the bundled BLUN lifecycle adapter`);
+    assert(Number.isInteger(command.timeout) && command.timeout > 0 && command.timeout <= 15, `${event} BLUN timeout is unsafe`);
+  }
+  return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
+}
+
+async function initializeServer({ label, root, variable, server, version }) {
+  assert(server && typeof server === "object" && !Array.isArray(server), `${label} MCP registration is missing`);
+  assert(server.command === "node", `${label} MCP registration must use the Node.js runtime`);
+  assert(Array.isArray(server.args) && server.args.length === 1, `${label} MCP registration must name exactly one entrypoint`);
+  const command = process.execPath;
+  const args = server.args.map((value) => {
+    const expanded = expand(value, variable, root);
+    return isAbsolute(expanded) ? expanded : resolve(root, expanded);
+  });
+  assert(!args.some((value) => value.includes("${")), `${label} MCP registration contains an unresolved variable`);
+  await validateEntrypoint(root, args[0]);
+
+  return await new Promise((resolveResult, reject) => {
+    const child = spawn(command, args, {
+      cwd: root,
+      env: { ...process.env, CLAUDE_PLUGIN_ROOT: root, PLUGIN_ROOT: root },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const settle = () => {
+        if (error) reject(error);
+        else resolveResult(value);
+      };
+      if (child.exitCode !== null || child.signalCode !== null) return settle();
+      child.once("close", settle);
+      child.kill();
+    };
+    const timer = setTimeout(() => {
+      finish(new Error(`${label} MCP initialize timed out${stderr ? `: ${stderr.trim()}` : ""}`));
+    }, 3000);
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      const newline = stdout.indexOf("\n");
+      if (newline < 0) return;
+      try {
+        const message = JSON.parse(stdout.slice(0, newline));
+        assert(message.id === 1, `${label} MCP initialize returned the wrong request id`);
+        assert(message.result?.serverInfo?.name === "agent-spine", `${label} MCP initialize returned the wrong server identity`);
+        assert(message.result?.serverInfo?.version === version, `${label} MCP initialize returned a stale server version`);
+        finish(null, { label, server: message.result.serverInfo.name, entrypoint: relative(root, args[0]) });
+      } catch (error) {
+        finish(error);
+      }
+    });
+    child.once("error", (error) => finish(error));
+    child.once("close", (code) => {
+      if (!settled) finish(new Error(`${label} MCP server exited with ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
+    });
+    // A real MCP host keeps stdio open after initialization. Closing stdin
+    // here let macOS and Windows terminate the server before its queued reply.
+    child.stdin.write(`${JSON.stringify({
+      jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18" }
+    })}\n`);
+  });
+}
+
+export async function checkHosts(root = process.cwd()) {
+  root = resolve(root);
+  const [pkg, blunManifest, claudeManifest, claudeMcp, codexManifest, claudeHooks, codexHooks, hookVersion] = await Promise.all([
+    json(root, "package.json"),
+    json(root, "blun.plugin.json"),
+    json(root, ".claude-plugin/plugin.json"),
+    json(root, ".mcp.json"),
+    json(root, ".codex-plugin/plugin.json"),
+    json(root, "hooks/hooks.json"),
+    json(root, "hooks/codex.json"),
+    json(root, "hooks/version.json")
+  ]);
+  assert(blunManifest.version === pkg.version && claudeManifest.version === pkg.version && codexManifest.version === pkg.version,
+    "host manifests must use the package cache version");
+  assert(hookVersion.schema === "agentspine.hook-bundle/v1" && hookVersion.version === pkg.version,
+    "hook bundle version must match the package cache version");
+  assert(hookVersion.contract === "agentspine.preflight/v2", "hook bundle preflight contract is missing");
+  assert(pkg.bin?.["agentspine-worker"] === "./src/worker.js", "package must register exactly one gateway worker entrypoint");
+  await validateEntrypoint(root, resolve(root, pkg.bin["agentspine-worker"]));
+  assert(claudeManifest.mcpServers === "./.mcp.json", "Claude manifest must explicitly reference ./.mcp.json");
+  assert(claudeManifest.hooks === undefined, "default hooks/hooks.json must not also be registered through a supplemental manifest path");
+  assert(codexManifest.hooks === undefined, "Codex manifest must omit unsupported hook registration fields");
+  assert(claudeMcp.mcpServers && Object.keys(claudeMcp.mcpServers).length === 1, "Claude MCP file must contain one mcpServers registration");
+  assert(codexManifest.mcpServers && Object.keys(codexManifest.mcpServers).length === 1, "Codex manifest must contain one MCP registration");
+  const commonEvents = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PreCompact", "PostCompact", "Stop", "SubagentStop"];
+  const claudeHookInventory = validateHooks(root, claudeHooks, {
+    required: [...commonEvents, "InstructionsLoaded"], commandRoot: "CLAUDE_PLUGIN_ROOT"
+  });
+  const codexHookInventory = validateHooks(root, codexHooks, { required: commonEvents, commandRoot: "PLUGIN_ROOT" });
+  const blunHookInventory = validateBlunHooks(root, blunManifest.hooks);
+  const registrations = await Promise.all([
+    initializeServer({ label: "blun", root, variable: "BLUN_PLUGIN_ROOT", server: blunManifest.mcpServers["agent-spine"], version: pkg.version }),
+    initializeServer({ label: "claude", root, variable: "CLAUDE_PLUGIN_ROOT", server: claudeMcp.mcpServers["agent-spine"], version: pkg.version }),
+    initializeServer({ label: "codex", root, variable: "PLUGIN_ROOT", server: codexManifest.mcpServers["agent-spine"], version: pkg.version })
+  ]);
+  return {
+    ok: true, root, version: pkg.version, registrations,
+    hooks: { blun: blunHookInventory, claude: claudeHookInventory, codex: codexHookInventory },
+    hookDiscovery: {
+      blun: "plugin-manifest", claude: "default-hooks-directory", codex: "bundled-host-adapter",
+      trust: "host-user-required", liveTrustVerified: false
+    },
+    worker: { entrypoint: pkg.bin["agentspine-worker"], setsPerInstall: 1 },
+    exactlyOnce: { mcpServersPerHost: 1, hookSetsPerHost: 1, workerSetsPerInstall: 1 },
+    authority: "registration-check-only"
+  };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let root = process.cwd();
+  let pretty = false;
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--root") root = args[++index];
+    else if (args[index] === "--json") pretty = true;
+    else throw new Error(`unknown host-check argument: ${args[index]}`);
+  }
+  process.stdout.write(`${JSON.stringify(await checkHosts(root), null, pretty ? 2 : 0)}\n`);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+  main().catch((error) => {
+    process.stderr.write(`AgentSpine host check failed: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.561",
+  "version": "9.1.562",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {
@@ -45,6 +45,7 @@
     "agent-spine-plugin/hooks/",
     "agent-spine-plugin/LICENSE",
     "agent-spine-plugin/package.json",
+    "agent-spine-plugin/scripts/check-hosts.js",
     "agent-spine-plugin/skill/",
     "agent-spine-plugin/skills/",
     "agent-spine-plugin/src/",