claudemesh-cli 1.0.0-alpha.18 → 1.0.0-alpha.19

package/dist/entrypoints/cli.js

@@ -6341,6 +6341,331 @@ var init_sync = __esm(() => {
   init_facade7();
 });
 
+// src/services/health/check-node-version.ts
+function checkNodeVersion() {
+  const major = parseInt(process.version.slice(1), 10);
+  if (major >= 20)
+    return { name: "node-version", ok: true, message: `Node ${process.version}` };
+  return { name: "node-version", ok: false, message: `Node ${process.version} — requires >= 20` };
+}
+
+// src/services/health/check-claude-binary.ts
+function checkClaudeBinary() {
+  const bin = findClaudeBinary();
+  if (bin)
+    return { name: "claude-binary", ok: true, message: `Found at ${bin}` };
+  return { name: "claude-binary", ok: false, message: "Claude binary not found" };
+}
+var init_check_claude_binary = __esm(() => {
+  init_facade4();
+});
+
+// src/services/health/check-mcp-registered.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+function checkMcpRegistered2() {
+  try {
+    if (!existsSync9(PATHS.CLAUDE_JSON)) {
+      return { name: "mcp-registered", ok: false, message: "~/.claude.json not found" };
+    }
+    const raw = readFileSync7(PATHS.CLAUDE_JSON, "utf-8");
+    const config = JSON.parse(raw);
+    if (config.mcpServers && "claudemesh" in config.mcpServers) {
+      return { name: "mcp-registered", ok: true, message: "MCP server registered" };
+    }
+    return { name: "mcp-registered", ok: false, message: "claudemesh not in mcpServers" };
+  } catch {
+    return { name: "mcp-registered", ok: false, message: "Could not read ~/.claude.json" };
+  }
+}
+var init_check_mcp_registered = __esm(() => {
+  init_paths();
+});
+
+// src/services/health/check-hooks-registered.ts
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
+function checkHooksRegistered2() {
+  try {
+    if (!existsSync10(PATHS.CLAUDE_SETTINGS)) {
+      return { name: "hooks-registered", ok: false, message: "~/.claude/settings.json not found" };
+    }
+    const raw = readFileSync8(PATHS.CLAUDE_SETTINGS, "utf-8");
+    const config = JSON.parse(raw);
+    if (config.hooks) {
+      return { name: "hooks-registered", ok: true, message: "Hooks configured" };
+    }
+    return { name: "hooks-registered", ok: false, message: "No hooks in settings.json" };
+  } catch {
+    return { name: "hooks-registered", ok: false, message: "Could not read settings.json" };
+  }
+}
+var init_check_hooks_registered = __esm(() => {
+  init_paths();
+});
+
+// src/services/health/check-config-perms.ts
+import { existsSync as existsSync11, statSync as statSync4 } from "node:fs";
+function checkConfigPerms() {
+  const configFile = PATHS.CONFIG_FILE;
+  if (!existsSync11(configFile)) {
+    return { name: "config-perms", ok: true, message: "No config file yet (first run)" };
+  }
+  try {
+    const mode = statSync4(configFile).mode & 511;
+    if (mode <= 384) {
+      return { name: "config-perms", ok: true, message: `config.json mode ${mode.toString(8)}` };
+    }
+    return { name: "config-perms", ok: false, message: `config.json mode ${mode.toString(8)} — should be 600` };
+  } catch {
+    return { name: "config-perms", ok: false, message: "Could not stat config.json" };
+  }
+}
+var init_check_config_perms = __esm(() => {
+  init_paths();
+});
+
+// src/services/health/check-keypairs-valid.ts
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
+function checkKeypairsValid() {
+  if (!existsSync12(PATHS.CONFIG_FILE)) {
+    return { name: "keypairs-valid", ok: true, message: "No config (first run)" };
+  }
+  try {
+    const raw = readFileSync9(PATHS.CONFIG_FILE, "utf-8");
+    const config = JSON.parse(raw);
+    const meshes = config.meshes ?? [];
+    if (meshes.length === 0) {
+      return { name: "keypairs-valid", ok: true, message: "No joined meshes" };
+    }
+    for (const m of meshes) {
+      if (!m.pubkey || !HEX_64.test(m.pubkey)) {
+        return { name: "keypairs-valid", ok: false, message: `Invalid pubkey for mesh ${m.slug ?? "unknown"}` };
+      }
+      if (!m.secretKey || !HEX_128.test(m.secretKey)) {
+        return { name: "keypairs-valid", ok: false, message: `Invalid secretKey for mesh ${m.slug ?? "unknown"}` };
+      }
+    }
+    return { name: "keypairs-valid", ok: true, message: `${meshes.length} keypair(s) valid` };
+  } catch {
+    return { name: "keypairs-valid", ok: false, message: "Could not parse config.json" };
+  }
+}
+var HEX_64, HEX_128;
+var init_check_keypairs_valid = __esm(() => {
+  init_paths();
+  HEX_64 = /^[0-9a-f]{64}$/;
+  HEX_128 = /^[0-9a-f]{128}$/;
+});
+
+// src/services/health/facade.ts
+function runAllChecks() {
+  return Object.values(CHECKS).map((fn) => fn());
+}
+var CHECKS;
+var init_facade13 = __esm(() => {
+  init_check_claude_binary();
+  init_check_mcp_registered();
+  init_check_hooks_registered();
+  init_check_config_perms();
+  init_check_keypairs_valid();
+  CHECKS = {
+    "node-version": checkNodeVersion,
+    "claude-binary": checkClaudeBinary,
+    "mcp-registered": checkMcpRegistered2,
+    "hooks-registered": checkHooksRegistered2,
+    "config-perms": checkConfigPerms,
+    "keypairs-valid": checkKeypairsValid
+  };
+});
+
+// src/commands/test.ts
+var exports_test = {};
+__export(exports_test, {
+  runTest: () => runTest
+});
+async function run(name, fn) {
+  const start = Date.now();
+  try {
+    const detail = await fn();
+    results.push({ name, ok: true, detail, ms: Date.now() - start });
+    console.log(`  ${green(icons.check)} ${name.padEnd(18)} ${dim(detail)}`);
+    return true;
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    results.push({ name, ok: false, detail, ms: Date.now() - start });
+    console.log(`  ${red(icons.cross)} ${name.padEnd(18)} ${red(detail)}`);
+    return false;
+  }
+}
+async function runTest() {
+  const started = Date.now();
+  const meshSlug = `test-e2e-${Date.now().toString(36)}`;
+  console.log("");
+  console.log(`  ${bold("claudemesh integration test")}`);
+  console.log(`  ${dim("─".repeat(40))}`);
+  console.log("");
+  const auth = getStoredToken();
+  if (!auth) {
+    console.log(`  ${red(icons.cross)} Not signed in. Run ${bold("claudemesh login")} first.
+`);
+    return EXIT.AUTH_FAILED;
+  }
+  let userId = "";
+  try {
+    const payload = JSON.parse(Buffer.from(auth.session_token.split(".")[1], "base64url").toString());
+    userId = payload.sub ?? "";
+  } catch {}
+  await run("auth", async () => {
+    if (!userId)
+      throw new Error("invalid token");
+    return `signed in as ${auth.user.display_name || auth.user.email}`;
+  });
+  {
+    const checks = runAllChecks();
+    const failed2 = checks.filter((c) => !c.ok);
+    if (failed2.length > 0) {
+      const warns = failed2.map((c) => c.name).join(", ");
+      console.log(`  ${yellow(icons.warn)} ${"doctor".padEnd(18)} ${dim(warns + " (non-blocking)")}`);
+    } else {
+      console.log(`  ${green(icons.check)} ${"doctor".padEnd(18)} ${dim(checks.length + " checks passed")}`);
+    }
+  }
+  await run("crypto", async () => {
+    const kp = await generateKeypair3();
+    const sig = await sign("test-message", kp.secretKey);
+    const valid = await verify("test-message", sig, kp.publicKey);
+    if (!valid)
+      throw new Error("signature verification failed");
+    const tampered = await verify("tampered", sig, kp.publicKey);
+    if (tampered)
+      throw new Error("tampered message should not verify");
+    return "keypair + sign + verify round-trip";
+  });
+  let meshId = "";
+  const createOk = await run("create", async () => {
+    const result = await createMesh2(meshSlug);
+    meshId = result.id;
+    return `created "${result.slug}" (${result.id.slice(0, 8)}…)`;
+  });
+  if (!createOk) {
+    console.log(`
+  ${red("Aborting — mesh creation failed.")}
+`);
+    return EXIT.INTERNAL_ERROR;
+  }
+  await run("list", async () => {
+    const config2 = readConfig();
+    const found = config2.meshes.find((m) => m.slug === meshSlug);
+    if (!found)
+      throw new Error("mesh not in local config");
+    return `found ${meshSlug} in local config`;
+  });
+  await run("server list", async () => {
+    const res = await request({
+      path: `/cli/meshes?user_id=${userId}`,
+      baseUrl: BROKER_HTTP5
+    });
+    const found = res.meshes?.find((m) => m.slug === meshSlug);
+    if (!found)
+      throw new Error("mesh not on server");
+    return `found ${meshSlug} on server (${res.meshes.length} total)`;
+  });
+  const config = readConfig();
+  const meshConfig = config.meshes.find((m) => m.slug === meshSlug);
+  let client = null;
+  if (meshConfig) {
+    await run("connect", async () => {
+      client = new BrokerClient(meshConfig, { displayName: "test-runner" });
+      await client.connect();
+      if (client.status !== "open")
+        throw new Error("status: " + client.status);
+      return "broker connected, hello_ack received";
+    });
+    if (client) {
+      await run("peers", async () => {
+        const peers = await client.listPeers();
+        return `${peers.length} peer(s) online`;
+      });
+      await run("send", async () => {
+        const result = await client.send("*", "test-battery-ping", "low");
+        if (!result.ok)
+          throw new Error(result.error ?? "send failed");
+        return `broadcast sent (${result.messageId?.slice(0, 8)}…)`;
+      });
+      let memoryId = null;
+      await run("remember", async () => {
+        memoryId = await client.remember("test-battery-memory", ["test", "e2e"]);
+        if (!memoryId)
+          throw new Error("no memory ID returned");
+        return `stored (${memoryId.slice(0, 8)}…)`;
+      });
+      await run("recall", async () => {
+        const memories = await client.recall("test-battery");
+        if (memories.length === 0)
+          throw new Error("no memories found");
+        return `${memories.length} result(s)`;
+      });
+      await run("state set", async () => {
+        await client.setState("test-key", "test-value-" + Date.now());
+        return "key written";
+      });
+      await run("state get", async () => {
+        const result = await client.getState("test-key");
+        if (!result)
+          throw new Error("key not found");
+        if (!String(result.value).startsWith("test-value-"))
+          throw new Error("wrong value");
+        return `read back: ${String(result.value).slice(0, 20)}…`;
+      });
+      if (memoryId) {
+        await run("forget", async () => {
+          await client.forget(memoryId);
+          return "memory cleaned up";
+        });
+      }
+      await run("disconnect", async () => {
+        client.close();
+        return "connection closed";
+      });
+    }
+  }
+  await run("delete", async () => {
+    await request({
+      path: `/cli/mesh/${meshSlug}`,
+      method: "DELETE",
+      body: { user_id: userId },
+      baseUrl: BROKER_HTTP5
+    });
+    leaveMesh(meshSlug);
+    return `deleted "${meshSlug}" from server + local`;
+  });
+  const passed = results.filter((r) => r.ok).length;
+  const failed = results.filter((r) => !r.ok).length;
+  const totalMs = Date.now() - started;
+  console.log("");
+  if (failed === 0) {
+    console.log(`  ${green(bold(`${passed}/${results.length} passed`))}  ${dim(`(${(totalMs / 1000).toFixed(1)}s)`)}`);
+  } else {
+    console.log(`  ${red(bold(`${failed} failed`))}, ${green(`${passed} passed`)}  ${dim(`(${(totalMs / 1000).toFixed(1)}s)`)}`);
+  }
+  console.log("");
+  return failed > 0 ? EXIT.INTERNAL_ERROR : EXIT.SUCCESS;
+}
+var BROKER_HTTP5, results;
+var init_test = __esm(() => {
+  init_facade6();
+  init_facade11();
+  init_facade5();
+  init_facade2();
+  init_facade7();
+  init_facade9();
+  init_urls();
+  init_facade13();
+  init_styles();
+  init_exit_codes();
+  BROKER_HTTP5 = URLS.BROKER.replace("wss://", "https://").replace("ws://", "http://").replace("/ws", "");
+  results = [];
+});
+
 // src/mcp/tools/definitions.ts
 var TOOLS;
 var init_definitions = __esm(() => {
@@ -7661,12 +7986,12 @@ ${manifest.allowed_tools.map((t) => `  - ${t}`).join(`
         if (!to || !message)
           return text("send_message: `to` and `message` required", true);
         const targets = Array.isArray(to) ? to : [to];
-        const results = [];
+        const results2 = [];
         const seen2 = new Set;
         for (const target of targets) {
           const { client, targetSpec, error: error2 } = await resolveClient(target);
           if (!client) {
-            results.push(`✗ ${target}: ${error2 ?? "no client resolved"}`);
+            results2.push(`✗ ${target}: ${error2 ?? "no client resolved"}`);
             continue;
           }
           if (seen2.has(targetSpec))
@@ -7674,12 +7999,12 @@ ${manifest.allowed_tools.map((t) => `  - ${t}`).join(`
           seen2.add(targetSpec);
           const result = await client.send(targetSpec, message, priority ?? "next");
           if (!result.ok) {
-            results.push(`✗ ${target}: ${result.error}`);
+            results2.push(`✗ ${target}: ${result.error}`);
           } else {
-            results.push(`✓ ${target} → ${result.messageId}`);
+            results2.push(`✓ ${target} → ${result.messageId}`);
           }
         }
-        return text(results.join(`
+        return text(results2.join(`
 `));
       }
       case "list_peers": {
@@ -7959,15 +8284,15 @@ ${lines.join(`
         const { path: filePath, name: fileName, tags, to: fileTo } = args ?? {};
         if (!filePath)
           return text("share_file: `path` required", true);
-        const { existsSync: existsSync9 } = await import("node:fs");
-        if (!existsSync9(filePath))
+        const { existsSync: existsSync13 } = await import("node:fs");
+        if (!existsSync13(filePath))
           return text(`share_file: file not found: ${filePath}`, true);
         const client = allClients()[0];
         if (!client)
           return text("share_file: not connected", true);
         if (fileTo) {
           const { encryptFile: encryptFile2, sealKeyForPeer: sealKeyForPeer2 } = await Promise.resolve().then(() => (init_file_crypto(), exports_file_crypto));
-          const { readFileSync: readFileSync7, writeFileSync: writeFileSync7, mkdtempSync: mkdtempSync2, unlinkSync: unlinkSync2, rmdirSync } = await import("node:fs");
+          const { readFileSync: readFileSync10, writeFileSync: writeFileSync7, mkdtempSync: mkdtempSync2, unlinkSync: unlinkSync2, rmdirSync } = await import("node:fs");
           const { tmpdir: tmpdir2 } = await import("node:os");
           const { join: join6, basename } = await import("node:path");
           const peers = await client.listPeers();
@@ -7975,7 +8300,7 @@ ${lines.join(`
           if (!targetPeer) {
             return text(`share_file: peer not found: ${fileTo}`, true);
           }
-          const plaintext = readFileSync7(filePath);
+          const plaintext = readFileSync10(filePath);
           const { ciphertext, nonce, key } = await encryptFile2(new Uint8Array(plaintext));
           const sealedForTarget = await sealKeyForPeer2(key, targetPeer.pubkey);
           const myPubkey = client.getSessionPubkey();
@@ -8142,11 +8467,11 @@ ${lines.join(`
         const client = allClients()[0];
         if (!client)
           return text("vector_search: not connected", true);
-        const results = await client.vectorSearch(collection, query, limit);
-        if (results.length === 0)
+        const results2 = await client.vectorSearch(collection, query, limit);
+        if (results2.length === 0)
           return text(`No results in ${collection} for "${query}".`);
-        const lines = results.map((r) => `- [${r.id.slice(0, 8)}…] (score: ${r.score.toFixed(3)}) ${r.text.slice(0, 120)}${r.text.length > 120 ? "…" : ""}`);
-        return text(`${results.length} result(s) in ${collection}:
+        const lines = results2.map((r) => `- [${r.id.slice(0, 8)}…] (score: ${r.score.toFixed(3)}) ${r.text.slice(0, 120)}${r.text.length > 120 ? "…" : ""}`);
+        return text(`${results2.length} result(s) in ${collection}:
 ${lines.join(`
 `)}`);
       }
@@ -8590,34 +8915,34 @@ ${lines.join(`
         const client = allClients()[0];
         if (!client)
           return text("ping_mesh: not connected", true);
-        const results = [];
-        results.push(`WS status: ${client.status}`);
-        results.push(`Mesh: ${client.meshSlug}`);
+        const results2 = [];
+        results2.push(`WS status: ${client.status}`);
+        results2.push(`Mesh: ${client.meshSlug}`);
         const peers = await client.listPeers();
         const selfPeer = peers.find((p) => p.displayName === myName);
-        results.push(`Your status: ${selfPeer?.status ?? "not found in peer list"}`);
-        results.push(`Peers online: ${peers.length}`);
-        results.push(`Push buffer: ${client.pushHistory.length} buffered`);
+        results2.push(`Your status: ${selfPeer?.status ?? "not found in peer list"}`);
+        results2.push(`Peers online: ${peers.length}`);
+        results2.push(`Push buffer: ${client.pushHistory.length} buffered`);
         for (const prio of toTest) {
           const sendTime = Date.now();
           const target = peers.find((p) => p.displayName !== myName);
           const sendResult = await client.send(target?.pubkey ?? "*", `__ping__ ${prio} from ${myName} at ${new Date().toISOString()}`, prio);
           const ackTime = Date.now();
           if (!sendResult.ok) {
-            results.push(`[${prio}] SEND FAILED: ${sendResult.error}`);
+            results2.push(`[${prio}] SEND FAILED: ${sendResult.error}`);
           } else {
-            results.push(`[${prio}] send→ack: ${ackTime - sendTime}ms (msgId: ${sendResult.messageId?.slice(0, 12)})`);
+            results2.push(`[${prio}] send→ack: ${ackTime - sendTime}ms (msgId: ${sendResult.messageId?.slice(0, 12)})`);
             if (prio !== "now" && selfPeer?.status === "working") {
-              results.push(`  ⚠ peer status is "working" — broker holds "${prio}" until idle`);
+              results2.push(`  ⚠ peer status is "working" — broker holds "${prio}" until idle`);
             }
           }
         }
-        results.push("");
-        results.push("Pipeline check:");
-        results.push(`  onPush handlers: active`);
-        results.push(`  messageMode: ${messageMode}`);
-        results.push(`  server.notification: ${messageMode === "off" ? "disabled (mode=off)" : "enabled"}`);
-        return text(results.join(`
+        results2.push("");
+        results2.push("Pipeline check:");
+        results2.push(`  onPush handlers: active`);
+        results2.push(`  messageMode: ${messageMode}`);
+        results2.push(`  server.notification: ${messageMode === "off" ? "disabled (mode=off)" : "enabled"}`);
+        return text(results2.join(`
 `));
       }
       case "mesh_mcp_register": {
@@ -8843,10 +9168,10 @@ ${lines.join(`
         const entryType = vType ?? "env";
         let plaintextBytes;
         if (entryType === "file") {
-          const { existsSync: existsSync9, readFileSync: readFileSync7 } = await import("node:fs");
-          if (!existsSync9(value))
+          const { existsSync: existsSync13, readFileSync: readFileSync10 } = await import("node:fs");
+          if (!existsSync13(value))
             return text(`vault_set: file not found: ${value}`, true);
-          plaintextBytes = new Uint8Array(readFileSync7(value));
+          plaintextBytes = new Uint8Array(readFileSync10(value));
         } else {
           plaintextBytes = new TextEncoder().encode(value);
         }
@@ -9888,6 +10213,11 @@ async function main() {
       await runSync2({ force: !!flags.force });
       break;
     }
+    case "test": {
+      const { runTest: runTest2 } = await Promise.resolve().then(() => (init_test(), exports_test));
+      process.exit(await runTest2());
+      break;
+    }
     case "mcp": {
       const { runMcp: runMcp2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
       await runMcp2();
@@ -9915,4 +10245,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=81163B8BFDE9F4C264756E2164756E21
+//# debugId=7B5D9F4BBB2B855F64756E2164756E21