chainlesschain 0.162.35 → 0.162.36

package/src/commands/mcp.js

@@ -65,6 +65,98 @@ export function registerMcpCommand(program) {
     .command("mcp")
     .description("MCP server management and tool execution");
 
+  // mcp login — OAuth 2.0 (Auth Code + PKCE) for a remote MCP server.
+  mcp
+    .command("login <url>")
+    .description("Authorize a remote MCP server via OAuth (opens a browser); stores the token")
+    .option("--scope <scope>", "OAuth scope(s) to request")
+    .option("--client-id <id>", "Use a pre-registered client_id instead of dynamic registration")
+    .option("--port <n>", "Localhost callback port", (v) => parseInt(v, 10), 53682)
+    .option("--no-open", "Print the authorize URL instead of opening a browser")
+    .action(async (url, options) => {
+      try {
+        const oauth = await import("../lib/mcp-oauth.js");
+        if (options.open === false) {
+          oauth._deps.openBrowser = () => false; // commander maps --no-open → open:false
+        }
+        logger.log(chalk.gray(`Authorizing ${url} …`));
+        const rec = await oauth.authorizeInteractive(url, {
+          scope: options.scope,
+          clientId: options.clientId,
+          port: options.port,
+          writeOut: (s) => process.stdout.write(s),
+        });
+        logger.log(
+          chalk.green(`✓ authorized ${rec.server}`) +
+            chalk.gray(
+              rec.expires_at
+                ? `  (expires ${new Date(rec.expires_at).toISOString()})`
+                : "",
+            ),
+        );
+        logger.log(
+          chalk.gray("The token is injected as a Bearer header on connect."),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`mcp login failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // mcp logout — forget a stored OAuth token.
+  mcp
+    .command("logout <url>")
+    .description("Delete the stored OAuth token for a remote MCP server")
+    .action(async (url) => {
+      try {
+        const { deleteStoredToken, serverKey } = await import("../lib/mcp-oauth.js");
+        const ok = deleteStoredToken(url);
+        logger.log(
+          ok
+            ? chalk.green(`✓ removed token for ${serverKey(url)}`)
+            : chalk.gray(`no stored token for ${serverKey(url)}`),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`mcp logout failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // mcp auth — list stored OAuth tokens.
+  mcp
+    .command("auth")
+    .description("List stored MCP OAuth tokens")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { loadTokenStore, isTokenExpired } = await import("../lib/mcp-oauth.js");
+        const store = loadTokenStore();
+        const rows = Object.values(store).map((r) => ({
+          server: r.server,
+          expired: isTokenExpired(r),
+          expires_at: r.expires_at || null,
+          refresh: Boolean(r.refresh_token),
+        }));
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+          return;
+        }
+        if (rows.length === 0) {
+          logger.log(chalk.gray("No MCP OAuth tokens. Run: cc mcp login <url>"));
+          return;
+        }
+        for (const r of rows) {
+          const state = r.expired ? chalk.red("expired") : chalk.green("valid");
+          logger.log(
+            `  ${chalk.cyan(r.server)}  [${state}]${r.refresh ? chalk.gray(" +refresh") : ""}`,
+          );
+        }
+      } catch (err) {
+        logger.error(chalk.red(`mcp auth failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
   // mcp servers — list configured servers
   mcp
     .command("servers")

package/src/commands/output-style.js

@@ -0,0 +1,127 @@
+/**
+ * cc output-style — list / show output-style personas (Claude-Code parity).
+ *
+ *   cc output-style list [--json]      list built-ins + .claude/output-styles/*.md
+ *   cc output-style show <name>        show a style's metadata + body
+ *   cc output-style new <name>         scaffold a new style file
+ *
+ * Apply one with `cc agent --output-style <name>` or the REPL `/output-style`,
+ * or set a default via `outputStyle` in .claude/settings.json.
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+export function registerOutputStyleCommand(program) {
+  const cmd = program
+    .command("output-style")
+    .alias("output-styles")
+    .description("List / show agent output-style personas");
+
+  cmd
+    .command("list", { isDefault: true })
+    .alias("ls")
+    .description("List built-in + .claude/output-styles/*.md personas")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { discoverOutputStyles, settingsDefaultOutputStyle } =
+          await import("../lib/output-styles.js");
+        const all = discoverOutputStyles(process.cwd());
+        const dflt = settingsDefaultOutputStyle(process.cwd());
+        if (options.json) {
+          console.log(JSON.stringify({ default: dflt, styles: all }, null, 2));
+          return;
+        }
+        for (const s of all) {
+          const tag = s.builtin
+            ? chalk.gray("[builtin]")
+            : s.scope === "project"
+              ? chalk.cyan("[proj]")
+              : chalk.gray("[pers]");
+          const star = s.name === dflt ? chalk.green(" *") : "";
+          logger.log(
+            `${chalk.bold(s.name.padEnd(16))} ${tag}${star}  ${chalk.gray(s.description || "")}`,
+          );
+        }
+        if (dflt) logger.log(chalk.dim(`\ndefault (settings.json): ${dflt}`));
+      } catch (err) {
+        logger.error(chalk.red(`output-style list failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command("show <name>")
+    .description("Show a style's metadata and body")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const { getOutputStyle } = await import("../lib/output-styles.js");
+        const s = getOutputStyle(name, process.cwd());
+        if (!s) {
+          logger.error(chalk.red(`no such output style: ${name}`));
+          process.exitCode = 1;
+          return;
+        }
+        if (options.json) {
+          console.log(JSON.stringify(s, null, 2));
+          return;
+        }
+        logger.log(
+          chalk.bold(s.name) +
+            (s.builtin ? chalk.gray("  [builtin]") : chalk.gray(`  [${s.scope}]`)),
+        );
+        if (s.description) logger.log(chalk.gray(`  ${s.description}`));
+        if (s.file) logger.log(chalk.gray(`  file: ${s.file}`));
+        logger.log(chalk.dim("  ───"));
+        logger.log(s.body || chalk.gray("(empty — no persona overlay)"));
+      } catch (err) {
+        logger.error(chalk.red(`output-style show failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command("new <name>")
+    .description("Scaffold a new style under .claude/output-styles/")
+    .option("--description <d>", "Frontmatter description")
+    .option("--personal", "Create under ~/.claude/output-styles instead of project")
+    .action(async (name, options) => {
+      try {
+        const fs = await import("node:fs");
+        const path = await import("node:path");
+        const { homedir } = await import("node:os");
+        const safe = String(name).replace(/[^\w.-]/g, "-");
+        const root = options.personal
+          ? path.join(homedir(), ".claude", "output-styles")
+          : path.join(process.cwd(), ".claude", "output-styles");
+        const file = path.join(root, `${safe}.md`);
+        if (fs.existsSync(file)) {
+          logger.error(chalk.red(`already exists: ${file}`));
+          process.exitCode = 1;
+          return;
+        }
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const tpl = `---
+name: ${safe}
+description: ${options.description || name}
+---
+
+## Output style: ${safe}
+
+Describe how the agent should behave in this style. This text is appended to
+the system prompt (after the base coding instructions), so keep it focused on
+*behaviour / tone*, not tool mechanics.
+`;
+        fs.writeFileSync(file, tpl, "utf-8");
+        logger.log(chalk.green(`✓ created ${file}`));
+        logger.log(
+          chalk.gray(`  use it: cc agent --output-style ${safe} -p "..."`),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`output-style new failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/permissions.js

@@ -0,0 +1,211 @@
+/**
+ * cc permissions — inspect, dry-run, and edit the `.claude/settings.json`
+ * permission ruleset (Claude-Code `permissions.{allow,ask,deny}` parity).
+ *
+ *   cc permissions list [--json]                merged ruleset + source file
+ *   cc permissions test <tool> <args...>        dry-run: which rule decides?
+ *   cc permissions add <allow|ask|deny> <rule>  append a rule to a settings file
+ *       [--local | --user]                      (default target: project)
+ *
+ * The ruleset is loaded by settings-loader (user < project < local < env) and
+ * evaluated by permission-rules (deny > ask > allow). This command only reads
+ * and edits the files / runs the engine — it does not yet gate the agent tool
+ * loop (that wiring is a separate, riskier step).
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+const KIND_COLOR = {
+  allow: chalk.green,
+  ask: chalk.yellow,
+  deny: chalk.red,
+};
+
+/** Resolve an umbrella token (Bash) to a concrete tool name for dry-run. */
+function resolveConcreteTool(token, groups) {
+  const t = String(token || "");
+  const lower = t.toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(groups, lower)) {
+    return groups[lower][0];
+  }
+  return t;
+}
+
+/** Build the tool args object a dry-run target needs from positional args. */
+function buildArgs(tool, positional, rulesMod) {
+  const joined = positional.join(" ").trim();
+  if (rulesMod.COMMAND_TOOLS.has(tool)) return { command: joined };
+  if (rulesMod.PATH_TOOLS.has(tool)) return { path: positional[0] || "" };
+  if (rulesMod.URL_TOOLS.has(tool)) return { url: positional[0] || "" };
+  return {};
+}
+
+export function registerPermissionsCommand(program) {
+  const cmd = program
+    .command("permissions")
+    .alias("perms")
+    .description(
+      "Inspect / dry-run / edit .claude/settings.json permission rules",
+    );
+
+  // ── list ──────────────────────────────────────────────────────────────
+  cmd
+    .command("list")
+    .alias("ls")
+    .description("Show the merged permission ruleset and where each rule came from")
+    .option("--json", "Output as JSON")
+    .option("--settings <file>", "Also merge an explicit settings file")
+    .action(async (options) => {
+      try {
+        const { loadSettings } = await import("../lib/settings-loader.cjs");
+        const { rules, sources, files } = loadSettings({
+          cwd: process.cwd(),
+          settingsFile: options.settings,
+        });
+        if (options.json) {
+          console.log(JSON.stringify({ rules, sources, files }, null, 2));
+          return;
+        }
+        const total =
+          rules.allow.length + rules.ask.length + rules.deny.length;
+        if (total === 0) {
+          logger.log(
+            chalk.gray(
+              "No permission rules. Add one: cc permissions add deny \"Bash(rm:*)\"\n" +
+                "(or create .claude/settings.json with a permissions block)",
+            ),
+          );
+          return;
+        }
+        for (const kind of ["deny", "ask", "allow"]) {
+          if (rules[kind].length === 0) continue;
+          logger.log(KIND_COLOR[kind].bold(`${kind} (${rules[kind].length})`));
+          for (const rule of rules[kind]) {
+            const src = sources[`${kind}:${rule}`] || "?";
+            logger.log(`  ${rule.padEnd(34)} ${chalk.gray(src)}`);
+          }
+        }
+        if (files.length) {
+          logger.log(chalk.dim(`\nsources: ${files.join(", ")}`));
+        }
+      } catch (err) {
+        logger.error(chalk.red(`permissions list failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── test (dry-run) ─────────────────────────────────────────────────────
+  cmd
+    .command("test <tool> [args...]")
+    .description(
+      'Dry-run a tool call against the ruleset, e.g. permissions test run_shell "git push"',
+    )
+    .option("--json", "Output as JSON")
+    .option("--settings <file>", "Also merge an explicit settings file")
+    .action(async (tool, args, options) => {
+      try {
+        const { loadSettings, ruleSource } =
+          await import("../lib/settings-loader.cjs");
+        // .cjs default-export interop: module.exports surfaces as `.default`.
+        const rulesMod = await import("../lib/permission-rules.cjs");
+        const mod = rulesMod.default || rulesMod;
+
+        const { rules, sources } = loadSettings({
+          cwd: process.cwd(),
+          settingsFile: options.settings,
+        });
+        const concrete = resolveConcreteTool(tool, mod.TOOL_GROUPS);
+        const toolArgs = buildArgs(concrete, args || [], mod);
+        const result = mod.evaluatePermissionRules({
+          tool: concrete,
+          args: toolArgs,
+          cwd: process.cwd(),
+          rules,
+        });
+        const decision = result.decision || "fallthrough";
+        const source = result.rule
+          ? ruleSource(sources, result.decision, result.rule)
+          : null;
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { tool: concrete, args: toolArgs, decision, rule: result.rule, source },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+
+        const color = KIND_COLOR[result.decision] || chalk.gray;
+        logger.log(
+          `${chalk.bold(concrete)} ${chalk.gray(JSON.stringify(toolArgs))}`,
+        );
+        logger.log(`  decision: ${color.bold(decision)}`);
+        if (result.rule) {
+          logger.log(`  rule:     ${result.rule}`);
+          if (source) logger.log(`  source:   ${chalk.gray(source)}`);
+        } else {
+          logger.log(
+            chalk.gray(
+              "  no rule matched → falls back to risk-tier / --permission-mode logic",
+            ),
+          );
+        }
+      } catch (err) {
+        logger.error(chalk.red(`permissions test failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── add ────────────────────────────────────────────────────────────────
+  cmd
+    .command("add <decision> <rule>")
+    .description("Append a rule (allow|ask|deny) to a settings file")
+    .option("--local", "Write to .claude/settings.local.json (personal, gitignored)")
+    .option("--user", "Write to ~/.claude/settings.json (all projects)")
+    .action(async (decision, rule, options) => {
+      try {
+        const kind = String(decision || "").toLowerCase();
+        if (!["allow", "ask", "deny"].includes(kind)) {
+          logger.error(
+            chalk.red(`decision must be allow | ask | deny (got "${decision}")`),
+          );
+          process.exitCode = 1;
+          return;
+        }
+        const rulesMod = await import("../lib/permission-rules.cjs");
+        const mod = rulesMod.default || rulesMod;
+        if (!mod.parseRule(rule)) {
+          logger.error(
+            chalk.red(
+              `not a valid rule: "${rule}" (expected Tool or Tool(pattern), e.g. Bash(rm:*))`,
+            ),
+          );
+          process.exitCode = 1;
+          return;
+        }
+
+        const scope = options.user ? "user" : options.local ? "local" : "project";
+        const { addRule } = await import("../lib/settings-loader.cjs");
+        const { file, added } = addRule({
+          cwd: process.cwd(),
+          kind,
+          rule,
+          scope,
+        });
+        if (!added) {
+          logger.log(chalk.gray(`already present in ${file}: ${kind} ${rule}`));
+          return;
+        }
+        logger.log(
+          `${KIND_COLOR[kind].bold("✓ " + kind)} ${rule} ${chalk.gray("→ " + file)}`,
+        );
+      } catch (err) {
+        logger.error(chalk.red(`permissions add failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/statusline.js

@@ -0,0 +1,93 @@
+/**
+ * cc statusline — preview the configured `statusLine` (Claude-Code parity).
+ *
+ *   cc statusline            preview the rendered status line
+ *   cc statusline show       show the resolved config (+ source)
+ *
+ * Configure in .claude/settings.json:
+ *   { "statusLine": { "type": "command", "command": "~/.claude/status.sh" } }
+ * The command receives a JSON context on stdin and its first stdout line is the
+ * status line (shown above the REPL prompt each turn).
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+export function registerStatuslineCommand(program) {
+  const cmd = program
+    .command("statusline")
+    .alias("status-line")
+    .description("Preview / show the .claude/settings.json statusLine");
+
+  cmd
+    .command("preview", { isDefault: true })
+    .description("Render the configured status line once")
+    .option("--model <m>", "Model to pass in the context", "opus")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { loadStatusLineConfig, buildContext, renderStatusLine } =
+          await import("../lib/status-line.cjs");
+        const cfg = loadStatusLineConfig({ cwd: process.cwd() });
+        if (!cfg) {
+          logger.log(
+            chalk.gray(
+              'No statusLine configured. Add to .claude/settings.json:\n' +
+                '  { "statusLine": { "type": "command", "command": "./status.sh" } }',
+            ),
+          );
+          return;
+        }
+        const line = renderStatusLine(
+          cfg,
+          buildContext({
+            sessionId: "preview",
+            model: options.model,
+            cwd: process.cwd(),
+          }),
+          { cwd: process.cwd() },
+        );
+        if (options.json) {
+          console.log(JSON.stringify({ config: cfg, line }, null, 2));
+          return;
+        }
+        if (line == null) {
+          logger.error(
+            chalk.red(
+              `statusLine command produced no output (or failed): ${cfg.command}`,
+            ),
+          );
+          process.exitCode = 1;
+          return;
+        }
+        process.stdout.write(line + "\n");
+      } catch (err) {
+        logger.error(chalk.red(`statusline preview failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command("show")
+    .description("Show the resolved statusLine config")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { loadStatusLineConfig } = await import("../lib/status-line.cjs");
+        const cfg = loadStatusLineConfig({ cwd: process.cwd() });
+        if (options.json) {
+          console.log(JSON.stringify(cfg, null, 2));
+          return;
+        }
+        if (!cfg) {
+          logger.log(chalk.gray("No statusLine configured."));
+          return;
+        }
+        logger.log(`command: ${chalk.cyan(cfg.command)}`);
+        logger.log(chalk.gray(`type: ${cfg.type}  padding: ${cfg.padding}`));
+      } catch (err) {
+        logger.error(chalk.red(`statusline show failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/index.js

@@ -58,11 +58,14 @@ import { registerRCacheCommand } from "./commands/rcache.js";
 import { registerSessionCommand } from "./commands/session.js";
 import { registerCostCommand } from "./commands/cost.js";
 import { registerContextCommand } from "./commands/context.js";
-import { registerAgentsCommand } from "./commands/agents.js";
 import { registerCheckpointCommand } from "./commands/checkpoint.js";
 import { registerGoalCommand } from "./commands/goal.js";
 import { registerCommandCommand } from "./commands/command.js";
 import { registerCompactCommand } from "./commands/compact.js";
+import { registerPermissionsCommand } from "./commands/permissions.js";
+import { registerOutputStyleCommand } from "./commands/output-style.js";
+import { registerStatuslineCommand } from "./commands/statusline.js";
+import { registerIdeCommand } from "./commands/ide.js";
 import { registerConsolCommand } from "./commands/consol.js";
 import { registerImportCommand } from "./commands/import.js";
 import { registerExportCommand } from "./commands/export.js";
@@ -457,11 +460,14 @@ export function createProgram(opts = {}) {
   registerSessionCommand(program);
   registerCostCommand(program);
   registerContextCommand(program);
-  registerAgentsCommand(program);
   registerCheckpointCommand(program);
   registerGoalCommand(program);
   registerCommandCommand(program);
   registerCompactCommand(program);
+  registerPermissionsCommand(program);
+  registerOutputStyleCommand(program);
+  registerStatuslineCommand(program);
+  registerIdeCommand(program);
   registerConsolCommand(program);
 
   // Phase 2: Knowledge & content management

package/src/lib/agent-core.js

@@ -24,5 +24,12 @@ export {
   agentLoop,
   formatToolArgs,
   getActiveMcpServers,
+  listBackgroundShellTasks,
+  killAllBackgroundShellTasks,
   _accumulateOllamaStream,
+  _accumulateOpenAIStream,
+  _accumulateAnthropicStream,
+  _toAnthropicMessages,
+  _anthropicThinkingParams,
+  _normalizeAnthropicResponse,
 } from "../runtime/agent-core.js";

package/src/lib/agents.js

@@ -57,7 +57,12 @@ export function normalizeTools(tools) {
 export function agentDirs(cwd = process.cwd(), opts = {}) {
   const path = opts.deps?.path || _deps.path;
   const home = opts.home || homedir();
+  // Project-native first (highest precedence), then the Claude-Code-portable
+  // location (so existing `.claude/agents/*.md` work unchanged), then personal.
+  // discoverAgents reverses + last-write-wins, so `.chainlesschain/agents/`
+  // shadows `.claude/agents/` shadows `~/.claude/agents/` on a name clash.
   return [
+    { dir: path.join(cwd, ".chainlesschain", "agents"), scope: "project" },
     { dir: path.join(cwd, ".claude", "agents"), scope: "project" },
     { dir: path.join(home, ".claude", "agents"), scope: "personal" },
   ];

package/src/lib/hook-manager.js

@@ -40,6 +40,7 @@ export const HookEvents = {
   SessionEnd: "SessionEnd",
   PreCompact: "PreCompact",
   PostCompact: "PostCompact",
+  Notification: "Notification",
   UserPromptSubmit: "UserPromptSubmit",
   AssistantResponse: "AssistantResponse",
   AgentStart: "AgentStart",