chainlesschain 0.162.158 → 0.162.159

package/src/commands/background-session.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
+import { readPrLinkLedger } from "../lib/pr-link-ledger.js";
 
 function formatAge(ms) {
   const n = Math.max(0, Math.round(Number(ms || 0) / 1000));
@@ -67,6 +68,11 @@ export function formatBackgroundAgentDetails(
     `  log: ${session.logFile || "-"}`,
   ];
   if (session.phase) lines.push(`  phase: ${session.phase}`);
+  if (session.pr?.number) {
+    lines.push(
+      `  pr: #${session.pr.number}${session.pr.state ? ` ${session.pr.state}` : ""}${session.pr.url ? `  ${session.pr.url}` : ""}`,
+    );
+  }
   if (Number.isFinite(Number(session.turnCount))) {
     lines.push(`  turns: ${session.turnCount}`);
   }
@@ -146,7 +152,7 @@ async function followBackgroundAgent(id, options = {}) {
  * when the transport is unavailable so the caller can fall back to the
  * log-only follow.
  */
-async function interactiveAttach(id, state, options = {}) {
+export async function interactiveAttach(id, state, options = {}) {
   const { connectBackgroundSession } =
     await import("../lib/background-session-transport.js");
   const { readBackgroundAgentLog, logPath } = await loadSupervisor();
@@ -279,6 +285,134 @@ async function interactiveAttach(id, state, options = {}) {
   return true;
 }
 
+/**
+ * `cc daemon view` (no id) — the interactive agent dashboard. Wires the real
+ * supervisor/transport into the injectable controller (repl/bg-dashboard.js).
+ * Non-TTY (or --json) degrades to the status listing.
+ */
+async function runDashboardView(options = {}) {
+  const supervisor = await loadSupervisor();
+  const {
+    listBackgroundAgents,
+    readBackgroundAgentLog,
+    stopBackgroundAgent,
+    renameBackgroundAgent,
+    setBackgroundAgentPinned,
+    resumeBackgroundAgent,
+    readBackgroundAgentState,
+    effectiveBackgroundAgentState,
+  } = supervisor;
+
+  const listAll = () => {
+    const sessions = listBackgroundAgents({ all: true });
+    // PR/session linking: decorate rows whose conversation touched a PR
+    // (`#123 open`). One ledger read per refresh; best-effort.
+    try {
+      const ledger = readPrLinkLedger();
+      for (const s of sessions) {
+        const links = s.sessionId ? ledger[s.sessionId] : null;
+        if (Array.isArray(links) && links.length > 0 && !s.pr) {
+          s.pr = [...links].sort(
+            (a, b) => (b.updatedAt || 0) - (a.updatedAt || 0),
+          )[0];
+        }
+      }
+    } catch {
+      /* PR decoration is cosmetic */
+    }
+    return sessions;
+  };
+
+  if (options.json || !process.stdout.isTTY || !process.stdin.isTTY) {
+    const sessions = listAll();
+    if (options.json) {
+      console.log(JSON.stringify({ sessions }, null, 2));
+    } else {
+      printBackgroundAgents(sessions);
+      logger.log(
+        chalk.gray("(interactive dashboard needs a TTY — showing a snapshot)"),
+      );
+    }
+    return;
+  }
+
+  const { runBgDashboard } = await import("../repl/bg-dashboard.js");
+  const { fileURLToPath } = await import("node:url");
+  const { spawn } = await import("node:child_process");
+  const BIN_PATH = fileURLToPath(
+    new URL("../../bin/chainlesschain.js", import.meta.url),
+  );
+
+  await runBgDashboard({
+    listAgents: listAll,
+    readLog: (id, lines) => {
+      try {
+        return readBackgroundAgentLog(id, { lines });
+      } catch {
+        return "";
+      }
+    },
+    stopAgent: (id) => stopBackgroundAgent(id),
+    renameAgent: (id, title) => renameBackgroundAgent(id, title),
+    pinAgent: (id, pinned) => setBackgroundAgentPinned(id, pinned),
+    replyAgent: async (session, text) => {
+      // Running with a live transport → queue a follow-up turn; otherwise
+      // continue the finished conversation as a new background session.
+      if (
+        session.status === "running" &&
+        session.transport?.pipe &&
+        session.transport?.token
+      ) {
+        const { connectBackgroundSession } =
+          await import("../lib/background-session-transport.js");
+        const conn = await connectBackgroundSession({
+          pipePath: session.transport.pipe,
+          token: session.transport.token,
+          onEvent: () => {},
+          onClose: () => {},
+        });
+        try {
+          conn.send({ type: "prompt", text });
+          // give the frame a beat to flush before closing
+          await new Promise((r) => setTimeout(r, 150));
+        } finally {
+          try {
+            conn.close();
+          } catch {
+            /* worker already closed it */
+          }
+        }
+        return;
+      }
+      resumeBackgroundAgent(session.id, text);
+    },
+    attachAgent: async (session) => {
+      const fresh = effectiveBackgroundAgentState(
+        readBackgroundAgentState(session.id),
+      );
+      if (!fresh) return;
+      if (
+        fresh.status === "running" &&
+        fresh.transport?.pipe &&
+        fresh.transport?.token
+      ) {
+        const attached = await interactiveAttach(session.id, fresh, {});
+        if (attached) return;
+      }
+      await followBackgroundAgent(session.id, { lines: 40 });
+    },
+    dispatchAgent: async (text) => {
+      const child = spawn(
+        process.execPath,
+        [BIN_PATH, "agent", "--bg", "-p", text],
+        { detached: true, stdio: "ignore", windowsHide: true },
+      );
+      child.unref();
+      return null; // id is minted by the launcher; the next refresh shows it
+    },
+  });
+}
+
 export function registerBackgroundSessionCommands(program) {
   program
     .command("logs <id>")
@@ -378,12 +512,18 @@ export function registerBackgroundSessionCommands(program) {
     });
 
   daemon
-    .command("view <id>")
-    .description("Show a detailed background agent view")
+    .command("view [id]")
+    .description(
+      "Detailed view of one background agent, or the interactive agent dashboard when no id is given",
+    )
     .option("-n, --lines <n>", "Recent log lines to include", "40")
     .option("--json", "Output as JSON")
     .action(async (id, options) => {
       try {
+        if (!id) {
+          await runDashboardView(options);
+          return;
+        }
         const {
           readBackgroundAgentState,
           effectiveBackgroundAgentState,

package/src/commands/browse.js

@@ -391,6 +391,92 @@ export function registerBrowseChromeCommand(browse) {
         logger.success(`Screenshot: ${state.screenshotPath}`);
       }
     });
+
+  chrome
+    .command("act")
+    .description(
+      "Perform EXPLICIT actions (click/type/press/navigate/waitForSelector/screenshot/assertText) in the connected Chrome — unlike 'state', this DRIVES your logged-in browser",
+    )
+    .option("-p, --port <port>", "CDP port", "9222")
+    .option("-t, --tab <n>", "Tab index", "0")
+    .requiredOption(
+      "--actions <json|@file>",
+      'JSON array of steps, e.g. \'[{"type":"click","selector":"#go"}]\', or @steps.json',
+    )
+    .option(
+      "--continue-on-error",
+      "Keep executing the remaining steps after a failed one (default: fail fast)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const { discoverCdp, performActions } =
+        await import("../lib/chrome-connector.js");
+      const port = numericOption(options.port, {
+        name: "--port",
+        integer: true,
+        min: 1,
+        fallback: 9222,
+      });
+      let actions;
+      try {
+        const raw = options.actions.startsWith("@")
+          ? (await import("fs")).readFileSync(options.actions.slice(1), "utf-8")
+          : options.actions;
+        actions = JSON.parse(raw);
+      } catch (err) {
+        logger.error(
+          `--actions must be a JSON array (or @file.json): ${err.message}`,
+        );
+        process.exit(1);
+      }
+      // Refuse outright when nothing is listening — an action command must
+      // never silently no-op or launch a browser on its own.
+      const probe = await discoverCdp({ port });
+      if (!probe.ok) {
+        const msg = `No debuggable Chrome on port ${port} — refusing to act. Start one first: cc browse chrome launch`;
+        if (options.json) {
+          console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+        } else {
+          logger.error(msg);
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const res = await performActions(actions, {
+        port,
+        tab: numericOption(options.tab, {
+          name: "--tab",
+          integer: true,
+          min: 0,
+          fallback: 0,
+        }),
+        continueOnError: options.continueOnError === true,
+      });
+      if (options.json) {
+        console.log(JSON.stringify(res, null, 2));
+        if (!res.ok) process.exitCode = 1;
+        return;
+      }
+      if (res.error) {
+        logger.error(res.error);
+        process.exitCode = 1;
+        return;
+      }
+      if (res.profileWarning) logger.warn(res.profileWarning);
+      for (const step of res.steps) {
+        const mark = step.ok ? chalk.green("ok") : chalk.red("FAIL");
+        logger.log(
+          `  [${mark}] ${step.action} ${chalk.gray(`(${step.durationMs}ms)`)} ${step.detail}`,
+        );
+      }
+      logger.log(
+        `  ${res.executed}/${actions.length} step(s) executed → ${chalk.cyan(res.url)}${res.title ? ` (${res.title})` : ""}`,
+      );
+      if (res.auditError) {
+        logger.warn(`audit log write failed: ${res.auditError}`);
+      }
+      if (!res.ok) process.exitCode = 1;
+    });
 }
 
 import {

package/src/commands/cloud.js

@@ -0,0 +1,232 @@
+/**
+ * `cc cloud` — self-hosted cloud handoff (gap-2026-07-11 P1#7).
+ *
+ *   cc cloud run "<task>"    bundle branch → submit to the private runner → record job
+ *   cc cloud status [id]     poll job(s) (last job when id omitted)
+ *   cc cloud attach <id>     wait for completion, reflow patch/plan/pr/artifacts locally
+ *   cc cloud list            local job ledger
+ *
+ * Runner endpoint + token come from config (cloud.baseUrl / cloud.token) or
+ * env (CC_CLOUD_URL / CC_CLOUD_TOKEN). See src/lib/cloud/cloud-client.js for
+ * the runner protocol.
+ */
+
+import { join } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+async function resolveRunner() {
+  let cfg = {};
+  try {
+    cfg = (await import("../lib/config-manager.js")).loadConfig()?.cloud || {};
+  } catch {
+    cfg = {};
+  }
+  const baseUrl = process.env.CC_CLOUD_URL || cfg.baseUrl || "";
+  const token = process.env.CC_CLOUD_TOKEN || cfg.token || null;
+  return { baseUrl, token };
+}
+
+function statusColor(status) {
+  if (status === "done") return chalk.green;
+  if (status === "failed" || status === "timeout") return chalk.red;
+  if (status === "running") return chalk.cyan;
+  return chalk.gray;
+}
+
+export function registerCloudCommand(program) {
+  const cloud = program
+    .command("cloud")
+    .description(
+      "Self-hosted cloud handoff — offload a task to a private runner (bundle → run → reflow)",
+    );
+
+  cloud
+    .command("run <task...>")
+    .description(
+      "Bundle the current branch and submit a task to the private runner",
+    )
+    .option("--json", "Output as JSON")
+    .option("--attach", "Wait for completion and reflow the result")
+    .action(async (taskWords, options) => {
+      try {
+        const task = taskWords.join(" ");
+        const { baseUrl, token } = await resolveRunner();
+        const { CloudClient, saveJob } =
+          await import("../lib/cloud/cloud-client.js");
+        const { bundleBranch } = await import("../lib/cloud/bundle.js");
+        const client = new CloudClient({ baseUrl, token });
+
+        logger.log(chalk.gray("Bundling current branch…"));
+        const snap = bundleBranch(process.cwd());
+        logger.log(
+          chalk.gray(
+            `  ${snap.branch} @ ${snap.baseSha.slice(0, 8)} (${(snap.bytes / 1024).toFixed(0)} KB)`,
+          ),
+        );
+
+        const submitted = await client.submit({
+          task,
+          bundle: snap.bundle,
+          branch: snap.branch,
+          baseSha: snap.baseSha,
+        });
+        const job = saveJob({
+          jobId: submitted.jobId,
+          task,
+          branch: snap.branch,
+          baseSha: snap.baseSha,
+          baseUrl,
+          status: "queued",
+          submittedAt: Date.now(),
+          cwd: process.cwd(),
+        });
+        if (options.json && !options.attach) {
+          return console.log(JSON.stringify(job, null, 2));
+        }
+        logger.success(`Submitted cloud job ${job.jobId} → ${baseUrl}`);
+        logger.log(chalk.gray(`  cc cloud attach ${job.jobId}`));
+        if (options.attach) await attachJob(job.jobId, options);
+      } catch (err) {
+        logger.error(err.message);
+        process.exitCode = 1;
+      }
+    });
+
+  cloud
+    .command("status [id]")
+    .description("Poll a cloud job's status (most recent when id omitted)")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const { CloudClient, readJob, listJobs, saveJob } =
+          await import("../lib/cloud/cloud-client.js");
+        const job = id ? readJob(id) : listJobs()[0];
+        if (!job)
+          throw new Error(id ? `job not found: ${id}` : "no cloud jobs");
+        const client = new CloudClient({
+          baseUrl: job.baseUrl,
+          token: (await resolveRunner()).token,
+        });
+        const status = await client.status(job.jobId);
+        saveJob({ ...job, status: status.status, lastSummary: status.summary });
+        if (options.json) return console.log(JSON.stringify(status, null, 2));
+        logger.log(
+          `${statusColor(status.status)(status.status)} ${job.jobId}  ${chalk.gray(job.task)}`,
+        );
+        if (status.summary) logger.log(chalk.gray(`  ${status.summary}`));
+      } catch (err) {
+        logger.error(err.message);
+        process.exitCode = 1;
+      }
+    });
+
+  cloud
+    .command("attach <id>")
+    .description("Wait for a cloud job to finish and reflow its result locally")
+    .option("--json", "Output as JSON")
+    .option("--no-apply", "Fetch the result but do not apply the patch")
+    .action(async (id, options) => {
+      try {
+        await attachJob(id, options);
+      } catch (err) {
+        logger.error(err.message);
+        process.exitCode = 1;
+      }
+    });
+
+  cloud
+    .command("list", { isDefault: true })
+    .description("List local cloud jobs")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { listJobs } = await import("../lib/cloud/cloud-client.js");
+        const jobs = listJobs();
+        if (options.json) return console.log(JSON.stringify(jobs, null, 2));
+        if (jobs.length === 0) {
+          logger.log(
+            chalk.gray("No cloud jobs. Submit one with `cc cloud run`."),
+          );
+          return;
+        }
+        for (const j of jobs) {
+          logger.log(
+            `${statusColor(j.status)((j.status || "?").padEnd(8))} ${j.jobId}  ${chalk.gray(j.branch)}  ${j.task}`,
+          );
+        }
+      } catch (err) {
+        logger.error(err.message);
+        process.exitCode = 1;
+      }
+    });
+}
+
+async function attachJob(id, options = {}) {
+  const { CloudClient, readJob, saveJob, pollUntilDone } =
+    await import("../lib/cloud/cloud-client.js");
+  const { applyResultPatch, persistResultArtifacts } =
+    await import("../lib/cloud/bundle.js");
+  const { token } = await resolveRunner();
+
+  const job = readJob(id);
+  if (!job) throw new Error(`job not found: ${id}`);
+  const client = new CloudClient({ baseUrl: job.baseUrl, token });
+
+  logger.log(chalk.gray(`Waiting for ${id}…`));
+  const final = await pollUntilDone(client, id, {
+    onTick: (s) =>
+      logger.log(
+        chalk.gray(`  ${s.status}${s.summary ? `: ${s.summary}` : ""}`),
+      ),
+  });
+  saveJob({ ...job, status: final.status, lastSummary: final.summary });
+
+  if (final.status !== "done") {
+    logger.error(`Job ${id} ended ${final.status}: ${final.summary || ""}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const result = await client.result(id);
+
+  // Persist plan/artifacts under the job's local dir.
+  const { cloudJobsDir } = await import("../lib/cloud/cloud-client.js");
+  const destDir = join(cloudJobsDir(), `${id}-result`);
+  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+  const written = persistResultArtifacts(result, destDir);
+
+  let applied = null;
+  if (result.patch && options.apply !== false) {
+    applied = applyResultPatch(result.patch, job.cwd || process.cwd());
+  }
+
+  if (options.json) {
+    return console.log(
+      JSON.stringify(
+        { jobId: id, status: final.status, applied, written, pr: result.pr },
+        null,
+        2,
+      ),
+    );
+  }
+  logger.success(`Job ${id} done`);
+  if (result.pr)
+    logger.log(chalk.magenta(`  PR: ${result.pr.url || result.pr}`));
+  if (applied) {
+    logger.log(
+      applied.applied
+        ? chalk.green(`  patch: ${applied.reason}`)
+        : chalk.yellow(`  patch: ${applied.reason} (saved under ${destDir})`),
+    );
+    if (!applied.applied) {
+      // Save the unapplied patch so the user can resolve it by hand.
+      persistResultArtifacts(
+        { artifacts: [{ name: "result.patch", content: result.patch }] },
+        destDir,
+      );
+    }
+  }
+  for (const w of written) logger.log(chalk.gray(`  wrote ${w}`));
+}

package/src/commands/doctor.js

@@ -1,18 +1,40 @@
 import chalk from "chalk";
 import logger from "../lib/logger.js";
 import { collectDoctorReport } from "../runtime/diagnostics.js";
+import {
+  collectCheckupSections,
+  runCheckupFixes,
+  unsafeFixCommands,
+} from "../lib/doctor-checkup.js";
+
+const LEVEL_ICON = {
+  ok: () => chalk.green("✔"),
+  warn: () => chalk.yellow("⚠"),
+  err: () => chalk.red("✖"),
+  info: () => chalk.gray("·"),
+};
 
 export function registerDoctorCommand(program) {
   program
     .command("doctor")
-    .description("Diagnose your ChainlessChain environment")
+    .alias("checkup")
+    .description("Diagnose your ChainlessChain environment (alias: checkup)")
     .option("--json", "Output as machine-readable JSON")
+    .option("--fix", "Apply safe fixes (stale job files, git worktree prune)")
     .action(async (options) => {
       const report = await collectDoctorReport();
+      const sections = await collectCheckupSections({ cwd: process.cwd() });
+      const fixResults = options.fix ? await runCheckupFixes(sections) : null;
+
+      const checkupErrs = sections
+        .flatMap((s) => s.checks)
+        .filter((c) => c.level === "err").length;
 
       if (options.json) {
-        console.log(JSON.stringify(report, null, 2));
-        if (report.summary.criticalFailed > 0) {
+        console.log(
+          JSON.stringify({ ...report, checkup: sections, fixResults }, null, 2),
+        );
+        if (report.summary.criticalFailed > 0 || checkupErrs > 0) {
           process.exitCode = 1;
         }
         return;
@@ -41,6 +63,17 @@ export function registerDoctorCommand(program) {
         logger.log(`  ${icon} ${check.name}${detail}`);
       }
 
+      // Layered checkup sections (config chain / provider / MCP / IDE /
+      // plugins / subagents / transcripts / background agents / worktrees).
+      for (const section of sections) {
+        logger.log(chalk.bold(`\n  ${section.title}\n`));
+        for (const c of section.checks) {
+          const icon = (LEVEL_ICON[c.level] || LEVEL_ICON.info)();
+          const detail = c.detail ? chalk.gray(` — ${c.detail}`) : "";
+          logger.log(`  ${icon} ${c.name}${detail}`);
+        }
+      }
+
       logger.log(chalk.bold("\n  Port Status\n"));
       for (const p of report.ports) {
         const icon = p.open ? chalk.green("●") : chalk.gray("○");
@@ -54,13 +87,35 @@ export function registerDoctorCommand(program) {
         logger.log(`  ${icon} Free space: ${report.disk.freeGB.toFixed(1)} GB`);
       }
 
+      // Applied fixes (--fix) and copyable commands for the rest.
+      if (fixResults && fixResults.length > 0) {
+        logger.log(chalk.bold("\n  Fixes applied\n"));
+        for (const f of fixResults) {
+          const icon = f.applied ? chalk.green("✔") : chalk.red("✖");
+          logger.log(`  ${icon} ${f.id}: ${f.detail}`);
+        }
+      } else if (options.fix) {
+        logger.log(chalk.gray("\n  No safe fixes needed.\n"));
+      }
+      const manual = unsafeFixCommands(sections);
+      if (manual.length > 0) {
+        logger.log(
+          chalk.bold("\n  Suggested commands (need your judgement)\n"),
+        );
+        for (const m of manual) {
+          logger.log(`  ${chalk.gray("#")} ${m.description}`);
+          logger.log(`    ${chalk.cyan(m.command)}`);
+        }
+      }
+
       logger.newline();
-      if (report.summary.failed === 0) {
+      const totalIssues = report.summary.criticalFailed + checkupErrs;
+      if (report.summary.failed === 0 && checkupErrs === 0) {
         logger.log(chalk.bold.green("  All checks passed!\n"));
-      } else if (report.summary.criticalFailed > 0) {
+      } else if (totalIssues > 0) {
         logger.log(
           chalk.bold.red(
-            `  ${report.summary.criticalFailed} issue(s) found. See details above.\n`,
+            `  ${totalIssues} issue(s) found. See details above.\n`,
           ),
         );
         process.exitCode = 1;

package/src/commands/mcp.js

@@ -342,6 +342,67 @@ export function registerMcpCommand(program) {
       }
     });
 
+  // mcp computer-use — expose GUI control verbs as an MCP server (opt-in)
+  mcp
+    .command("computer-use")
+    .description(
+      "Expose GUI control (screenshot/window-list/click/type/scroll/clipboard/app-launch) as a Streamable-HTTP MCP server. OFF by default; input verbs need confirm:true; high-risk apps (terminals/IDEs/settings/password managers) always confirm",
+    )
+    .option("--port <n>", "Port to listen on (default: random free port)", "0")
+    .option(
+      "--capabilities <list>",
+      "Comma-separated subset (default: all): screenshot,window_list,app_launch,click,type,scroll,clipboard_read,clipboard_write",
+    )
+    .option(
+      "--allow-apps <list>",
+      "Comma-separated app allowlist for input/launch verbs (default: any app)",
+    )
+    .option(
+      "--confirm-all",
+      "Require confirm:true for every verb, not just input verbs",
+    )
+    .option("--token <token>", "Fixed Bearer token (default: random)")
+    .option("--no-auth", "Disable Bearer auth (server binds 127.0.0.1 only)")
+    .action(async (options) => {
+      try {
+        const { startComputerUseServer } =
+          await import("../lib/computer-use/computer-use-server.js");
+        const handle = await startComputerUseServer({
+          port: Number(options.port) || 0,
+          token: options.auth === false ? false : options.token || null,
+          config: {
+            capabilities: options.capabilities
+              ? options.capabilities.split(",").map((s) => s.trim())
+              : undefined,
+            appAllowlist: options.allowApps
+              ? options.allowApps.split(",").map((s) => s.trim())
+              : undefined,
+            confirmAll: options.confirmAll === true,
+          },
+        });
+        logger.log(
+          chalk.bold("Computer-use MCP server ready (Streamable-HTTP)"),
+        );
+        logger.log(`  URL:          ${chalk.cyan(handle.url)}`);
+        logger.log(`  Capabilities: ${handle.capabilities.join(", ")}`);
+        if (handle.token) {
+          logger.log(`  Auth:         Bearer ${handle.token}`);
+        } else {
+          logger.log(chalk.yellow("  Auth:         disabled (--no-auth)"));
+        }
+        logger.log(
+          chalk.yellow(
+            "  ⚠ GUI control can act on anything on screen. Input verbs need confirm:true; high-risk apps always confirm.",
+          ),
+        );
+        logger.log(chalk.gray("\nCtrl+C to stop."));
+        await new Promise(() => {});
+      } catch (err) {
+        logger.error(chalk.red(`mcp computer-use failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
   // mcp servers — list configured servers
   mcp
     .command("servers")