claudemesh-cli 0.1.2 → 0.1.4

package/dist/index.js

@@ -55344,7 +55344,7 @@ ${body}`;
 }
 async function startMcpServer() {
   const config2 = loadConfig();
-  const server = new Server({ name: "claudemesh", version: "0.1.2" }, {
+  const server = new Server({ name: "claudemesh", version: "0.1.4" }, {
     capabilities: {
       experimental: { "claude/channel": {} },
       tools: {}
@@ -56081,8 +56081,418 @@ function runLaunch(extraArgs = []) {
   });
 }
 
+// src/commands/status.ts
+import { statSync, existsSync as existsSync3 } from "node:fs";
+// package.json
+var package_default = {
+  name: "claudemesh-cli",
+  version: "0.1.4",
+  description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
+  keywords: [
+    "claude-code",
+    "mcp",
+    "model-context-protocol",
+    "claudemesh",
+    "peer-messaging",
+    "multi-agent"
+  ],
+  author: "Alejandro Gutiérrez",
+  license: "MIT",
+  homepage: "https://claudemesh.com",
+  repository: {
+    type: "git",
+    url: "https://github.com/alezmad/claudemesh.git",
+    directory: "apps/cli"
+  },
+  type: "module",
+  bin: {
+    claudemesh: "./dist/index.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: 'bun build src/index.ts --target=node --outfile dist/index.js --banner "#!/usr/bin/env node" && chmod +x dist/index.js',
+    clean: "git clean -xdf .cache .turbo dist node_modules",
+    dev: "bun --hot src/index.ts",
+    start: "bun src/index.ts",
+    format: "prettier --check . --ignore-path ../../.gitignore",
+    lint: "eslint",
+    prepublishOnly: "bun run build",
+    test: "vitest run",
+    typecheck: "tsc --noEmit"
+  },
+  prettier: "@turbostarter/prettier-config",
+  engines: {
+    node: ">=20"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "1.27.1",
+    "libsodium-wrappers": "0.7.15",
+    ws: "8.20.0",
+    zod: "4.1.13"
+  },
+  devDependencies: {
+    "@turbostarter/eslint-config": "workspace:*",
+    "@turbostarter/prettier-config": "workspace:*",
+    "@turbostarter/tsconfig": "workspace:*",
+    "@turbostarter/vitest-config": "workspace:*",
+    "@types/libsodium-wrappers": "0.7.14",
+    "@types/ws": "8.5.13",
+    eslint: "catalog:",
+    prettier: "catalog:",
+    typescript: "catalog:",
+    vitest: "catalog:"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/commands/status.ts
+async function probeBroker(url2, timeoutMs = 4000) {
+  return new Promise((resolve2) => {
+    const ws = new wrapper_default(url2);
+    const timer = setTimeout(() => {
+      try {
+        ws.terminate();
+      } catch {}
+      resolve2({ ok: false, error: "timeout" });
+    }, timeoutMs);
+    ws.on("open", () => {
+      clearTimeout(timer);
+      try {
+        ws.close();
+      } catch {}
+      resolve2({ ok: true });
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      resolve2({ ok: false, error: err.message });
+    });
+  });
+}
+async function runStatus() {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const green = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
+  const red = (s) => useColor ? `\x1B[31m${s}\x1B[39m` : s;
+  console.log(`claudemesh status  (v${VERSION})`);
+  console.log("─".repeat(60));
+  const configPath = getConfigPath();
+  let configPerms = "missing";
+  if (existsSync3(configPath)) {
+    const st = statSync(configPath);
+    const mode = (st.mode & 511).toString(8).padStart(4, "0");
+    configPerms = mode === "0600" ? `${mode} ✓` : `${mode} ⚠ (expected 0600)`;
+  }
+  console.log(`Config:     ${configPath} (${configPerms})`);
+  const config2 = loadConfig();
+  if (config2.meshes.length === 0) {
+    console.log("");
+    console.log(dim("No meshes joined. Run `claudemesh join <invite-url>` to get started."));
+    process.exit(0);
+  }
+  console.log("");
+  console.log(`Meshes (${config2.meshes.length}):`);
+  const results = [];
+  for (const m of config2.meshes) {
+    process.stdout.write(`  ${m.slug.padEnd(20)} probing ${m.brokerUrl}… `);
+    const probe = await probeBroker(m.brokerUrl);
+    results.push({
+      slug: m.slug,
+      brokerUrl: m.brokerUrl,
+      pubkey: m.pubkey,
+      reachable: probe.ok,
+      error: probe.error
+    });
+    if (probe.ok) {
+      console.log(green("reachable"));
+    } else {
+      console.log(red(`unreachable (${probe.error})`));
+    }
+  }
+  console.log("");
+  for (const r of results) {
+    console.log(dim(`  ${r.slug}: pubkey ${r.pubkey.slice(0, 16)}…`));
+  }
+  const allOk = results.every((r) => r.reachable);
+  console.log("");
+  if (allOk) {
+    console.log(green("All meshes reachable."));
+    process.exit(0);
+  } else {
+    const broken = results.filter((r) => !r.reachable).length;
+    console.log(red(`${broken} of ${results.length} mesh(es) unreachable.`));
+    process.exit(1);
+  }
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { homedir as homedir3, platform as platform2 } from "node:os";
+import { join as join3 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+function checkNode() {
+  const major = Number(process.versions.node.split(".")[0]);
+  return {
+    name: "Node.js >= 20",
+    pass: major >= 20,
+    detail: `v${process.versions.node}`,
+    fix: "Install Node 20 or newer (https://nodejs.org)"
+  };
+}
+function checkClaudeOnPath() {
+  const res = platform2() === "win32" ? spawnSync2("where", ["claude"]) : spawnSync2("sh", ["-c", "command -v claude"]);
+  const onPath = res.status === 0;
+  const location = onPath ? res.stdout.toString().trim().split(`
+`)[0] : undefined;
+  return {
+    name: "claude binary on PATH",
+    pass: onPath,
+    detail: location,
+    fix: "Install Claude Code (https://claude.com/claude-code)"
+  };
+}
+function checkMcpRegistered() {
+  const claudeConfig = join3(homedir3(), ".claude.json");
+  if (!existsSync4(claudeConfig)) {
+    return {
+      name: "claudemesh MCP registered in ~/.claude.json",
+      pass: false,
+      fix: "Run `claudemesh install`"
+    };
+  }
+  try {
+    const cfg = JSON.parse(readFileSync3(claudeConfig, "utf-8"));
+    const registered = Boolean(cfg.mcpServers?.["claudemesh"]);
+    return {
+      name: "claudemesh MCP registered in ~/.claude.json",
+      pass: registered,
+      fix: registered ? undefined : "Run `claudemesh install`"
+    };
+  } catch (e) {
+    return {
+      name: "claudemesh MCP registered in ~/.claude.json",
+      pass: false,
+      detail: e instanceof Error ? e.message : String(e),
+      fix: "Check ~/.claude.json for JSON parse errors"
+    };
+  }
+}
+function checkHooksRegistered() {
+  const settings = join3(homedir3(), ".claude", "settings.json");
+  if (!existsSync4(settings)) {
+    return {
+      name: "Status hooks registered in ~/.claude/settings.json",
+      pass: false,
+      fix: "Run `claudemesh install` (remove --no-hooks)"
+    };
+  }
+  try {
+    const raw = readFileSync3(settings, "utf-8");
+    const has = raw.includes("claudemesh hook ");
+    return {
+      name: "Status hooks registered in ~/.claude/settings.json",
+      pass: has,
+      fix: has ? undefined : "Run `claudemesh install` (remove --no-hooks)"
+    };
+  } catch (e) {
+    return {
+      name: "Status hooks registered in ~/.claude/settings.json",
+      pass: false,
+      detail: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function checkConfigFile() {
+  const path = getConfigPath();
+  if (!existsSync4(path)) {
+    return {
+      name: "~/.claudemesh/config.json exists and parses",
+      pass: true,
+      detail: "not created yet (fine — no meshes joined)"
+    };
+  }
+  try {
+    loadConfig();
+    const st = statSync2(path);
+    const mode = (st.mode & 511).toString(8);
+    const secure = platform2() === "win32" || mode === "600";
+    return {
+      name: "~/.claudemesh/config.json parses + chmod 0600",
+      pass: secure,
+      detail: platform2() === "win32" ? "chmod skipped on Windows" : `0${mode}`,
+      fix: secure ? undefined : `chmod 600 ${path}`
+    };
+  } catch (e) {
+    return {
+      name: "~/.claudemesh/config.json exists and parses",
+      pass: false,
+      detail: e instanceof Error ? e.message : String(e),
+      fix: "Inspect or delete ~/.claudemesh/config.json and re-join"
+    };
+  }
+}
+function checkKeypairs() {
+  try {
+    const cfg = loadConfig();
+    if (cfg.meshes.length === 0) {
+      return {
+        name: "Mesh keypairs valid",
+        pass: true,
+        detail: "no meshes joined"
+      };
+    }
+    for (const m of cfg.meshes) {
+      if (m.pubkey.length !== 64 || !/^[0-9a-f]+$/.test(m.pubkey)) {
+        return {
+          name: "Mesh keypairs valid",
+          pass: false,
+          detail: `${m.slug}: pubkey malformed`,
+          fix: `Leave + re-join the mesh: claudemesh leave ${m.slug}`
+        };
+      }
+      if (m.secretKey.length !== 128 || !/^[0-9a-f]+$/.test(m.secretKey)) {
+        return {
+          name: "Mesh keypairs valid",
+          pass: false,
+          detail: `${m.slug}: secret key malformed`,
+          fix: `Leave + re-join the mesh: claudemesh leave ${m.slug}`
+        };
+      }
+    }
+    return {
+      name: "Mesh keypairs valid",
+      pass: true,
+      detail: `${cfg.meshes.length} mesh(es)`
+    };
+  } catch (e) {
+    return {
+      name: "Mesh keypairs valid",
+      pass: false,
+      detail: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+async function runDoctor() {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const green = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
+  const red = (s) => useColor ? `\x1B[31m${s}\x1B[39m` : s;
+  console.log(`claudemesh doctor  (v${VERSION})`);
+  console.log("─".repeat(60));
+  const checks3 = [
+    checkNode(),
+    checkClaudeOnPath(),
+    checkMcpRegistered(),
+    checkHooksRegistered(),
+    checkConfigFile(),
+    checkKeypairs()
+  ];
+  for (const c of checks3) {
+    const mark = c.pass ? green("✓") : red("✗");
+    const detail = c.detail ? dim(` (${c.detail})`) : "";
+    console.log(`${mark} ${c.name}${detail}`);
+    if (!c.pass && c.fix) {
+      console.log(dim(`   → ${c.fix}`));
+    }
+  }
+  const failing = checks3.filter((c) => !c.pass);
+  console.log("");
+  if (failing.length === 0) {
+    console.log(green("All checks passed."));
+    process.exit(0);
+  } else {
+    console.log(red(`${failing.length} check(s) failed.`));
+    process.exit(1);
+  }
+}
+
+// src/commands/welcome.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+function detectState() {
+  const claudeConfig = join4(homedir4(), ".claude.json");
+  let mcpRegistered = false;
+  if (existsSync5(claudeConfig)) {
+    try {
+      const cfg = JSON.parse(readFileSync4(claudeConfig, "utf-8"));
+      mcpRegistered = Boolean(cfg.mcpServers?.["claudemesh"]);
+    } catch {}
+  }
+  if (!mcpRegistered)
+    return "no-install";
+  try {
+    const cfg = loadConfig();
+    return cfg.meshes.length === 0 ? "no-meshes" : "ready";
+  } catch {
+    return "broken-config";
+  }
+}
+function runWelcome() {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const bold = (s) => useColor ? `\x1B[1m${s}\x1B[22m` : s;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const green = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
+  const yellow = (s) => useColor ? `\x1B[33m${s}\x1B[39m` : s;
+  console.log(bold(`claudemesh v${VERSION}`) + dim(" — peer mesh for Claude Code"));
+  console.log("─".repeat(60));
+  const state = detectState();
+  switch (state) {
+    case "no-install":
+      console.log("Welcome. Let's get you set up.");
+      console.log("");
+      console.log(bold("Step 1:") + " register the MCP server + status hooks");
+      console.log(`  ${green("$")} claudemesh install`);
+      console.log("");
+      console.log(dim("Step 2 (after restart): claudemesh join <invite-url>"));
+      console.log(dim("Step 3:                 claudemesh launch"));
+      break;
+    case "no-meshes":
+      console.log(green("✓") + " MCP registered. Now join a mesh.");
+      console.log("");
+      console.log(bold("Step 2:") + " join a mesh");
+      console.log(`  ${green("$")} claudemesh join https://claudemesh.com/join/<token>`);
+      console.log("");
+      console.log(dim("  Don't have an invite? Create one at ") + bold("https://claudemesh.com") + dim(" or ask a mesh owner."));
+      console.log("");
+      console.log(dim("Step 3 (after joining): claudemesh launch"));
+      break;
+    case "ready": {
+      const cfg = loadConfig();
+      const meshNames = cfg.meshes.map((m) => m.slug).join(", ");
+      console.log(green("✓") + " MCP registered.");
+      console.log(green("✓") + ` ${cfg.meshes.length} mesh(es) joined: ${meshNames}`);
+      console.log("");
+      console.log(bold("You're ready.") + " Launch Claude Code with real-time peer messages:");
+      console.log(`  ${green("$")} claudemesh launch`);
+      console.log("");
+      console.log(dim("  (Plain `claude` works too — messages pull-only via check_messages.)"));
+      console.log("");
+      console.log(dim("Health check:  claudemesh status"));
+      console.log(dim("Diagnostics:   claudemesh doctor"));
+      console.log(dim("All commands:  claudemesh --help"));
+      break;
+    }
+    case "broken-config":
+      console.log(yellow("⚠") + "  Your ~/.claudemesh/config.json is unreadable.");
+      console.log("");
+      console.log("Run diagnostics to see what's wrong:");
+      console.log(`  ${green("$")} claudemesh doctor`);
+      break;
+  }
+  console.log("");
+}
+
 // src/index.ts
-var HELP = `claudemesh — peer mesh for Claude Code sessions
+var HELP = `claudemesh v${VERSION} — peer mesh for Claude Code sessions
 
 Usage:
   claudemesh <command> [args]
@@ -56097,9 +56507,12 @@ Commands:
   join <url>      Join a mesh via https://claudemesh.com/join/... URL
   list            Show all joined meshes
   leave <slug>    Leave a joined mesh
+  status          Health report: broker reachability per joined mesh
+  doctor          Diagnostic checks (install, config, keypairs, PATH)
   seed-test-mesh  Dev-only: inject a mesh into config (skips invite flow)
   mcp             Start MCP server (stdio) — invoked by Claude Code
   --help, -h      Show this help
+  --version, -v   Show the CLI version
 
 Environment:
   CLAUDEMESH_BROKER_URL    Override broker URL (default: wss://ic.claudemesh.com/ws)
@@ -56134,15 +56547,28 @@ async function main() {
     case "leave":
       runLeave(args);
       return;
+    case "status":
+      await runStatus();
+      return;
+    case "doctor":
+      await runDoctor();
+      return;
     case "seed-test-mesh":
       runSeedTestMesh(args);
       return;
+    case "--version":
+    case "-v":
+    case "version":
+      console.log(VERSION);
+      return;
     case "--help":
     case "-h":
     case "help":
-    case undefined:
       console.log(HELP);
       return;
+    case undefined:
+      runWelcome();
+      return;
     default:
       console.error(`Unknown command: ${cmd}`);
       console.error("Run `claudemesh --help` for usage.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudemesh-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   "keywords": [
     "claude-code",