chainlesschain 0.162.34 → 0.162.36

package/src/commands/ide.js

@@ -0,0 +1,168 @@
+/**
+ * `cc ide` — inspect IDE bridge discovery (Phase 0).
+ *
+ * The agent auto-connects a running editor's MCP server when inside an IDE
+ * integrated terminal (or with `cc agent --ide`). These subcommands make that
+ * discovery visible and debuggable WITHOUT running an agent:
+ *
+ *   cc ide list             list live IDE lockfiles found
+ *   cc ide status           which server `cc agent` would connect to (+ its MCP config)
+ *   cc ide doctor           explain WHY discovery did / didn't pick a server
+ *
+ * Pure read-only over ~/.chainlesschain/ide/*.json — see
+ * docs/design/modules/98_IDE桥接对标方案.md.
+ */
+import chalk from "chalk";
+import {
+  readIdeLocks,
+  discoverIdeServer,
+  ideServerToMcpConfig,
+  isInIdeTerminal,
+  ideLockDir,
+  diagnoseIde,
+} from "../lib/ide-bridge.js";
+
+function emit(obj) {
+  console.log(JSON.stringify(obj, null, 2));
+}
+
+export function registerIdeCommand(program) {
+  const ide = program
+    .command("ide")
+    .description("Inspect IDE bridge discovery (editor MCP server auto-connect)");
+
+  ide
+    .command("list")
+    .description("List live IDE lockfiles (editor MCP servers advertised)")
+    .option("--json", "Machine-readable output")
+    .action((options) => {
+      const locks = readIdeLocks();
+      if (options.json) {
+        // Never surface the raw bearer token or internal _file path.
+        const safe = locks.map(({ token, _file, ...rest }) => ({
+          ...rest,
+          hasToken: !!token,
+        }));
+        emit({ lockDir: ideLockDir(), count: safe.length, locks: safe });
+        return;
+      }
+      if (!locks.length) {
+        console.log(
+          chalk.gray(`No live IDE lockfiles in ${ideLockDir()}`),
+        );
+        console.log(
+          chalk.gray(
+            "Start an IDE extension that advertises one, or run `cc ide doctor`.",
+          ),
+        );
+        return;
+      }
+      console.log(chalk.bold(`IDE servers (${locks.length}) in ${ideLockDir()}:`));
+      for (const l of locks) {
+        console.log(
+          `  ${chalk.cyan(l.ide)}  port ${l.port}  ${l.transport}  ` +
+            `${l.token ? chalk.green("token") : chalk.yellow("no-token")}`,
+        );
+        console.log(chalk.gray(`    url ${l.url}`));
+        if (l.workspaceFolders.length) {
+          console.log(chalk.gray(`    ws  ${l.workspaceFolders.join(", ")}`));
+        }
+      }
+    });
+
+  ide
+    .command("status")
+    .description("Show the IDE server `cc agent` would connect to right now")
+    .option("--ide", "Force selection even outside an IDE terminal")
+    .option("--json", "Machine-readable output")
+    .action((options) => {
+      const env = process.env;
+      const cwd = process.cwd();
+      const inIde = isInIdeTerminal(env);
+      const lock = discoverIdeServer({ cwd, env, force: options.ide === true });
+      const cfg = lock ? ideServerToMcpConfig(lock) : null;
+      // Redact the bearer token in the previewed config.
+      const safeCfg = cfg
+        ? {
+            ...cfg,
+            headers: cfg.headers?.Authorization
+              ? { ...cfg.headers, Authorization: "Bearer ***" }
+              : cfg.headers,
+          }
+        : null;
+      if (options.json) {
+        // Strip the raw token + internal _file from the chosen lock.
+        const safeChosen = lock
+          ? (({ token, _file, ...rest }) => ({ ...rest, hasToken: !!token }))(
+              lock,
+            )
+          : null;
+        emit({
+          inIdeTerminal: inIde,
+          chosen: safeChosen,
+          mcpConfig: safeCfg,
+        });
+        return;
+      }
+      console.log(
+        `In IDE terminal: ${inIde ? chalk.green("yes") : chalk.gray("no")}`,
+      );
+      if (!lock) {
+        console.log(
+          chalk.gray(
+            "No IDE server would be connected. Try `cc ide doctor` for why.",
+          ),
+        );
+        return;
+      }
+      console.log(
+        `Would connect: ${chalk.cyan(lock.ide)} on port ${lock.port} ` +
+          `(${lock.transport}) as MCP server ${chalk.bold("ide")}`,
+      );
+      console.log(chalk.gray("MCP config:"));
+      console.log(chalk.gray("  " + JSON.stringify(safeCfg)));
+    });
+
+  ide
+    .command("doctor")
+    .description("Explain why IDE discovery did / didn't pick a server")
+    .option("--ide", "Diagnose as if --ide (force) were passed")
+    .option("--json", "Machine-readable output")
+    .action((options) => {
+      const diag = diagnoseIde({
+        cwd: process.cwd(),
+        env: process.env,
+        force: options.ide === true,
+      });
+      if (options.json) {
+        emit(diag);
+        return;
+      }
+      console.log(chalk.bold("IDE bridge discovery"));
+      console.log(`  lock dir       : ${diag.lockDir}`);
+      console.log(
+        `  in IDE terminal: ${diag.inIdeTerminal ? chalk.green("yes") : chalk.gray("no")}`,
+      );
+      console.log(`  live locks     : ${diag.locks.length}`);
+      for (const l of diag.locks) {
+        const m =
+          l.matchScore >= 0
+            ? chalk.green(`workspace-match(${l.matchScore})`)
+            : chalk.yellow("no-workspace-match");
+        console.log(
+          `    - ${chalk.cyan(l.ide)} port ${l.port} ${l.transport} ` +
+            `${l.hasToken ? "token" : chalk.yellow("no-token")} ${m}`,
+        );
+      }
+      console.log(
+        `  result         : ${
+          diag.chosen
+            ? chalk.green(`connect ${diag.chosen.ide}:${diag.chosen.port}`)
+            : chalk.yellow("nothing to connect")
+        }`,
+      );
+      console.log(`  reason         : ${diag.reason}`);
+    });
+
+  return ide;
+}

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;
+      }
+    });
+}