@wrongstack/cli 0.305.0 → 0.306.0

package/dist/diag-doctor-WTBHPOMB.js

@@ -0,0 +1,329 @@
+import {
+  API_VERSION
+} from "./chunk-XJXDOF63.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/subcommands/handlers/diag-doctor.ts
+import * as fs2 from "node:fs/promises";
+import * as os from "node:os";
+import * as path2 from "node:path";
+import { color, toErrorMessage } from "@wrongstack/core/utils";
+
+// src/subcommands/handlers/daemon-inventory.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+  chronicleProjectServerEndpoint,
+  chronicleProjectServerMetadataPath
+} from "@wrongstack/core/chronicle";
+import {
+  mailboxProjectServerEndpoint,
+  mailboxProjectServerMetadataPath
+} from "@wrongstack/core/coordination";
+import {
+  sessionCatalogProjectServerEndpoint,
+  sessionCatalogProjectServerMetadataPath
+} from "@wrongstack/core/session-catalog";
+import {
+  KANBAN_PROJECT_SERVER_METADATA_FILE,
+  kanbanProjectServerEndpoint
+} from "@wrongstack/kanban";
+import { isProjectEndpointLive } from "@wrongstack/persistence";
+import { sageProjectServerEndpoint, sageProjectServerMetadataPath } from "@wrongstack/sage";
+import {
+  projectIndexServerEndpoint,
+  projectIndexServerMetadataPath
+} from "@wrongstack/tools/codebase-index";
+function describeDaemons(options) {
+  const { projectRoot, projectDir } = options;
+  return [
+    {
+      name: "kanban",
+      // In-repo `<projectRoot>/.wrongstack/`, not the global per-project state
+      // directory the other daemons use. Kanban deliberately keeps its server
+      // file next to the boards it owns.
+      metadataPath: path.join(projectRoot, ".wrongstack", KANBAN_PROJECT_SERVER_METADATA_FILE),
+      endpoint: kanbanProjectServerEndpoint(projectRoot)
+    },
+    {
+      name: "sage",
+      endpoint: sageProjectServerEndpoint(projectRoot),
+      metadataPath: sageProjectServerMetadataPath(projectRoot)
+    },
+    {
+      name: "chronicle",
+      endpoint: chronicleProjectServerEndpoint(projectDir),
+      metadataPath: chronicleProjectServerMetadataPath(projectDir)
+    },
+    {
+      name: "mailbox",
+      endpoint: mailboxProjectServerEndpoint(projectDir),
+      metadataPath: mailboxProjectServerMetadataPath(projectDir)
+    },
+    {
+      name: "session-catalog",
+      endpoint: sessionCatalogProjectServerEndpoint(projectDir),
+      metadataPath: sessionCatalogProjectServerMetadataPath(projectDir)
+    },
+    {
+      name: "codebase-index",
+      endpoint: projectIndexServerEndpoint(projectRoot),
+      metadataPath: projectIndexServerMetadataPath(projectRoot)
+    }
+  ];
+}
+async function readPid(metadataPath) {
+  if (!metadataPath) return void 0;
+  try {
+    const parsed = JSON.parse(await fs.readFile(metadataPath, "utf8"));
+    return typeof parsed.pid === "number" ? parsed.pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function endpointExists(endpoint) {
+  if (process.platform === "win32") return false;
+  try {
+    await fs.stat(endpoint);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectDaemonReports(options) {
+  return Promise.all(
+    describeDaemons(options).map(async (descriptor) => {
+      const live = await isProjectEndpointLive(descriptor.endpoint);
+      const status = live ? "live" : await endpointExists(descriptor.endpoint) ? "stale" : "stopped";
+      const pid = live ? await readPid(descriptor.metadataPath) : void 0;
+      return pid === void 0 ? { name: descriptor.name, endpoint: descriptor.endpoint, status } : { name: descriptor.name, endpoint: descriptor.endpoint, status, pid };
+    })
+  );
+}
+async function clearStaleDaemonEndpoints(options) {
+  const cleared = [];
+  for (const report of await collectDaemonReports(options)) {
+    if (report.status !== "stale") continue;
+    try {
+      await fs.rm(report.endpoint, { force: true });
+      cleared.push(report.name);
+    } catch {
+    }
+  }
+  return cleared;
+}
+
+// src/subcommands/handlers/diag-doctor.ts
+var diagCmd = async (_args, deps) => {
+  const cfg = deps.config;
+  const age = await deps.modelsRegistry.ageSeconds();
+  const lines = [
+    color.bold("WrongStack diagnostics"),
+    `  apiVersion:    ${API_VERSION}`,
+    `  cwd:           ${deps.cwd}`,
+    `  projectRoot:   ${deps.projectRoot}`,
+    `  projectHash:   ${deps.paths.projectHash}`,
+    `  projectDir:    ${deps.paths.projectDir}`,
+    `  globalRoot:    ${deps.paths.globalRoot}`,
+    `  modelsCache:   ${deps.paths.modelsCache}`,
+    `  cacheAge:      ${isFinite(age) ? `${Math.round(age / 60)}m` : "never"}`,
+    `  node:          ${process.version}`,
+    `  os:            ${os.platform()} ${os.release()}`,
+    `  provider:      ${cfg.provider ?? "<unset>"}`,
+    `  model:         ${cfg.model ?? "<unset>"}`,
+    `  tools:         ${deps.toolRegistry?.list().length ?? 0}`,
+    `  plugins:       ${cfg.plugins?.length ?? 0}`,
+    `  mcpServers:    ${Object.keys(cfg.mcpServers ?? {}).length}`
+  ];
+  deps.renderer.write(lines.join("\n") + "\n");
+  return 0;
+};
+async function reportDaemons(deps, opts) {
+  const inventory = { projectRoot: deps.projectRoot, projectDir: deps.paths.projectDir };
+  let reports = await collectDaemonReports(inventory);
+  deps.renderer.write(color.bold("WrongStack project daemons\n\n"));
+  const icon = (status) => status === "live" ? color.green("\u2713") : status === "stale" ? color.red("\u2717") : color.dim("\xB7");
+  for (const report of reports) {
+    const suffix = report.pid === void 0 ? "" : ` pid ${report.pid}`;
+    deps.renderer.write(
+      `  ${icon(report.status)} ${report.name.padEnd(16)} ${report.status.padEnd(8)}${color.dim(report.endpoint + suffix)}
+`
+    );
+  }
+  const stale = reports.filter((report) => report.status === "stale");
+  if (stale.length === 0) {
+    deps.renderer.write(color.green("\nNo wedged endpoints.\n"));
+    return 0;
+  }
+  if (!opts.clear) {
+    deps.renderer.write(
+      color.amber(
+        `
+${stale.length} stale endpoint${stale.length === 1 ? "" : "s"}: ${stale.map((report) => report.name).join(", ")}
+`
+      )
+    );
+    deps.renderer.write(
+      color.dim(
+        "  A daemon died without releasing its endpoint. Current daemons reclaim\n  this automatically on next start; clear it now with:\n    wstack doctor --daemons --clear-stale\n"
+      )
+    );
+    return 1;
+  }
+  const cleared = await clearStaleDaemonEndpoints(inventory);
+  reports = await collectDaemonReports(inventory);
+  const remaining = reports.filter((report) => report.status === "stale");
+  if (cleared.length > 0) {
+    deps.renderer.write(color.green(`
+Cleared: ${cleared.join(", ")}
+`));
+  }
+  if (remaining.length > 0) {
+    deps.renderer.write(
+      color.red(`Still wedged: ${remaining.map((report) => report.name).join(", ")}
+`)
+    );
+    return 1;
+  }
+  deps.renderer.write(color.dim("Daemons restart on demand \u2014 no further action needed.\n"));
+  return 0;
+}
+var doctorCmd = async (args, deps) => {
+  const flagged = (name) => deps.flags?.[name] === true || deps.flags?.[name] === "true" || args.includes(`--${name}`);
+  if (flagged("daemons")) {
+    return reportDaemons(deps, { clear: flagged("clear-stale") });
+  }
+  const checks = [];
+  const cfg = deps.config;
+  if (!cfg.provider)
+    checks.push({
+      name: "provider",
+      status: "fail",
+      detail: "no provider configured \u2014 run `wstack auth` to set up"
+    });
+  else checks.push({ name: "provider", status: "ok", detail: cfg.provider });
+  if (!cfg.model)
+    checks.push({
+      name: "model",
+      status: "fail",
+      detail: "no model configured \u2014 run `wstack auth` to configure"
+    });
+  else checks.push({ name: "model", status: "ok", detail: cfg.model });
+  if (cfg.provider) {
+    const providerCfg = cfg.providers?.[cfg.provider];
+    const hasVaultKey = typeof providerCfg?.apiKey === "string" && providerCfg.apiKey.length > 0;
+    const envHit = providerCfg?.envVars?.some((v) => process.env[v]) ?? false;
+    if (hasVaultKey || envHit)
+      checks.push({
+        name: "api key",
+        status: "ok",
+        detail: hasVaultKey ? "found in vault" : "found in env"
+      });
+    else
+      checks.push({
+        name: "api key",
+        status: "fail",
+        detail: `no key for "${cfg.provider}" in vault or env \u2014 run \`wstack auth ${cfg.provider}\``
+      });
+  }
+  try {
+    const age = await deps.modelsRegistry.ageSeconds();
+    if (!isFinite(age))
+      checks.push({
+        name: "models cache",
+        status: "warn",
+        detail: "never fetched \u2014 run `wstack models refresh`"
+      });
+    else if (age > 7 * 24 * 3600)
+      checks.push({
+        name: "models cache",
+        status: "warn",
+        detail: `${Math.round(age / 86400)} days old \u2014 run \`wstack models refresh\``
+      });
+    else
+      checks.push({ name: "models cache", status: "ok", detail: `${Math.round(age / 60)}m old` });
+  } catch (err) {
+    checks.push({
+      name: "models cache",
+      status: "warn",
+      detail: `read failed: ${toErrorMessage(err)}`
+    });
+  }
+  try {
+    await fs2.access(deps.paths.secretsKey);
+    checks.push({ name: "secret vault", status: "ok", detail: deps.paths.secretsKey });
+  } catch {
+    checks.push({
+      name: "secret vault",
+      status: "warn",
+      detail: "not yet initialized (created lazily on first encrypt)"
+    });
+  }
+  try {
+    await fs2.mkdir(deps.paths.projectSessions, { recursive: true });
+    const probe = path2.join(deps.paths.projectSessions, `.probe-${Date.now()}`);
+    await fs2.writeFile(probe, "");
+    await fs2.unlink(probe);
+    checks.push({ name: "sessions writable", status: "ok", detail: deps.paths.projectSessions });
+  } catch (err) {
+    checks.push({
+      name: "sessions writable",
+      status: "fail",
+      detail: `cannot write to ${deps.paths.projectSessions}: ${toErrorMessage(err)}`
+    });
+  }
+  const mcpEntries = Object.entries(cfg.mcpServers ?? {});
+  for (const [name, srv] of mcpEntries) {
+    if (!srv.enabled) continue;
+    if ((srv.transport === "sse" || srv.transport === "streamable-http") && !srv.url)
+      checks.push({ name: `mcp:${name}`, status: "fail", detail: "transport requires url" });
+    else if (srv.transport === "stdio" && !srv.command)
+      checks.push({
+        name: `mcp:${name}`,
+        status: "fail",
+        detail: "stdio transport requires command"
+      });
+    else
+      checks.push({
+        name: `mcp:${name}`,
+        status: "ok",
+        detail: `${srv.transport} ${srv.command ?? srv.url ?? ""}`.trim()
+      });
+  }
+  const major = Number.parseInt(process.version.replace(/^v/, "").split(".")[0] ?? "0", 10);
+  if (major < 22)
+    checks.push({ name: "node", status: "fail", detail: `${process.version} (need \u226522)` });
+  else checks.push({ name: "node", status: "ok", detail: process.version });
+  deps.renderer.write(color.bold("WrongStack doctor\n\n"));
+  let failed = 0;
+  let warned = 0;
+  for (const c of checks) {
+    const icon = c.status === "ok" ? color.green("\u2713") : c.status === "warn" ? color.amber("\u25CF") : color.red("\u2717");
+    deps.renderer.write(`  ${icon} ${c.name.padEnd(20)} ${color.dim(c.detail)}
+`);
+    if (c.status === "fail") failed++;
+    if (c.status === "warn") warned++;
+  }
+  deps.renderer.write("\n");
+  if (failed > 0) {
+    deps.renderer.write(
+      color.red(`${failed} failed, ${warned} warning${warned === 1 ? "" : "s"}
+`)
+    );
+    return 1;
+  }
+  if (warned > 0) {
+    deps.renderer.write(
+      color.amber(`All checks passed (${warned} warning${warned === 1 ? "" : "s"})
+`)
+    );
+    return 0;
+  }
+  deps.renderer.write(color.green("All checks passed.\n"));
+  return 0;
+};
+export {
+  diagCmd,
+  doctorCmd
+};
+//# sourceMappingURL=diag-doctor-WTBHPOMB.js.map