chainlesschain 0.162.162 → 0.162.164

package/src/commands/plugin.js

@@ -30,6 +30,135 @@ import {
   getPluginSkills,
 } from "../harness/plugin-manager.js";
 
+/**
+ * After an install/upgrade, resolve the just-installed plugin's DECLARED
+ * capabilities and its current consent status, so `cc plugin add`/`upgrade`
+ * surface a capability list + diff and tell the user when a WIDENING requires
+ * re-consent (mirroring `cc plugin consent`). Best-effort: capability rendering
+ * must never fail an otherwise-successful install. Returns a structured summary
+ * (for --json folding) or null when the plugin declares nothing / can't be
+ * resolved.
+ */
+async function resolvePluginCapabilityNotice(name, scope, cwd) {
+  try {
+    const { discoverPlugins } = await import("../lib/plugin-runtime/scopes.js");
+    const { describeCapabilities } =
+      await import("../lib/plugin-runtime/capabilities.js");
+    const consent = await import("../lib/plugin-runtime/capability-consent.js");
+    const installed = discoverPlugins({ cwd, skipPolicy: true }).find(
+      (p) => p.name === name && p.scope === scope,
+    );
+    if (!installed) return null;
+    const declared = installed.manifest?.capabilities;
+    if (!declared || consent.capabilitiesAreEmpty(declared)) return null;
+    const entry = consent.loadConsentStore()[`${scope}:${name}`] || null;
+    const status = consent.capabilityConsentStatus(declared, entry);
+    return {
+      declared: describeCapabilities(declared),
+      consented: status.consented,
+      reason: status.reason,
+      added: status.added,
+    };
+  } catch {
+    return null; // capability rendering is advisory — never break an install
+  }
+}
+
+/**
+ * Print the capability notice (text mode) after an install/upgrade. Pass
+ * `{ hint: false }` to omit the trailing `cc plugin consent … --grant` pointer
+ * when consent is being granted inline (explicit flag or interactive prompt).
+ */
+function printPluginCapabilityNotice(name, notice, { hint = true } = {}) {
+  if (!notice) return;
+  logger.log(chalk.bold("\nCapabilities (declared):"));
+  for (const l of notice.declared) logger.log(`  ${chalk.magenta(l)}`);
+  if (notice.consented) {
+    logger.log(chalk.gray(`  capability consent: ${notice.reason}`));
+    return;
+  }
+  logger.log(
+    chalk.yellow(`  ⚠ capability consent required (${notice.reason})`),
+  );
+  if (notice.added.length)
+    logger.log(chalk.yellow(`    new: ${notice.added.join(", ")}`));
+  if (hint)
+    logger.log(
+      chalk.dim(`    run \`cc plugin consent ${name} --grant\` to allow them`),
+    );
+}
+
+/**
+ * Record consent for a freshly installed/upgraded plugin's currently-declared
+ * capabilities (re-discovers to get the raw declared set + version). Best-effort
+ * — returns false rather than throwing so it can never break an install.
+ */
+async function grantInstalledPluginCapabilities(name, scope, cwd) {
+  try {
+    const { discoverPlugins } = await import("../lib/plugin-runtime/scopes.js");
+    const consent = await import("../lib/plugin-runtime/capability-consent.js");
+    const installed = discoverPlugins({ cwd, skipPolicy: true }).find(
+      (p) => p.name === name && p.scope === scope,
+    );
+    if (!installed) return false;
+    const declared = installed.manifest?.capabilities;
+    if (!declared || consent.capabilitiesAreEmpty(declared)) return false;
+    consent.consentPluginCapabilities(name, {
+      scope,
+      version: installed.version,
+      capabilities: declared,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Handle the capability-consent gate after a text-mode install/upgrade: print
+ * the notice and, when consent is required, either auto-grant (explicit
+ * `--grant-capabilities`) or block interactively (TTY) to grant it right away
+ * instead of forcing a separate `cc plugin consent --grant` step. Returns true
+ * if consent was recorded during this call.
+ */
+async function applyCapabilityConsentGate(name, scope, notice, cwd, opts = {}) {
+  const consent = await import("../lib/plugin-runtime/capability-consent.js");
+  const action = consent.resolveConsentAction(notice, {
+    grant: opts.grant === true,
+    interactive: opts.interactive === true,
+  });
+  if (action === "advisory") {
+    printPluginCapabilityNotice(name, notice);
+    return false;
+  }
+  // Show the ⚠ notice + new-capability diff before deciding; suppress the
+  // "run cc plugin consent" pointer since we grant inline here.
+  printPluginCapabilityNotice(name, notice, { hint: false });
+  if (action === "prompt") {
+    let ok = false;
+    try {
+      const { confirm } = await import("@inquirer/prompts");
+      ok = await confirm({
+        message: `Grant these capabilities to ${name} now?`,
+        default: false,
+      });
+    } catch {
+      ok = false; // Ctrl-C / non-interactive → treat as decline (fail closed)
+    }
+    if (!ok) {
+      logger.log(
+        chalk.dim(
+          "    capabilities not granted — components needing them stay disabled",
+        ),
+      );
+      return false;
+    }
+  }
+  const granted = await grantInstalledPluginCapabilities(name, scope, cwd);
+  if (granted) logger.success(`  ✔ capability consent granted for ${name}`);
+  return granted;
+}
+
 export function registerPluginCommand(program) {
   const plugin = program
     .command("plugin")
@@ -632,6 +761,17 @@ export function registerPluginCommand(program) {
           logger.log(chalk.yellow(`  ⚠ ${issue}`));
         }
       }
+      // Declared capabilities (Phase 3 gap): show what the plugin says it needs
+      // so a user can compare against the components it ships (the audit findings
+      // for an under-declared manifest already surface in manifest.warnings).
+      if (manifest.capabilitiesDeclared) {
+        const { describeCapabilities } =
+          await import("../lib/plugin-runtime/capabilities.js");
+        const capLines = describeCapabilities(manifest.capabilities);
+        logger.log(chalk.bold("\nCapabilities (declared):"));
+        if (capLines.length === 0) logger.log(chalk.gray("  (none)"));
+        for (const l of capLines) logger.log(`  ${chalk.magenta(l)}`);
+      }
       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) {
@@ -674,6 +814,10 @@ export function registerPluginCommand(program) {
       "--allow-insecure-registry",
       "Allow a plain-HTTP registry URL (MITM risk — trusted networks only)",
     )
+    .option(
+      "--grant-capabilities",
+      "Grant the plugin's declared capabilities at install time (no separate consent step)",
+    )
     .option("--json", "Output as JSON")
     .action(async (source, options) => {
       const { installFromSource } =
@@ -736,8 +880,28 @@ export function registerPluginCommand(program) {
           force: options.force === true,
           signature,
         });
+        const capNotice = await resolvePluginCapabilityNotice(
+          res.name,
+          res.scope,
+          process.cwd(),
+        );
         if (options.json) {
-          console.log(JSON.stringify(res, null, 2));
+          // Non-interactive JSON path: honor an explicit --grant-capabilities so
+          // scripted installs can consent atomically; never prompt.
+          let capabilitiesGranted = false;
+          if (options.grantCapabilities && capNotice && !capNotice.consented)
+            capabilitiesGranted = await grantInstalledPluginCapabilities(
+              res.name,
+              res.scope,
+              process.cwd(),
+            );
+          console.log(
+            JSON.stringify(
+              { ...res, capabilities: capNotice, capabilitiesGranted },
+              null,
+              2,
+            ),
+          );
         } else {
           logger.success(
             `Installed ${res.name} v${res.version} (${res.scope} scope)` +
@@ -746,6 +910,16 @@ export function registerPluginCommand(program) {
           logger.log(chalk.gray(`  → ${res.dir}`));
           for (const w of res.warnings || [])
             logger.log(chalk.yellow(`  ⚠ ${w}`));
+          await applyCapabilityConsentGate(
+            res.name,
+            res.scope,
+            capNotice,
+            process.cwd(),
+            {
+              grant: options.grantCapabilities === true,
+              interactive: Boolean(process.stdin.isTTY),
+            },
+          );
         }
       } catch (err) {
         logger.error(`Install failed: ${err.message}`);
@@ -905,6 +1079,265 @@ export function registerPluginCommand(program) {
       }
     });
 
+  // plugin consent [name] — view / grant a plugin's CAPABILITY consent
+  // (process / network / filesystem / mcp / monitor / credential). Distinct from
+  // `trust`, which pins the code VERSION: consent pins the capability SET, and
+  // any widening re-prompts even for an already-trusted plugin.
+  plugin
+    .command("consent [name]")
+    .description(
+      "View or grant a plugin's capability consent (--grant / --revoke / --list)",
+    )
+    .option("--scope <scope>", "Scope of the plugin", "project")
+    .option(
+      "--grant",
+      "Grant consent for the plugin's currently-declared capabilities",
+    )
+    .option("--revoke", "Revoke capability consent")
+    .option("--list", "List all capability consent entries")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      const consent =
+        await import("../lib/plugin-runtime/capability-consent.js");
+      const { describeCapabilities } =
+        await import("../lib/plugin-runtime/capabilities.js");
+
+      if (!name || options.list) {
+        const rows = consent.listCapabilityConsent();
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+          return;
+        }
+        if (rows.length === 0) {
+          logger.info("No capability consent recorded.");
+          return;
+        }
+        logger.log(chalk.bold(`Capability consent (${rows.length}):`));
+        for (const r of rows) {
+          logger.log(`  ${chalk.cyan(r.name)} v${r.version} [${r.scope}]`);
+          for (const c of r.capabilities) logger.log(`    ${chalk.magenta(c)}`);
+        }
+        return;
+      }
+
+      if (options.revoke) {
+        const res = consent.revokeCapabilityConsent(name, {
+          scope: options.scope,
+        });
+        if (res.removed) {
+          logger.success(
+            `Revoked capability consent for ${name} (${options.scope} scope)`,
+          );
+        } else {
+          logger.info(
+            `${name} had no capability consent at ${options.scope} scope`,
+          );
+        }
+        return;
+      }
+
+      // Resolve the installed plugin + its declared capabilities.
+      const { discoverPlugins } =
+        await import("../lib/plugin-runtime/scopes.js");
+      let installed = null;
+      try {
+        installed = discoverPlugins({
+          cwd: process.cwd(),
+          skipPolicy: true,
+        }).find((p) => p.name === name && p.scope === options.scope);
+      } catch {
+        /* discovery best-effort */
+      }
+      if (!installed) {
+        logger.error(`${name} is not installed at ${options.scope} scope`);
+        process.exitCode = 1;
+        return;
+      }
+      const declared = installed.manifest?.capabilities;
+      const entry =
+        consent.loadConsentStore()[`${options.scope}:${name}`] || null;
+      const status = consent.capabilityConsentStatus(declared, entry);
+
+      if (options.grant) {
+        consent.consentPluginCapabilities(name, {
+          scope: options.scope,
+          version: installed.version,
+          capabilities: declared,
+        });
+        const capLines = describeCapabilities(declared);
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                granted: true,
+                name,
+                scope: options.scope,
+                version: installed.version,
+                capabilities: capLines,
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+        logger.success(
+          `Granted capability consent for ${name} v${installed.version} (${options.scope} scope)`,
+        );
+        for (const l of capLines) logger.log(`    ${chalk.magenta(l)}`);
+        return;
+      }
+
+      // Show status.
+      const capLines = describeCapabilities(declared);
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              name,
+              scope: options.scope,
+              version: installed.version,
+              declared: capLines,
+              ...status,
+            },
+            null,
+            2,
+          ),
+        );
+        return;
+      }
+      logger.log(
+        chalk.bold("Capability consent: ") +
+          `${chalk.cyan(name)} v${installed.version} [${options.scope}]`,
+      );
+      logger.log(chalk.bold("Declared capabilities:"));
+      if (capLines.length === 0) logger.log(chalk.gray("  (none)"));
+      for (const l of capLines) logger.log(`  ${chalk.magenta(l)}`);
+      logger.log(
+        chalk.bold("Status: ") +
+          (status.consented
+            ? chalk.green("consented")
+            : chalk.yellow("NEEDS CONSENT")),
+      );
+      logger.log(chalk.gray(`  ${status.reason}`));
+      if (status.added.length) {
+        logger.log(
+          chalk.yellow(`  new since consent: ${status.added.join(", ")}`),
+        );
+      }
+      if (!status.consented) {
+        logger.log(
+          chalk.dim(
+            `  run \`cc plugin consent ${name} --grant\` to allow them`,
+          ),
+        );
+      }
+    });
+
+  // plugin options — view a plugin's resolved typed options, or set values at a
+  // scope. The security-critical rule: a SENSITIVE option can never be set from
+  // PROJECT scope (a checked-in file must not inject secrets) — such values are
+  // dropped + warned; use `--scope user`.
+  plugin
+    .command("options <name>")
+    .description(
+      "View or set a plugin's typed options (--set key=value, --scope user|project)",
+    )
+    .option("--scope <scope>", "Scope for --set (user|project)", "user")
+    .option(
+      "--set <pair>",
+      "Set an option value (key=value); repeatable",
+      (v, acc) => {
+        acc.push(v);
+        return acc;
+      },
+      [],
+    )
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      const { discoverPlugins } =
+        await import("../lib/plugin-runtime/scopes.js");
+      const optsMod = await import("../lib/plugin-runtime/plugin-options.js");
+
+      let installed = null;
+      try {
+        installed = discoverPlugins({
+          cwd: process.cwd(),
+          skipPolicy: true,
+        }).find((p) => p.name === name);
+      } catch {
+        /* discovery best-effort */
+      }
+      if (!installed) {
+        logger.error(`${name} is not installed`);
+        process.exitCode = 1;
+        return;
+      }
+      const schema = installed.manifest?.optionsSchema || {};
+
+      // --set: persist values at the requested scope (then fall through to show).
+      if (options.set && options.set.length) {
+        const scope = options.scope === "project" ? "project" : "user";
+        const current = optsMod.loadPluginOptionValues(name, scope, {
+          cwd: process.cwd(),
+        });
+        for (const pair of options.set) {
+          const eq = pair.indexOf("=");
+          if (eq <= 0) {
+            logger.error(`Invalid --set "${pair}" (expected key=value)`);
+            process.exitCode = 1;
+            return;
+          }
+          current[pair.slice(0, eq)] = pair.slice(eq + 1);
+        }
+        optsMod.setPluginOptionValues(name, current, scope, {
+          cwd: process.cwd(),
+        });
+        logger.success(`Set option(s) for ${name} at ${scope} scope`);
+      }
+
+      const resolved = optsMod.getResolvedPluginOptions(name, schema, {
+        cwd: process.cwd(),
+      });
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              name,
+              scope: installed.scope,
+              options: resolved.redacted,
+              sources: resolved.sources,
+              warnings: resolved.warnings,
+              droppedFromProject: resolved.droppedFromProject,
+            },
+            null,
+            2,
+          ),
+        );
+        return;
+      }
+      logger.log(chalk.bold(`Options: ${chalk.cyan(name)}`));
+      const keys = Object.keys(resolved.redacted);
+      if (keys.length === 0) logger.log(chalk.gray("  (no options)"));
+      for (const k of keys) {
+        logger.log(
+          `  ${chalk.cyan(k)} = ${resolved.redacted[k]} ${chalk.gray(
+            `[${resolved.sources[k] || "default"}]`,
+          )}`,
+        );
+      }
+      if (resolved.droppedFromProject.length) {
+        logger.log(
+          chalk.yellow(
+            `  ⚠ dropped from project config (sensitive/user-only): ${resolved.droppedFromProject.join(
+              ", ",
+            )} — set with --scope user`,
+          ),
+        );
+      }
+      for (const w of resolved.warnings) logger.log(chalk.gray(`  ${w}`));
+    });
+
   // plugin monitors — list (and optionally run) trusted plugins' background
   // monitors. `--run --seconds N` actually starts the supervisor for N seconds,
   // prints captured output, then reaps everything (verifies no leaked process).
@@ -991,6 +1424,10 @@ export function registerPluginCommand(program) {
     )
     .option("--scope <scope>", `Scope to update in (${SCOPES})`, "user")
     .option("--force", "Reinstall even if the version is unchanged")
+    .option(
+      "--grant-capabilities",
+      "Grant any newly declared capabilities during the upgrade (no separate consent step)",
+    )
     .action(async (source, options) => {
       const { updatePlugin } = await import("../lib/plugin-runtime/install.js");
       try {
@@ -1012,6 +1449,24 @@ export function registerPluginCommand(program) {
             `${res.name} is already up to date at v${res.version} (use --force to reinstall)`,
           );
         }
+        // Surface the (possibly widened) capability set + re-consent hint. An
+        // upgrade that adds a capability shows a `⚠ capability consent required`
+        // notice diffed against the prior consent, then either auto-grants
+        // (--grant-capabilities) or blocks interactively to re-consent now.
+        await applyCapabilityConsentGate(
+          res.name,
+          options.scope,
+          await resolvePluginCapabilityNotice(
+            res.name,
+            options.scope,
+            process.cwd(),
+          ),
+          process.cwd(),
+          {
+            grant: options.grantCapabilities === true,
+            interactive: Boolean(process.stdin.isTTY),
+          },
+        );
       } catch (err) {
         logger.error(`Upgrade failed: ${err.message}`);
         process.exitCode = 1;