chainlesschain 0.162.158 → 0.162.160

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")
@@ -938,6 +999,52 @@ export function registerMcpCommand(program) {
     });
 
   // mcp scaffold — generate a boilerplate MCP server project
+  mcp
+    .command("trust-project")
+    .description(
+      "Re-trust the project .mcp.json after reviewing a content change (records its fingerprint for --project-mcp runs)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const fsMod = await import("node:fs");
+        const { projectRootBase } = await import("../lib/project-root.cjs");
+        const { recordProjectMcpTrust, projectMcpFingerprint } =
+          await import("../lib/project-mcp-trust.js");
+        const cwd = process.cwd();
+        const candidates = [path.join(cwd, ".mcp.json")];
+        const root = projectRootBase(cwd, { fs: fsMod.default, path });
+        if (root) candidates.push(path.join(root, ".mcp.json"));
+        const results = [];
+        for (const file of [...new Set(candidates)]) {
+          if (!fsMod.existsSync(file)) continue;
+          const content = fsMod.readFileSync(file, "utf-8");
+          const ok = recordProjectMcpTrust(file, content);
+          results.push({
+            file,
+            trusted: ok,
+            fingerprint: projectMcpFingerprint(content).slice(0, 16),
+          });
+        }
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+          return;
+        }
+        if (results.length === 0) {
+          console.log("No .mcp.json found in this project.");
+          return;
+        }
+        for (const r of results) {
+          console.log(
+            `${r.trusted ? "Trusted" : "FAILED to record"} ${r.file} (${r.fingerprint})`,
+          );
+        }
+      } catch (err) {
+        console.error(`Failed: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
   mcp
     .command("scaffold <name>")
     .description("Scaffold a new MCP server project (stdio or http+sse)")

package/src/commands/plugin.js

@@ -538,10 +538,61 @@ export function registerPluginCommand(program) {
 
       const counts = summarizeComponents(manifest);
 
+      // Dependency version constraints (gap P2#13): if the manifest declares
+      // `dependencies` (plugin name → semver range, plus reserved host/cc),
+      // check them against what's installed and the running cc version. Unmet
+      // deps are surfaced but do not by themselves fail structural validation —
+      // they may simply be absent in this environment.
+      let dependencyCheck = null;
+      try {
+        const rawManifest = manifest.manifestPath
+          ? JSON.parse(
+              (await import("node:fs")).readFileSync(
+                manifest.manifestPath,
+                "utf8",
+              ),
+            )
+          : {};
+        if (rawManifest && rawManifest.dependencies) {
+          const { checkPluginDependencies, formatDependencyIssues } =
+            await import("../lib/plugin-runtime/governance.js");
+          const { discoverPlugins } =
+            await import("../lib/plugin-runtime/scopes.js");
+          const { VERSION } = await import("../constants.js");
+          const installed = {};
+          try {
+            for (const p of discoverPlugins({ skipPolicy: true })) {
+              installed[p.name] = p.version;
+            }
+          } catch {
+            /* discovery best-effort */
+          }
+          const result = checkPluginDependencies(rawManifest, {
+            installed,
+            hostVersion: VERSION,
+          });
+          dependencyCheck = {
+            ok: result.ok,
+            issues: formatDependencyIssues(
+              manifest.metadata?.name || dir,
+              result,
+            ),
+            ...result,
+          };
+        }
+      } catch {
+        /* dependency inspection is best-effort */
+      }
+
       if (options.json) {
         console.log(
           JSON.stringify(
-            { ...manifest, componentCounts: counts, verification },
+            {
+              ...manifest,
+              componentCounts: counts,
+              verification,
+              dependencyCheck,
+            },
             null,
             2,
           ),
@@ -570,6 +621,17 @@ export function registerPluginCommand(program) {
             (verification.ok ? chalk.green("passed") : chalk.red("FAILED")),
         );
       }
+      if (dependencyCheck) {
+        logger.log(
+          chalk.bold("\nDependencies: ") +
+            (dependencyCheck.ok
+              ? chalk.green("satisfied")
+              : chalk.yellow("unmet")),
+        );
+        for (const issue of dependencyCheck.issues) {
+          logger.log(chalk.yellow(`  ⚠ ${issue}`));
+        }
+      }
       for (const w of manifest.warnings) logger.log(chalk.yellow(`  ⚠ ${w}`));
       for (const e of manifest.errors) logger.log(chalk.red(`  ✖ ${e}`));
       if (manifest.ok) {