camstack 1.2.212 → 1.2.214

package/dist/doctor-command-S7Q2U6HO.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import {
+  hubRequest
+} from "./chunk-BYNP7S4W.js";
+import {
+  isOlder,
+  latestOnNpm
+} from "./chunk-37A556YF.js";
+import "./chunk-JPGJK5DC.js";
+import "./chunk-LMMQX4CK.js";
+
+// src/mcp/doctor-command.ts
+import { parseArgs } from "util";
+import { tryConnectHub } from "@camstack/develop";
+
+// src/mcp/doctor.ts
+import {
+  explainTlsFailure,
+  hubCaFileForServer,
+  resolveHubTls
+} from "@camstack/develop";
+var MIN_NODE_MAJOR = 24;
+function nodeCheck(version) {
+  const major = Number.parseInt(version.replace(/^v/, "").split(".")[0] ?? "", 10);
+  if (Number.isNaN(major)) {
+    return {
+      id: "node",
+      label: "Node.js version",
+      status: "unknown",
+      detail: `cannot read "${version}"`
+    };
+  }
+  if (major >= MIN_NODE_MAJOR) {
+    return {
+      id: "node",
+      label: "Node.js version",
+      status: "ok",
+      detail: `${version} (>= ${MIN_NODE_MAJOR})`
+    };
+  }
+  return {
+    id: "node",
+    label: "Node.js version",
+    status: "fail",
+    detail: `${version} is older than the required ${MIN_NODE_MAJOR}`,
+    fix: `Install Node.js ${MIN_NODE_MAJOR} or newer, then reinstall: npm install -g camstack@latest`
+  };
+}
+async function versionCheck(deps) {
+  const latest = await latestOnNpm("camstack", deps.fetch);
+  if (latest.latest === null) {
+    return {
+      id: "version",
+      label: "CLI version",
+      status: "unknown",
+      detail: `${deps.cliVersion} installed; npm latest unreadable (${latest.error ?? "no answer"})`
+    };
+  }
+  if (isOlder(deps.cliVersion, latest.latest)) {
+    return {
+      id: "version",
+      label: "CLI version",
+      status: "fail",
+      detail: `${deps.cliVersion} installed, ${latest.latest} is on npm`,
+      fix: "npm install -g camstack@latest, then restart the MCP in your client (OpenCode and similar keep the old process)."
+    };
+  }
+  return {
+    id: "version",
+    label: "CLI version",
+    status: "ok",
+    detail: `${deps.cliVersion} (npm latest ${latest.latest})`
+  };
+}
+var NO_HUB = "no hub to check (see the session line)";
+async function runDoctorChecks(deps) {
+  const checks = [nodeCheck(deps.nodeVersion)];
+  let outcome;
+  try {
+    outcome = await deps.connect();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const tls = explainTlsFailure("the hub", err);
+    outcome = {
+      ok: false,
+      reason: "no-session",
+      message: tls ?? message,
+      action: "camstack login <host>"
+    };
+  }
+  if (!outcome.ok) {
+    checks.push(
+      { id: "hub", label: "Hub reachable", status: "unknown", detail: NO_HUB },
+      { id: "ca", label: "Hub CA pinned", status: "unknown", detail: NO_HUB },
+      {
+        id: "session",
+        label: "Session or token file",
+        status: "fail",
+        detail: outcome.message,
+        fix: `${outcome.action}; without a TTY: camstack login <host> --token-file <path-to-0600-file>`
+      },
+      { id: "scope", label: "Token scope", status: "unknown", detail: "no credential to inspect" },
+      await versionCheck(deps)
+    );
+    return checks;
+  }
+  const { connection } = outcome;
+  const server = connection.server;
+  const probe = await deps.probeHub(server);
+  const tlsExplained = probe.reachable ? null : explainTlsFailure(server, probe.cause);
+  checks.push(
+    probe.reachable ? { id: "hub", label: "Hub reachable", status: "ok", detail: server } : {
+      id: "hub",
+      label: "Hub reachable",
+      status: "fail",
+      detail: `${server}: ${probe.error ?? "no answer"}`,
+      fix: tlsExplained === null ? "Check the hub is running and the address is right (camstack login <host>)." : "Pin the hub CA (see the next line)."
+    }
+  );
+  const pinned = resolveHubTls(server, deps.env ?? process.env, deps.sessionDir);
+  if (!server.startsWith("https:")) {
+    checks.push({
+      id: "ca",
+      label: "Hub CA pinned",
+      status: "unknown",
+      detail: "plain http hub: TLS is not used"
+    });
+  } else if (pinned.ca) {
+    checks.push({
+      id: "ca",
+      label: "Hub CA pinned",
+      status: "ok",
+      detail: pinned.caFile ?? "pinned"
+    });
+  } else if (tlsExplained !== null) {
+    checks.push({
+      id: "ca",
+      label: "Hub CA pinned",
+      status: "fail",
+      detail: "no pinned CA and the hub certificate is not publicly trusted",
+      fix: `Save the hub's certificate or CA PEM to ${hubCaFileForServer(server, deps.sessionDir)} (or set $CAMSTACK_HUB_CA_FILE).`
+    });
+  } else {
+    checks.push({
+      id: "ca",
+      label: "Hub CA pinned",
+      status: "unknown",
+      detail: "no pin; fine while the hub certificate is publicly trusted"
+    });
+  }
+  checks.push({
+    id: "session",
+    label: "Session or token file",
+    status: "ok",
+    detail: `usable credential from ${connection.source}`
+  });
+  checks.push(
+    connection.tier === "admin" ? { id: "scope", label: "Token scope", status: "ok", detail: "admin" } : {
+      id: "scope",
+      label: "Token scope",
+      status: "unknown",
+      detail: "not admin: read tools work, configure and update tools are refused",
+      fix: connection.adminHint ?? "camstack login <host> as an administrator"
+    }
+  );
+  checks.push(await versionCheck(deps));
+  return checks;
+}
+var MARK = {
+  ok: "ok     ",
+  fail: "FAIL   ",
+  unknown: "unknown"
+};
+function formatDoctor(checks) {
+  const lines = ["camstack mcp doctor", ""];
+  for (const c of checks) {
+    lines.push(`[${MARK[c.status]}] ${c.label}: ${c.detail}`);
+    if (c.fix && c.status !== "ok") lines.push(`          fix: ${c.fix}`);
+  }
+  const failed = checks.filter((c) => c.status === "fail").length;
+  lines.push("", failed === 0 ? "No failing check." : `${failed} failing check(s).`);
+  return lines.join("\n");
+}
+function doctorExitCode(checks) {
+  return checks.some((c) => c.status === "fail") ? 1 : 0;
+}
+
+// src/mcp/doctor-command.ts
+async function probeHub(server) {
+  try {
+    const res = await hubRequest(`${server}/health`, { timeoutMs: 5e3 });
+    return res.ok ? { reachable: true } : { reachable: false, error: `answered ${res.status}` };
+  } catch (err) {
+    return {
+      reachable: false,
+      error: err instanceof Error ? err.message : String(err),
+      cause: err instanceof Error && err.cause !== void 0 ? err.cause : err
+    };
+  }
+}
+async function runDoctorCommand(args, cliVersion) {
+  const parsed = parseArgs({
+    args: [...args],
+    options: { server: { type: "string", short: "s" }, "token-file": { type: "string" } },
+    allowPositionals: false,
+    strict: true
+  });
+  const server = parsed.values.server;
+  const tokenFile = parsed.values["token-file"];
+  const checks = await runDoctorChecks({
+    cliVersion,
+    nodeVersion: process.version,
+    connect: () => tryConnectHub({
+      workspaceRoot: process.cwd(),
+      ...server ? { server } : {},
+      ...tokenFile ? { tokenFile } : {}
+    }),
+    probeHub,
+    fetch: (url, init) => fetch(url, init)
+  });
+  process.stdout.write(`${formatDoctor(checks)}
+`);
+  return doctorExitCode(checks);
+}
+export {
+  runDoctorCommand
+};