rush-ai 0.2.0

package/dist/index.js

@@ -0,0 +1,3496 @@
+#!/usr/bin/env node
+import {
+  consumeSSEStream,
+  consumeSSEStreamWithReconnect
+} from "./chunk-ISJJIX7U.js";
+import {
+  ApiError,
+  AuthError,
+  RushError,
+  TaskFailedError,
+  VERSION,
+  clearAuthConfig,
+  createClient,
+  createProfile,
+  deleteProfile,
+  getActiveProfile,
+  getAuthConfig,
+  getAuthMethod,
+  getAuthToken,
+  getConfigDir,
+  getGlobalConfig,
+  getProfileAuth,
+  getProfileConfig,
+  isLoggedIn,
+  isRushError,
+  listProfiles,
+  output,
+  revokeCurrentSession,
+  setActiveProfile,
+  setAuthConfig,
+  setGlobalConfig,
+  setVerbosity,
+  verifyCurrentAuthSession
+} from "./chunk-7H2T3KCJ.js";
+
+// src/index.ts
+import chalk6 from "chalk";
+import { Command } from "commander";
+
+// src/output/formatters/csv.ts
+function escapeField(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r") || value !== value.trim()) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function formatCsv(rows) {
+  if (rows.length === 0) return "";
+  const keys = Object.keys(rows[0]);
+  const header = keys.map(escapeField).join(",");
+  const lines = rows.map(
+    (row) => keys.map((k) => escapeField(row[k] ?? "")).join(",")
+  );
+  return [header, ...lines].join("\n");
+}
+
+// src/output/formatters/table.ts
+import chalk from "chalk";
+var STATUS_COLORS = {
+  completed: chalk.green,
+  active: chalk.green,
+  installed: chalk.green,
+  running: chalk.yellow,
+  pending: chalk.yellow,
+  available: chalk.dim,
+  failed: chalk.red,
+  cancelled: chalk.red,
+  error: chalk.red
+};
+function colorizeStatus(value) {
+  const colorFn = STATUS_COLORS[value.toLowerCase()];
+  return colorFn ? colorFn(value) : value;
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return `${str.slice(0, max - 3)}...`;
+}
+function formatTableEnhanced(rows, options) {
+  if (rows.length === 0) return "";
+  const keys = Object.keys(rows[0]);
+  const colOpts = options?.columns ?? {};
+  const widths = {};
+  for (const key of keys) {
+    widths[key] = key.length;
+  }
+  for (const row of rows) {
+    for (const key of keys) {
+      const val = row[key] ?? "";
+      const maxW = colOpts[key]?.maxWidth;
+      const display = maxW ? truncate(val, maxW) : val;
+      if (display.length > widths[key]) {
+        widths[key] = display.length;
+      }
+    }
+  }
+  const header = keys.map((k) => chalk.bold(k.padEnd(widths[k]))).join("  ");
+  const separator = keys.map((k) => "-".repeat(widths[k])).join("  ");
+  const lines = rows.map(
+    (row) => keys.map((k) => {
+      const raw = row[k] ?? "-";
+      const display = raw === "" ? "-" : raw;
+      const maxW = colOpts[k]?.maxWidth;
+      const truncated = maxW ? truncate(display, maxW) : display;
+      const align = colOpts[k]?.align ?? "left";
+      const padded = align === "right" ? truncated.padStart(widths[k]) : truncated.padEnd(widths[k]);
+      if (k.toLowerCase() === "status" || k.toLowerCase() === "state") {
+        return colorizeStatus(padded);
+      }
+      return padded;
+    }).join("  ")
+  );
+  return [header, separator, ...lines].join("\n");
+}
+
+// src/output/formatters/index.ts
+var VALID_FORMATS = ["table", "json", "csv"];
+function resolveFormat(opts) {
+  const hasJson = opts.json === true;
+  const hasFormat = opts.format != null && opts.format !== void 0;
+  if (hasFormat && !VALID_FORMATS.includes(opts.format)) {
+    throw new Error(
+      `Invalid format: "${opts.format}". Supported formats: ${VALID_FORMATS.join(", ")}`
+    );
+  }
+  if (hasJson && hasFormat && opts.format !== "json") {
+    throw new Error(
+      `Conflicting options: --json cannot be used with --format ${opts.format}. Use one or the other.`
+    );
+  }
+  if (hasJson) return "json";
+  if (hasFormat) return opts.format;
+  return "table";
+}
+function formatOutput(rows, format, options) {
+  switch (format) {
+    case "csv":
+      return formatCsv(rows);
+    case "json":
+      return JSON.stringify(rows, null, 2);
+    default:
+      return formatTableEnhanced(rows, options);
+  }
+}
+
+// src/util/require-auth.ts
+function requireAuth() {
+  const token = getAuthToken();
+  if (!token) {
+    throw new AuthError();
+  }
+  if (!process.env.RUSH_API_KEY) {
+    const auth = getAuthConfig();
+    if (auth.expiresAt && Date.now() > auth.expiresAt) {
+      if (auth.method === "cas" && auth.refreshToken) {
+        return;
+      }
+      throw new AuthError(
+        "Token expired. Run `rush-ai auth login` to re-authenticate."
+      );
+    }
+  }
+}
+
+// src/commands/agent/index.ts
+function registerAgentCommand(program) {
+  const agent = program.command("agent").description("Manage and inspect agents");
+  agent.command("list").alias("ls").description("List available agents").action(async () => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    const { data } = await client.get("/api/agents");
+    if (format === "json") {
+      output.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    if (data.agents.length === 0) {
+      output.info("No agents found.");
+      return;
+    }
+    const total = data.pagination?.total ?? data.agents.length;
+    output.log(output.bold(`Agents (${total} total):`));
+    output.newline();
+    const rows = data.agents.map((a) => ({
+      Name: a.name,
+      Description: truncate2(a.description ?? "", 50),
+      Status: a.status,
+      Skills: String(a.skills?.length ?? 0),
+      MCP: String(a.mcp_servers?.length ?? 0)
+    }));
+    output.log(
+      formatOutput(rows, format, {
+        columns: { Description: { maxWidth: 50 } }
+      })
+    );
+  });
+  agent.command("info").description("Show agent details").argument("<name>", "Agent name or ID").action(async (nameOrId) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    let data;
+    try {
+      ({ data } = await client.get(
+        `/api/agents/${encodeURIComponent(nameOrId)}`
+      ));
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 409) {
+        let parsed;
+        try {
+          parsed = JSON.parse(err.meta.body);
+        } catch {
+        }
+        const candidates = parsed?.candidates;
+        const isValid = Array.isArray(candidates) && candidates.length > 0 && candidates.every(
+          (c) => typeof c.id === "string" && typeof c.name === "string"
+        );
+        if (isValid) {
+          if (format === "json") {
+            output.log(JSON.stringify(parsed, null, 2));
+            process.exitCode = 1;
+            return;
+          }
+          output.error(`Multiple agents found with name "${nameOrId}":`);
+          output.newline();
+          for (const c of candidates) {
+            const date = c.created_at?.split("T")[0] ?? "";
+            output.dim(`  ${c.id}  ${c.name}  ${c.status ?? ""}  ${date}`);
+          }
+          output.newline();
+          output.info(`Use agent ID to specify: rush agent info <id>`);
+          process.exitCode = 1;
+          return;
+        }
+      }
+      throw err;
+    }
+    const a = data.agent;
+    if (format === "json") {
+      output.log(JSON.stringify(a, null, 2));
+      return;
+    }
+    output.log(output.bold(a.name));
+    output.log(`  ID: ${a.id}`);
+    output.log(`  Description: ${a.description ?? "(none)"}`);
+    output.log(`  Status: ${a.status}`);
+    output.log(`  Visibility: ${a.visibility}`);
+    output.log(
+      `  Provider: ${a.provider_type}${a.provider_model ? ` (${a.provider_model})` : ""}`
+    );
+    output.log(`  Capabilities: ${a.capabilities?.join(", ") || "none"}`);
+    output.newline();
+    if (a.skills && a.skills.length > 0) {
+      output.log(output.bold("  Skills:"));
+      for (const skill of a.skills) {
+        output.log(`    - ${skill}`);
+      }
+      output.newline();
+    }
+    if (a.mcp_servers && a.mcp_servers.length > 0) {
+      output.log(output.bold(`  MCP Servers (${a.mcp_servers.length}):`));
+      for (const mcp of a.mcp_servers) {
+        if (typeof mcp === "object" && mcp !== null) {
+          const m = mcp;
+          const name = String(m.serverName ?? m.name ?? "unknown");
+          const disabled = m.disabled ? " (disabled)" : "";
+          output.log(`    - ${name}${disabled}`);
+        } else {
+          output.log(`    - ${JSON.stringify(mcp)}`);
+        }
+      }
+      output.newline();
+    }
+    output.dim(`  Updated: ${new Date(a.updated_at).toLocaleString()}`);
+  });
+}
+function truncate2(str, max) {
+  if (str.length <= max) return str;
+  return `${str.slice(0, max - 3)}...`;
+}
+
+// src/commands/auth/browser-login.ts
+import { randomBytes } from "crypto";
+import { createServer } from "http";
+import open from "open";
+function getApiBaseUrl() {
+  return process.env.RUSH_API_URL ?? getGlobalConfig().api;
+}
+async function loginViaBrowser(jsonMode) {
+  const baseUrl = getApiBaseUrl();
+  const state = randomBytes(16).toString("hex");
+  return new Promise((resolve7, reject) => {
+    const server = createServer(async (req, res) => {
+      try {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        if (url.pathname !== "/callback") {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          const desc = url.searchParams.get("error_description") ?? "Authentication failed";
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            getHtmlPage(
+              "Authentication Failed",
+              `Error: ${desc}. You can close this window.`
+            )
+          );
+          server.close();
+          reject(new AuthError(`Browser authentication failed: ${desc}`));
+          return;
+        }
+        if (!code || returnedState !== state) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(
+            getHtmlPage(
+              "Authentication Failed",
+              "Invalid callback parameters. You can close this window."
+            )
+          );
+          server.close();
+          reject(
+            new AuthError("Invalid callback: missing code or state mismatch")
+          );
+          return;
+        }
+        const tokenUrl = `${baseUrl}/api/cli/auth/token`;
+        const tokenResponse = await fetch(tokenUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ code, state })
+        });
+        if (!tokenResponse.ok) {
+          const errorText = await tokenResponse.text().catch(() => "Unknown error");
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            getHtmlPage(
+              "Authentication Failed",
+              "Token exchange failed. You can close this window."
+            )
+          );
+          server.close();
+          reject(new AuthError(`Token exchange failed: ${errorText}`));
+          return;
+        }
+        const tokenData = await tokenResponse.json();
+        const expiresAt = tokenData.expires_at ? new Date(tokenData.expires_at).getTime() : null;
+        setAuthConfig({
+          token: tokenData.token,
+          expiresAt,
+          refreshToken: null,
+          method: "platform_token",
+          tokenId: tokenData.token_id
+        });
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          getHtmlPage(
+            "Authentication Successful",
+            "You are now logged in. You can close this window and return to the terminal."
+          )
+        );
+        server.close();
+        if (jsonMode) {
+          output.log(
+            JSON.stringify({
+              status: "authenticated",
+              method: "platform_token",
+              expiresAt
+            })
+          );
+        } else {
+          output.success("Logged in successfully.");
+          if (expiresAt) {
+            output.dim(
+              `Token expires: ${new Date(expiresAt).toLocaleString()}`
+            );
+          }
+        }
+        resolve7();
+      } catch (err) {
+        server.close();
+        reject(
+          err instanceof AuthError ? err : new AuthError(
+            `Authentication error: ${err instanceof Error ? err.message : "Unknown"}`
+          )
+        );
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      const authUrl = `${baseUrl}/api/cli/auth/authorize?callback_port=${port}&state=${encodeURIComponent(state)}`;
+      if (!jsonMode) {
+        output.log("Opening browser for authentication...");
+        output.dim("If the browser doesn't open, visit:");
+        output.dim(authUrl);
+        output.newline();
+        output.dim("Waiting for authentication...");
+      }
+      open(authUrl).catch(() => {
+        if (!jsonMode) {
+          output.warn(
+            "Could not open browser. Please visit the URL above manually."
+          );
+        }
+      });
+    });
+    const timeoutId = setTimeout(() => {
+      server.close();
+      reject(new AuthError("Authentication timed out after 5 minutes"));
+    }, 3e5);
+    server.on("close", () => clearTimeout(timeoutId));
+  });
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+function getHtmlPage(title, message) {
+  return `<!DOCTYPE html>
+<html>
+<head><title>Rush CLI - ${escapeHtml(title)}</title>
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #f5f5f5; }
+  .card { background: white; border-radius: 12px; padding: 40px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); text-align: center; max-width: 400px; }
+  h1 { color: #333; font-size: 1.5em; }
+  p { color: #666; line-height: 1.6; }
+</style>
+</head>
+<body>
+  <div class="card">
+    <h1>${escapeHtml(title)}</h1>
+    <p>${escapeHtml(message)}</p>
+  </div>
+</body>
+</html>`;
+}
+
+// src/commands/auth/index.ts
+function registerAuthCommand(program) {
+  const auth = program.command("auth").description("Manage authentication");
+  auth.command("login").description("Log in to the Rush platform").option("--api-key <key>", "Authenticate with an API key instead of CAS").option("--no-verify", "Skip online validation for API key login").action(async (options) => {
+    const jsonMode = program.opts().json;
+    if (options.apiKey) {
+      setAuthConfig({
+        token: options.apiKey,
+        expiresAt: null,
+        refreshToken: null,
+        method: "api_key"
+      });
+      let verification;
+      if (options.verify !== false) {
+        verification = await verifyCurrentAuthSession();
+        if (!verification.valid) {
+          clearAuthConfig();
+          throw new RushError(
+            `API key validation failed: ${verification.message ?? "invalid credentials"}`,
+            {},
+            "AUTH_ERROR"
+          );
+        }
+      }
+      if (jsonMode) {
+        output.log(
+          JSON.stringify({
+            status: "authenticated",
+            method: "api_key",
+            verified: options.verify !== false,
+            ...verification ? { serverStatus: verification.status } : {}
+          })
+        );
+      } else {
+        output.success("Authenticated with API key.");
+        if (options.verify !== false) {
+          output.dim("Server validation: OK");
+        }
+      }
+      return;
+    }
+    if (isLoggedIn()) {
+      if (jsonMode) {
+        output.log(JSON.stringify({ status: "already_authenticated" }));
+      } else {
+        output.warn("You are already logged in.");
+        output.dim("Run `rush-ai auth logout` first to log out.");
+      }
+      return;
+    }
+    await loginViaBrowser(jsonMode);
+  });
+  auth.command("status").description("Show the current authentication status").option("--verify", "Validate the current credential against the server").action(async (options) => {
+    const jsonMode = program.opts().json;
+    const method = getAuthMethod();
+    const authConfig = getAuthConfig();
+    const loggedIn = method !== null && (method === "api_key" || isLoggedIn());
+    const verification = loggedIn && options.verify ? await verifyCurrentAuthSession() : null;
+    if (jsonMode) {
+      output.log(
+        JSON.stringify({
+          authenticated: loggedIn,
+          method: method ?? null,
+          expiresAt: authConfig.expiresAt,
+          hasRefreshToken: Boolean(authConfig.refreshToken),
+          configDir: getConfigDir(),
+          ...verification ? {
+            serverAuthenticated: verification.valid,
+            serverStatus: verification.status,
+            serverMessage: verification.message
+          } : {}
+        })
+      );
+    } else {
+      if (loggedIn) {
+        output.success(`Authenticated via ${method ?? "token"}`);
+        if (authConfig.expiresAt) {
+          const expiresDate = new Date(authConfig.expiresAt).toLocaleString();
+          output.dim(`Token expires: ${expiresDate}`);
+        }
+        if (authConfig.refreshToken) {
+          output.dim("Refresh token: available");
+        }
+      } else {
+        output.warn("Not authenticated.");
+        output.dim("Run `rush-ai auth login` to log in.");
+      }
+      if (verification) {
+        if (verification.valid) {
+          output.dim("Server validation: OK");
+        } else {
+          output.warn(
+            `Server validation failed: ${verification.message ?? "token rejected"}`
+          );
+        }
+      }
+      output.dim(`Config: ${getConfigDir()}`);
+    }
+  });
+  auth.command("logout").description("Log out and clear stored credentials").option("--no-revoke", "Skip best-effort CAS revoke request").action(async (options) => {
+    const jsonMode = program.opts().json;
+    const authConfig = getAuthConfig();
+    const hasToken = authConfig.token !== null;
+    if (!hasToken) {
+      if (jsonMode) {
+        output.log(JSON.stringify({ status: "not_authenticated" }));
+      } else {
+        output.warn("You are not currently logged in.");
+      }
+      return;
+    }
+    const shouldRevoke = options.revoke !== false && (authConfig.method === "cas" || authConfig.method === "platform_token");
+    const revoked = shouldRevoke ? await revokeCurrentSession() : false;
+    clearAuthConfig();
+    if (jsonMode) {
+      output.log(
+        JSON.stringify({
+          status: "logged_out",
+          ...shouldRevoke ? { revoked } : {}
+        })
+      );
+    } else {
+      output.success("Logged out successfully.");
+      if (shouldRevoke) {
+        if (revoked) {
+          output.dim("Remote token revoked.");
+        } else {
+          output.warn(
+            "Could not confirm remote revoke. Local credentials were cleared."
+          );
+        }
+      }
+    }
+  });
+}
+
+// src/commands/completion/index.ts
+import { existsSync } from "fs";
+import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { basename, dirname, join } from "path";
+var MARKER_BEGIN = "###-begin-rush-ai-completion-###";
+var MARKER_END = "###-end-rush-ai-completion-###";
+var COMPLETION_SCRIPTS = {
+  bash: `
+${MARKER_BEGIN}
+_rush_cli_completion() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  local cmds="auth agent task mcp plugin completion config doctor"
+
+  case "$prev" in
+    rush-ai) COMPREPLY=( $(compgen -W "$cmds" -- "$cur") ) ;;
+    auth) COMPREPLY=( $(compgen -W "login logout status" -- "$cur") ) ;;
+    agent) COMPREPLY=( $(compgen -W "list info" -- "$cur") ) ;;
+    task) COMPREPLY=( $(compgen -W "run create status result list watch cancel" -- "$cur") ) ;;
+    plugin) COMPREPLY=( $(compgen -W "install list status update uninstall" -- "$cur") ) ;;
+    completion) COMPREPLY=( $(compgen -W "install bash zsh fish" -- "$cur") ) ;;
+    config) COMPREPLY=( $(compgen -W "show set use create delete list" -- "$cur") ) ;;
+  esac
+}
+complete -F _rush_cli_completion rush-ai
+${MARKER_END}`.trimStart(),
+  zsh: `
+${MARKER_BEGIN}
+_rush_cli_completion() {
+  local -a cmds
+  cmds=(
+    'auth:Authentication commands'
+    'agent:Agent management'
+    'task:Task operations'
+    'mcp:MCP server'
+    'plugin:Plugin management'
+    'completion:Shell completion'
+    'config:Configuration management'
+    'doctor:System diagnostics'
+  )
+  _describe 'command' cmds
+}
+compdef _rush_cli_completion rush-ai
+${MARKER_END}`.trimStart(),
+  fish: `
+${MARKER_BEGIN}
+complete -c rush-ai -n '__fish_use_subcommand' -a auth -d 'Authentication'
+complete -c rush-ai -n '__fish_use_subcommand' -a agent -d 'Agent management'
+complete -c rush-ai -n '__fish_use_subcommand' -a task -d 'Task operations'
+complete -c rush-ai -n '__fish_use_subcommand' -a mcp -d 'MCP server'
+complete -c rush-ai -n '__fish_use_subcommand' -a plugin -d 'Plugin management'
+complete -c rush-ai -n '__fish_use_subcommand' -a completion -d 'Shell completion'
+complete -c rush-ai -n '__fish_use_subcommand' -a config -d 'Configuration management'
+complete -c rush-ai -n '__fish_use_subcommand' -a doctor -d 'System diagnostics'
+complete -c rush-ai -n '__fish_seen_subcommand_from auth' -a 'login logout status'
+complete -c rush-ai -n '__fish_seen_subcommand_from agent' -a 'list info'
+complete -c rush-ai -n '__fish_seen_subcommand_from task' -a 'run create status result list watch cancel'
+complete -c rush-ai -n '__fish_seen_subcommand_from plugin' -a 'install list status update uninstall'
+complete -c rush-ai -n '__fish_seen_subcommand_from completion' -a 'install bash zsh fish'
+complete -c rush-ai -n '__fish_seen_subcommand_from config' -a 'show set use create delete list'
+${MARKER_END}`.trimStart()
+};
+function detectShell() {
+  const shell = process.env.SHELL;
+  if (!shell) return null;
+  const name = basename(shell);
+  return COMPLETION_SCRIPTS[name] ? name : null;
+}
+function getShellRcFile(shell) {
+  const home = homedir();
+  switch (shell) {
+    case "bash":
+      return existsSync(join(home, ".bashrc")) ? join(home, ".bashrc") : join(home, ".bash_profile");
+    case "zsh":
+      return join(home, ".zshrc");
+    case "fish":
+      return join(home, ".config", "fish", "completions", "rush-ai.fish");
+    default:
+      throw new Error(`Unsupported shell: ${shell}`);
+  }
+}
+function registerCompletionCommand(program) {
+  const completion = program.command("completion").description("Shell completion utilities");
+  completion.command("bash").description("Print bash completion script").action(() => {
+    output.log(COMPLETION_SCRIPTS.bash);
+  });
+  completion.command("zsh").description("Print zsh completion script").action(() => {
+    output.log(COMPLETION_SCRIPTS.zsh);
+  });
+  completion.command("fish").description("Print fish completion script").action(() => {
+    output.log(COMPLETION_SCRIPTS.fish);
+  });
+  completion.command("install").description("Auto-install shell completion to your shell rc file").option("--shell <shell>", "Shell type (auto-detect if omitted)").action(async (opts) => {
+    const shell = opts.shell ?? detectShell();
+    if (!shell) {
+      output.error("Could not detect shell. Use --shell <bash|zsh|fish>.");
+      process.exit(1);
+    }
+    if (!COMPLETION_SCRIPTS[shell]) {
+      output.error(
+        `Unsupported shell: ${shell}. Supported: bash, zsh, fish.`
+      );
+      process.exit(1);
+    }
+    const script = COMPLETION_SCRIPTS[shell];
+    const rcFile = getShellRcFile(shell);
+    if (shell === "fish") {
+      try {
+        await mkdir(dirname(rcFile), { recursive: true });
+        await writeFile(rcFile, script + "\n");
+        output.success(`Fish completion installed to ${rcFile}`);
+      } catch {
+        output.error(`Failed to write to ${rcFile}`);
+        output.dim(
+          "  You can manually add the following to your fish completions:"
+        );
+        output.log(script);
+      }
+      return;
+    }
+    try {
+      const existing = await readFile(rcFile, "utf-8");
+      if (existing.includes(MARKER_BEGIN)) {
+        output.info(`Completion already installed in ${rcFile}`);
+        return;
+      }
+    } catch {
+    }
+    try {
+      await appendFile(rcFile, "\n" + script + "\n");
+      output.success(`Completion installed to ${rcFile}`);
+      output.dim(
+        `  Run \`source ${rcFile}\` or restart your shell to activate.`
+      );
+    } catch {
+      output.error(`Failed to write to ${rcFile}`);
+      output.dim(
+        "  You can manually add the following to your shell rc file:"
+      );
+      output.log(script);
+    }
+  });
+}
+
+// src/commands/config/index.ts
+var SETTABLE_KEYS = ["api", "collectMetrics", "currentTeam"];
+function maskToken(token) {
+  if (!token) return "(none)";
+  if (token.length <= 8) return "****";
+  return `${token.slice(0, 4)}...****`;
+}
+function registerConfigCommand(program) {
+  const config = program.command("config").description("Manage CLI configuration and profiles");
+  config.command("show").description("Show current configuration").action(() => {
+    const jsonMode = program.opts().json;
+    const profile = getActiveProfile();
+    const globalConf = getGlobalConfig();
+    const authConf = getAuthConfig();
+    const configDir = getConfigDir();
+    const apiOverride = process.env.RUSH_API_URL;
+    const profileOverride = process.env.RUSH_PROFILE;
+    if (jsonMode) {
+      output.log(
+        JSON.stringify(
+          {
+            profile,
+            api: apiOverride ?? globalConf.api,
+            apiOverridden: Boolean(apiOverride),
+            profileOverridden: Boolean(profileOverride),
+            authMethod: authConf.method,
+            collectMetrics: globalConf.collectMetrics,
+            currentTeam: globalConf.currentTeam,
+            configDir
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    output.log(output.bold("Configuration"));
+    output.newline();
+    const profileLabel = profileOverride ? `${profile} (overridden by RUSH_PROFILE env)` : profile;
+    output.log(`  Active profile: ${profileLabel}`);
+    const apiLabel = apiOverride ? `${apiOverride} (overridden by RUSH_API_URL env)` : globalConf.api;
+    output.log(`  API:            ${apiLabel}`);
+    output.log(
+      `  Auth method:    ${authConf.method ?? "(not authenticated)"}`
+    );
+    output.log(`  Token:          ${maskToken(authConf.token)}`);
+    output.log(
+      `  Metrics:        ${globalConf.collectMetrics ? "enabled" : "disabled"}`
+    );
+    output.log(`  Config dir:     ${configDir}`);
+  });
+  config.command("set").description("Set a configuration value").argument("<key>", `Config key (${SETTABLE_KEYS.join(", ")})`).argument("<value>", "Config value").action((key, value) => {
+    const jsonMode = program.opts().json;
+    const profile = getActiveProfile();
+    if (!SETTABLE_KEYS.includes(key)) {
+      output.error(
+        `Unknown config key '${key}'. Valid keys: ${SETTABLE_KEYS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    let typedValue = value;
+    if (key === "collectMetrics") {
+      if (value !== "true" && value !== "false") {
+        output.error("'collectMetrics' must be 'true' or 'false'.");
+        process.exit(1);
+      }
+      typedValue = value === "true";
+    }
+    if (key === "currentTeam" && value === "null") {
+      typedValue = null;
+    }
+    setGlobalConfig({ [key]: typedValue });
+    if (jsonMode) {
+      output.log(JSON.stringify({ key, value: typedValue, profile }));
+    } else {
+      output.success(
+        `Updated '${key}' to '${String(typedValue)}' (profile: ${profile})`
+      );
+    }
+  });
+  config.command("use").description("Switch active profile").argument("<profile>", "Profile name to switch to").action((profileName) => {
+    const jsonMode = program.opts().json;
+    try {
+      setActiveProfile(profileName);
+    } catch (err) {
+      output.error(
+        err instanceof Error ? err.message : "Failed to switch profile"
+      );
+      const available = listProfiles();
+      if (!jsonMode) {
+        output.dim(`Available profiles: ${available.join(", ")}`);
+        output.dim(
+          `Run \`rush-ai config create ${profileName}\` to create it.`
+        );
+      }
+      process.exit(1);
+    }
+    const globalConf = getGlobalConfig();
+    if (jsonMode) {
+      output.log(
+        JSON.stringify({
+          profile: profileName,
+          api: globalConf.api
+        })
+      );
+    } else {
+      output.success(`Switched to profile '${profileName}'`);
+      output.dim(`API: ${globalConf.api}`);
+    }
+  });
+  config.command("create").description("Create a new profile").argument("<profile>", "Profile name").option("--api <url>", "API base URL").action((profileName, options) => {
+    const jsonMode = program.opts().json;
+    try {
+      createProfile(
+        profileName,
+        options.api ? { api: options.api } : void 0
+      );
+    } catch (err) {
+      output.error(
+        err instanceof Error ? err.message : "Failed to create profile"
+      );
+      process.exit(1);
+    }
+    if (jsonMode) {
+      output.log(JSON.stringify({ profile: profileName, created: true }));
+    } else {
+      output.success(`Created profile '${profileName}'`);
+      output.dim(
+        `Run \`rush-ai config use ${profileName}\` to switch to it.`
+      );
+    }
+  });
+  config.command("delete").description("Delete a profile").argument("<profile>", "Profile name to delete").action((profileName) => {
+    const jsonMode = program.opts().json;
+    try {
+      deleteProfile(profileName);
+    } catch (err) {
+      output.error(
+        err instanceof Error ? err.message : "Failed to delete profile"
+      );
+      process.exit(1);
+    }
+    if (jsonMode) {
+      output.log(JSON.stringify({ profile: profileName, deleted: true }));
+    } else {
+      output.success(`Deleted profile '${profileName}'`);
+    }
+  });
+  config.command("list").alias("ls").description("List all profiles").action(() => {
+    const jsonMode = program.opts().json;
+    const profiles = listProfiles();
+    const active = getActiveProfile();
+    if (jsonMode) {
+      const data = profiles.map((name) => {
+        const conf = getProfileConfig(name);
+        const auth = getProfileAuth(name);
+        return {
+          name,
+          active: name === active,
+          api: conf?.api ?? "",
+          authMethod: auth.method,
+          loggedIn: Boolean(auth.token)
+        };
+      });
+      output.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    if (profiles.length === 0) {
+      output.info("No profiles configured.");
+      return;
+    }
+    const rows = profiles.map((name) => {
+      const conf = getProfileConfig(name);
+      const auth = getProfileAuth(name);
+      const marker = name === active ? "*" : " ";
+      const authStatus = auth.token ? `${auth.method ?? "unknown"} (logged in)` : "not authenticated";
+      return {
+        " ": marker,
+        Profile: name,
+        API: conf?.api ?? "",
+        Auth: authStatus
+      };
+    });
+    output.log(formatTableEnhanced(rows));
+  });
+}
+
+// src/commands/doctor/index.ts
+import chalk2 from "chalk";
+
+// src/commands/doctor/checks/auth.ts
+var checkAuth = async () => {
+  const checks = [];
+  const method = getAuthMethod();
+  if (method === "platform_token") {
+    checks.push({
+      name: "auth_method",
+      group: "Authentication",
+      status: "pass",
+      label: "Auth method",
+      value: "Platform Token (browser login)"
+    });
+  } else if (method === "cas") {
+    checks.push({
+      name: "auth_method",
+      group: "Authentication",
+      status: "pass",
+      label: "Auth method",
+      value: "CAS PKCE"
+    });
+  } else if (method === "api_key") {
+    checks.push({
+      name: "auth_method",
+      group: "Authentication",
+      status: "pass",
+      label: "Auth method",
+      value: "API Key"
+    });
+  } else {
+    checks.push({
+      name: "auth_method",
+      group: "Authentication",
+      status: "warn",
+      label: "Auth method",
+      value: "Not authenticated",
+      fix: "Run `rush-ai auth login` to authenticate"
+    });
+  }
+  if (method === "api_key") {
+    checks.push({
+      name: "token_status",
+      group: "Authentication",
+      status: "info",
+      label: "Token status",
+      value: "Using API key auth"
+    });
+  } else if (method === "cas" || method === "platform_token") {
+    const auth = getAuthConfig();
+    if (auth.token && auth.expiresAt) {
+      const remaining = auth.expiresAt - Date.now();
+      if (remaining > 0) {
+        const hours = Math.floor(remaining / (1e3 * 60 * 60));
+        const minutes = Math.floor(
+          remaining % (1e3 * 60 * 60) / (1e3 * 60)
+        );
+        const timeStr = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+        checks.push({
+          name: "token_status",
+          group: "Authentication",
+          status: "pass",
+          label: "Token status",
+          value: `Valid (expires in ${timeStr})`
+        });
+      } else {
+        checks.push({
+          name: "token_status",
+          group: "Authentication",
+          status: "warn",
+          label: "Token status",
+          value: "Expired",
+          fix: "Run `rush-ai auth login` to re-authenticate"
+        });
+      }
+    } else if (auth.token) {
+      checks.push({
+        name: "token_status",
+        group: "Authentication",
+        status: "pass",
+        label: "Token status",
+        value: "Valid (no expiry set)"
+      });
+    } else {
+      checks.push({
+        name: "token_status",
+        group: "Authentication",
+        status: "warn",
+        label: "Token status",
+        value: "No token found",
+        fix: "Run `rush-ai auth login` to authenticate"
+      });
+    }
+  } else {
+    checks.push({
+      name: "token_status",
+      group: "Authentication",
+      status: "warn",
+      label: "Token status",
+      value: "Not authenticated",
+      fix: "Run `rush-ai auth login` to authenticate"
+    });
+  }
+  const apiKey = process.env.RUSH_API_KEY;
+  checks.push({
+    name: "api_key",
+    group: "Authentication",
+    status: "info",
+    label: "API Key",
+    value: apiKey ? "Set (RUSH_API_KEY)" : "Not set"
+  });
+  return checks;
+};
+
+// src/commands/doctor/checks/config.ts
+import { accessSync, constants, existsSync as existsSync2, mkdirSync } from "fs";
+var checkConfig = async () => {
+  const checks = [];
+  const configDir = getConfigDir();
+  const dirExists = existsSync2(configDir);
+  let writable = false;
+  if (dirExists) {
+    try {
+      accessSync(configDir, constants.W_OK);
+      writable = true;
+    } catch {
+    }
+  }
+  if (dirExists && writable) {
+    checks.push({
+      name: "config_dir",
+      group: "Configuration",
+      status: "pass",
+      label: "Config directory",
+      value: configDir
+    });
+  } else if (dirExists && !writable) {
+    checks.push({
+      name: "config_dir",
+      group: "Configuration",
+      status: "fail",
+      label: "Config directory",
+      value: `${configDir} (not writable)`,
+      fix: `Check permissions on ${configDir}`
+    });
+  } else {
+    checks.push({
+      name: "config_dir",
+      group: "Configuration",
+      status: "fail",
+      label: "Config directory",
+      value: `${configDir} (not found)`,
+      fix: `Run \`rush-ai doctor --fix\` to create it`,
+      autoFix: async () => {
+        mkdirSync(configDir, { recursive: true });
+      }
+    });
+  }
+  try {
+    getGlobalConfig();
+    getAuthConfig();
+    checks.push({
+      name: "config_validity",
+      group: "Configuration",
+      status: "pass",
+      label: "Config files",
+      value: "Valid"
+    });
+  } catch (err) {
+    checks.push({
+      name: "config_validity",
+      group: "Configuration",
+      status: "fail",
+      label: "Config files",
+      value: `Error: ${err instanceof Error ? err.message : "unknown"}`,
+      fix: "Check config files in " + configDir
+    });
+  }
+  try {
+    const config = getGlobalConfig();
+    checks.push({
+      name: "api_url",
+      group: "Configuration",
+      status: "info",
+      label: "API URL",
+      value: config.api
+    });
+  } catch {
+    checks.push({
+      name: "api_url",
+      group: "Configuration",
+      status: "warn",
+      label: "API URL",
+      value: "Unable to read"
+    });
+  }
+  return checks;
+};
+
+// src/commands/doctor/checks/connectivity.ts
+var checkConnectivity = async () => {
+  const checks = [];
+  const config = getGlobalConfig();
+  const apiUrl = process.env.RUSH_API_URL ?? config.api;
+  try {
+    const start = Date.now();
+    const response = await fetch(apiUrl, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5e3)
+    });
+    const rtt = Date.now() - start;
+    checks.push({
+      name: "api_endpoint",
+      group: "Connectivity",
+      status: "pass",
+      label: "API endpoint",
+      value: `${apiUrl} (${rtt}ms, HTTP ${response.status})`
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    const isTimeout = message.includes("timeout") || message.includes("abort");
+    checks.push({
+      name: "api_endpoint",
+      group: "Connectivity",
+      status: "fail",
+      label: "API endpoint",
+      value: isTimeout ? `${apiUrl} (timeout after 5s)` : `${apiUrl} (${message})`,
+      fix: "Check your network connection and API URL in config"
+    });
+  }
+  const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+  const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+  if (httpProxy || httpsProxy) {
+    const parts = [];
+    if (httpProxy) parts.push(`HTTP_PROXY=${maskUrl(httpProxy)}`);
+    if (httpsProxy) parts.push(`HTTPS_PROXY=${maskUrl(httpsProxy)}`);
+    checks.push({
+      name: "proxy",
+      group: "Connectivity",
+      status: "info",
+      label: "Proxy",
+      value: parts.join(", ")
+    });
+  } else {
+    checks.push({
+      name: "proxy",
+      group: "Connectivity",
+      status: "info",
+      label: "Proxy",
+      value: "Not configured"
+    });
+  }
+  return checks;
+};
+function maskUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.username || parsed.password) {
+      parsed.username = "***";
+      parsed.password = "";
+      return parsed.toString().replace(/\/$/, "");
+    }
+    if (url.includes("@")) {
+      return url.replace(/[^/@]+@/, "***@");
+    }
+    return parsed.toString().replace(/\/$/, "");
+  } catch {
+    if (url.includes("@")) {
+      return url.replace(/[^/@]+@/, "***@");
+    }
+    return url;
+  }
+}
+
+// src/commands/doctor/checks/environment.ts
+import { execFileSync } from "child_process";
+import { arch, platform, release, type } from "os";
+function formatOS() {
+  const p = platform();
+  const r = release();
+  const a = arch();
+  let osName;
+  switch (p) {
+    case "darwin":
+      osName = "macOS";
+      break;
+    case "win32":
+      osName = "Windows";
+      break;
+    case "linux":
+      osName = "Linux";
+      break;
+    default:
+      osName = type();
+  }
+  return `${osName} ${r} (${p} ${a})`;
+}
+var KNOWN_SHELLS = ["bash", "zsh", "fish", "sh", "dash", "ksh", "tcsh"];
+function detectShell2() {
+  const shell = process.env.SHELL;
+  if (!shell) {
+    return { name: "unknown", version: null };
+  }
+  const name = shell.split("/").pop() ?? shell;
+  if (!KNOWN_SHELLS.includes(name)) {
+    return { name, version: null };
+  }
+  let version = null;
+  try {
+    const raw = execFileSync(shell, ["--version"], {
+      timeout: 3e3,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    });
+    const firstLine = raw.split("\n")[0] ?? "";
+    const match = firstLine.match(/(\d+\.\d+[\d.]*)/);
+    version = match?.[1] ?? null;
+  } catch {
+  }
+  return { name, version };
+}
+var checkEnvironment = async () => {
+  const checks = [];
+  checks.push({
+    name: "cli_version",
+    group: "Environment",
+    status: "info",
+    label: "CLI version",
+    value: VERSION
+  });
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1), 10);
+  const nodeOk = major >= 18;
+  checks.push({
+    name: "node_version",
+    group: "Environment",
+    status: nodeOk ? "pass" : "fail",
+    label: "Node.js version",
+    value: `${nodeVersion}${nodeOk ? "" : " (>=18.0.0 required)"}`,
+    fix: nodeOk ? void 0 : "Upgrade Node.js to version 18 or higher"
+  });
+  checks.push({
+    name: "os",
+    group: "Environment",
+    status: "info",
+    label: "OS",
+    value: formatOS()
+  });
+  const shell = detectShell2();
+  const shellValue = shell.name === "unknown" ? "Unknown" : shell.version ? `${shell.name} ${shell.version}` : shell.name;
+  checks.push({
+    name: "shell",
+    group: "Environment",
+    status: shell.name === "unknown" ? "warn" : "pass",
+    label: "Shell",
+    value: shellValue
+  });
+  const terminal = process.env.TERM_PROGRAM ?? "Unknown";
+  checks.push({
+    name: "terminal",
+    group: "Environment",
+    status: "info",
+    label: "Terminal",
+    value: terminal
+  });
+  return checks;
+};
+
+// src/commands/doctor/checks/plugins.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { resolve } from "path";
+var PLUGINS_FILE = resolve(homedir2(), ".rush", "plugins", "installed.json");
+var MCP_CONFIG_PATHS = {
+  "claude-code": resolve(homedir2(), ".claude", "settings.json"),
+  cursor: resolve(homedir2(), ".cursor", "mcp.json")
+};
+function safeReadJson(filePath, fallback) {
+  if (!existsSync3(filePath)) return fallback;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function injectMcpConfig(configPath) {
+  const config = safeReadJson(configPath, {});
+  const mcpServers = config.mcpServers ?? {};
+  const globalConfig = getGlobalConfig();
+  mcpServers.rush = {
+    command: "rush-ai",
+    args: ["mcp", "serve"],
+    env: {
+      RUSH_API_URL: globalConfig.api
+    }
+  };
+  config.mcpServers = mcpServers;
+  writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function checkMcpForPlugin(name, manifest) {
+  const configPath = MCP_CONFIG_PATHS[manifest.type];
+  if (!configPath) {
+    return {
+      name: `plugin_${name}`,
+      group: "Plugins",
+      status: "warn",
+      label: name,
+      value: `Installed (v${manifest.version}), unknown type: ${manifest.type}`
+    };
+  }
+  if (!existsSync3(configPath)) {
+    return {
+      name: `plugin_${name}`,
+      group: "Plugins",
+      status: "warn",
+      label: name,
+      value: `Installed, MCP config missing (${configPath})`,
+      fix: `Run \`rush-ai plugin install ${name}\``,
+      autoFix: async () => {
+        injectMcpConfig(configPath);
+      }
+    };
+  }
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    const servers = config.mcpServers;
+    if (!servers || !("rush" in servers)) {
+      return {
+        name: `plugin_${name}`,
+        group: "Plugins",
+        status: "warn",
+        label: name,
+        value: "Installed, MCP server not configured",
+        fix: `Run \`rush-ai doctor --fix\` to inject MCP config`,
+        autoFix: async () => {
+          injectMcpConfig(configPath);
+        }
+      };
+    }
+    const rushServer = servers.rush;
+    const command = rushServer?.command;
+    if (command !== "rush-ai") {
+      return {
+        name: `plugin_${name}`,
+        group: "Plugins",
+        status: "warn",
+        label: name,
+        value: `Installed, MCP command is "${command}" (expected "rush-ai")`,
+        fix: `Run \`rush-ai plugin update ${name}\``
+      };
+    }
+    return {
+      name: `plugin_${name}`,
+      group: "Plugins",
+      status: "pass",
+      label: name,
+      value: `Installed (v${manifest.version}), MCP config valid`
+    };
+  } catch {
+    return {
+      name: `plugin_${name}`,
+      group: "Plugins",
+      status: "warn",
+      label: name,
+      value: `Installed, failed to parse MCP config`,
+      fix: `Check ${configPath} for JSON syntax errors`
+    };
+  }
+}
+var checkPlugins = async () => {
+  const data = safeReadJson(PLUGINS_FILE, { plugins: {} });
+  const plugins = data && typeof data === "object" && data.plugins && typeof data.plugins === "object" ? data.plugins : {};
+  const entries = Object.entries(plugins);
+  if (entries.length === 0) {
+    return [
+      {
+        name: "plugins_none",
+        group: "Plugins",
+        status: "info",
+        label: "Plugins",
+        value: "No plugins installed"
+      }
+    ];
+  }
+  return entries.map(([name, manifest]) => checkMcpForPlugin(name, manifest));
+};
+
+// src/commands/doctor/index.ts
+var CHECK_RUNNERS = [
+  checkEnvironment,
+  checkAuth,
+  checkConnectivity,
+  checkConfig,
+  checkPlugins
+];
+async function runAllChecks() {
+  const checks = [];
+  for (const runner of CHECK_RUNNERS) {
+    try {
+      const results = await runner();
+      checks.push(...results);
+    } catch (err) {
+      checks.push({
+        name: "runner_error",
+        group: "Environment",
+        status: "fail",
+        label: "Check error",
+        value: `A check group failed: ${err instanceof Error ? err.message : "unknown error"}`
+      });
+    }
+  }
+  return checks;
+}
+function getSummary(checks) {
+  let pass = 0;
+  let warn = 0;
+  let fail = 0;
+  for (const c of checks) {
+    if (c.status === "pass") pass++;
+    else if (c.status === "warn") warn++;
+    else if (c.status === "fail") fail++;
+  }
+  return { pass, warn, fail };
+}
+function statusIcon(status) {
+  switch (status) {
+    case "pass":
+      return chalk2.green("\u2713");
+    case "warn":
+      return chalk2.yellow("!");
+    case "fail":
+      return chalk2.red("\u2717");
+    case "info":
+      return chalk2.dim("\xB7");
+  }
+}
+var LABEL_WIDTH = 20;
+function displayResults(checks) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const check of checks) {
+    const existing = groups.get(check.group) ?? [];
+    existing.push(check);
+    groups.set(check.group, existing);
+  }
+  output.newline();
+  for (const [groupName, groupChecks] of groups) {
+    output.log(`  ${chalk2.bold(groupName)}`);
+    for (const check of groupChecks) {
+      const icon = statusIcon(check.status);
+      const label = check.label.padEnd(LABEL_WIDTH);
+      output.log(`  ${icon} ${label} ${check.value}`);
+    }
+    output.log("");
+  }
+  const summary = getSummary(checks);
+  const parts = [];
+  parts.push(chalk2.green(`${summary.pass} passed`));
+  if (summary.warn > 0) parts.push(chalk2.yellow(`${summary.warn} warnings`));
+  if (summary.fail > 0) parts.push(chalk2.red(`${summary.fail} failed`));
+  if (summary.warn === 0 && summary.fail === 0) {
+    parts.push("0 warnings");
+    parts.push("0 failed");
+  }
+  output.log(`  ${chalk2.bold("Summary:")} ${parts.join(", ")}`);
+  if (summary.fail > 0 || summary.warn > 0) {
+    const fixable = checks.filter(
+      (c) => c.status !== "pass" && c.status !== "info" && c.autoFix
+    );
+    if (fixable.length > 0) {
+      output.log(
+        chalk2.dim(`  Run \`rush-ai doctor --fix\` to attempt auto-fixes.`)
+      );
+    }
+  }
+  output.log("");
+}
+function outputJson(checks) {
+  const summary = getSummary(checks);
+  const result = {
+    checks: checks.map((c) => ({
+      name: c.name,
+      group: c.group,
+      status: c.status,
+      label: c.label,
+      value: c.value,
+      ...c.fix ? { fix: c.fix } : {}
+    })),
+    summary
+  };
+  output.log(JSON.stringify(result, null, 2));
+}
+async function runAutoFixes(checks) {
+  const fixable = checks.filter(
+    (c) => c.status !== "pass" && c.status !== "info" && c.autoFix
+  );
+  if (fixable.length === 0) {
+    output.info("No auto-fixable issues found.");
+    return;
+  }
+  output.newline();
+  for (const check of fixable) {
+    output.info(`Fixing: ${check.label}...`);
+    try {
+      await check.autoFix();
+      output.success(`Fixed: ${check.label}`);
+    } catch (err) {
+      output.error(
+        `Failed to fix ${check.label}: ${err instanceof Error ? err.message : "unknown error"}`
+      );
+    }
+  }
+  output.newline();
+}
+function registerDoctorCommand(program) {
+  program.command("doctor").description("Diagnose environment, auth, and connectivity issues").option("--fix", "Attempt to auto-fix detected issues").action(async (opts) => {
+    const jsonMode = program.opts().json;
+    let checks = await runAllChecks();
+    if (opts.fix) {
+      await runAutoFixes(checks);
+      checks = await runAllChecks();
+    }
+    if (jsonMode) {
+      outputJson(checks);
+    } else {
+      displayResults(checks);
+    }
+    const hasFail = checks.some((c) => c.status === "fail");
+    if (hasFail) {
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/mcp/index.ts
+function formatValidationStatus(vs) {
+  if (!vs) return "-";
+  switch (vs.status) {
+    case "verified":
+      return "\u2713 verified";
+    case "pending":
+      return "\u2026 pending";
+    case "credential_required":
+      return "\u26A0 credential required";
+    case "failed":
+      return `\u2717 ${vs.errorCode || "failed"}`;
+    default:
+      return vs.status;
+  }
+}
+function truncate3(str, max) {
+  if (str.length <= max) return str;
+  return `${str.slice(0, max - 3)}...`;
+}
+function registerMcpCommand(program) {
+  const mcp = program.command("mcp").description("MCP server and platform MCP discovery");
+  mcp.command("serve").description("Start the MCP stdio server").action(async () => {
+    const { startMcpServer } = await import("./server-PVZOTJZA.js");
+    await startMcpServer();
+  });
+  mcp.command("list").alias("ls").description("List available MCP servers on the platform").option("-c, --category <category>", "Filter by category").option("-t, --tag <tag>", "Filter by tag").option("-s, --search <query>", "Search by name or description").option("--transport <type>", "Filter by transport type (stdio|sse|http)").option(
+    "-l, --limit <number>",
+    "Max results per page (default: 50, max: 100)",
+    "50"
+  ).option("-p, --page <number>", "Page number (default: 1)", "1").action(async (opts) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    const params = new URLSearchParams();
+    if (opts.category) params.set("category", opts.category);
+    if (opts.tag) params.set("tag", opts.tag);
+    if (opts.search) params.set("search", opts.search);
+    if (opts.transport) params.set("transport", opts.transport);
+    const parsedLimit = parseInt(opts.limit, 10);
+    params.set(
+      "limit",
+      String(
+        Math.min(
+          Math.max(Number.isFinite(parsedLimit) ? parsedLimit : 50, 1),
+          100
+        )
+      )
+    );
+    const parsedPage = parseInt(opts.page, 10);
+    params.set(
+      "page",
+      String(Math.max(Number.isFinite(parsedPage) ? parsedPage : 1, 1))
+    );
+    const { data } = await client.get(
+      `/api/mcp-registry?${params.toString()}`
+    );
+    const servers = data.data;
+    const pagination = data.meta?.pagination;
+    if (format === "json") {
+      output.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    if (servers.length === 0) {
+      output.info("No MCP servers found.");
+      return;
+    }
+    const totalItems = pagination?.totalItems ?? servers.length;
+    output.log(output.bold(`MCP Servers (${totalItems} total):`));
+    output.newline();
+    const rows = servers.map((m) => ({
+      ID: m.id,
+      "Display Name": truncate3(m.displayName, 30),
+      Category: m.category || "-",
+      Transport: m.transportType || "-",
+      Tools: String(m.tools?.length ?? 0),
+      Status: formatValidationStatus(m.validationStatus)
+    }));
+    output.log(
+      formatOutput(rows, format, {
+        columns: { "Display Name": { maxWidth: 30 } }
+      })
+    );
+    if (pagination && pagination.hasNext) {
+      output.newline();
+      output.dim(
+        `Page ${pagination.currentPage} of ${pagination.totalPages}. Use --page ${pagination.currentPage + 1} to see more.`
+      );
+    }
+  });
+  mcp.command("list-tools <server-id>").description("List tools provided by an MCP server").action(async (serverId) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    let data;
+    try {
+      ({ data } = await client.get(
+        `/api/mcp-registry/${encodeURIComponent(serverId)}`
+      ));
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404) {
+        output.error(`MCP server '${serverId}' not found.`);
+        process.exitCode = 1;
+        return;
+      }
+      throw err;
+    }
+    const server = data.data;
+    if (format === "json") {
+      output.log(JSON.stringify(server, null, 2));
+      return;
+    }
+    output.log(output.bold(`${server.displayName} (${server.id})`));
+    output.log(`  Category:   ${server.category || "-"}`);
+    output.log(`  Transport:  ${server.transportType || "-"}`);
+    output.log(`  Author:     ${server.author || "-"}`);
+    output.log(
+      `  Status:     ${formatValidationStatus(server.validationStatus)}`
+    );
+    output.newline();
+    const tools = server.tools ?? [];
+    if (tools.length === 0) {
+      output.info("No tools defined for this MCP server.");
+      return;
+    }
+    output.log(output.bold(`Tools (${tools.length}):`));
+    output.newline();
+    const rows = tools.map((t) => ({
+      "Tool Name": t.name || "-",
+      Description: truncate3(t.description || "", 60)
+    }));
+    output.log(
+      formatOutput(rows, format, {
+        columns: { Description: { maxWidth: 60 } }
+      })
+    );
+  });
+}
+
+// src/commands/plugin/index.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir8 } from "os";
+import { resolve as resolve6 } from "path";
+import chalk4 from "chalk";
+
+// src/commands/plugin/adapters/claude-code.ts
+import { existsSync as existsSync5 } from "fs";
+import { homedir as homedir3 } from "os";
+import { resolve as resolve3 } from "path";
+
+// src/commands/plugin/adapters/base.ts
+import {
+  copyFileSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { resolve as resolve2 } from "path";
+var BaseJsonAdapter = class {
+  detect() {
+    return existsSync4(this.configDir);
+  }
+  readConfig() {
+    const file = this.configPath();
+    if (!existsSync4(file)) return {};
+    try {
+      return JSON.parse(readFileSync2(file, "utf-8"));
+    } catch (err) {
+      throw new Error(
+        `Failed to parse ${file}: ${err instanceof Error ? err.message : "invalid JSON"}`
+      );
+    }
+  }
+  validateConfig(config) {
+    return config !== null && typeof config === "object" && !Array.isArray(config);
+  }
+  injectMcpConfig(config, apiUrl) {
+    const mcpServers = config.mcpServers ?? {};
+    mcpServers.rush = {
+      command: "rush-ai",
+      args: ["mcp", "serve"],
+      env: {
+        RUSH_API_URL: apiUrl
+      }
+    };
+    return { ...config, mcpServers };
+  }
+  removeMcpConfig(config) {
+    const mcpServers = config.mcpServers;
+    if (mcpServers && "rush" in mcpServers) {
+      delete mcpServers.rush;
+    }
+    return config;
+  }
+  writeConfig(config) {
+    const file = this.configPath();
+    if (!existsSync4(this.configDir)) {
+      mkdirSync2(this.configDir, { recursive: true });
+    }
+    if (existsSync4(file)) {
+      copyFileSync(file, `${file}.bak`);
+    }
+    writeFileSync2(file, JSON.stringify(config, null, 2), "utf-8");
+  }
+  configPath() {
+    return resolve2(this.configDir, this.configFile);
+  }
+};
+
+// src/commands/plugin/adapters/claude-code.ts
+var ClaudeCodeAdapter = class extends BaseJsonAdapter {
+  name = "claude-code";
+  description = "Claude Code integration (MCP config + SKILL.md + commands)";
+  version = "0.2.0";
+  configDir = resolve3(homedir3(), ".claude");
+  configFile = "settings.json";
+  detect() {
+    return existsSync5(this.configDir);
+  }
+};
+
+// src/commands/plugin/adapters/cursor.ts
+import { existsSync as existsSync6 } from "fs";
+import { homedir as homedir4 } from "os";
+import { resolve as resolve4 } from "path";
+var CursorAdapter = class extends BaseJsonAdapter {
+  name = "cursor";
+  description = "Cursor integration (MCP config)";
+  version = "0.2.0";
+  configDir = resolve4(homedir4(), ".cursor");
+  configFile = "mcp.json";
+  detect() {
+    return existsSync6(this.configDir);
+  }
+};
+
+// src/commands/plugin/adapters/index.ts
+var ADAPTER_REGISTRY = {
+  "claude-code": () => new ClaudeCodeAdapter(),
+  cursor: () => new CursorAdapter()
+};
+function getAdapter(name) {
+  const factory = ADAPTER_REGISTRY[name];
+  return factory ? factory() : null;
+}
+function getAvailableAdapters() {
+  return Object.keys(ADAPTER_REGISTRY);
+}
+function getAdapterDescriptions() {
+  return Object.entries(ADAPTER_REGISTRY).map(([name, factory]) => {
+    const adapter = factory();
+    return {
+      name,
+      description: adapter.description,
+      version: adapter.version
+    };
+  });
+}
+
+// src/commands/plugin/assets.ts
+import { createHash } from "crypto";
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync7,
+  lstatSync,
+  mkdirSync as mkdirSync3,
+  readdirSync,
+  readFileSync as readFileSync3,
+  readlinkSync,
+  rmSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname2, join as join2, relative, resolve as resolve5 } from "path";
+var ASSET_SCHEMA_VERSION = 1;
+var PLUGINS_BASE = resolve5(homedir5(), ".rush", "plugins");
+function getAssetManifestPath(pluginName) {
+  return resolve5(PLUGINS_BASE, pluginName, "asset-manifest.json");
+}
+function getAssetStorePath(pluginName) {
+  return resolve5(PLUGINS_BASE, pluginName, "assets");
+}
+function computeChecksum(filePath) {
+  const content = readFileSync3(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+function loadAssetManifest(pluginName) {
+  const manifestPath = getAssetManifestPath(pluginName);
+  if (!existsSync7(manifestPath)) return null;
+  try {
+    return JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function installAssets(options) {
+  const { pluginName, sourceDir, cliVersion, force = false } = options;
+  const storePath = getAssetStorePath(pluginName);
+  const manifestPath = getAssetManifestPath(pluginName);
+  mkdirSync3(storePath, { recursive: true });
+  const files = [];
+  const existing = loadAssetManifest(pluginName);
+  const sourceFiles = collectFiles(sourceDir);
+  for (const relPath of sourceFiles) {
+    const srcFile = resolve5(sourceDir, relPath);
+    const destFile = resolve5(storePath, relPath);
+    const newChecksum = computeChecksum(srcFile);
+    if (existsSync7(destFile) && !force && existing) {
+      const existingEntry = existing.files.find((f) => f.path === relPath);
+      if (existingEntry) {
+        const currentChecksum = computeChecksum(destFile);
+        if (currentChecksum !== existingEntry.checksum && currentChecksum !== newChecksum) {
+          output.warn(
+            `  Skipping ${relPath}: modified by user (use --force to overwrite)`
+          );
+          files.push({
+            ...existingEntry,
+            checksum: currentChecksum
+          });
+          continue;
+        }
+      }
+    }
+    mkdirSync3(dirname2(destFile), { recursive: true });
+    copyFileSync2(srcFile, destFile);
+    files.push({
+      path: relPath,
+      checksum: newChecksum,
+      target: destFile,
+      type: "file"
+    });
+  }
+  const skillTarget = resolve5(homedir5(), ".claude", "skills", "rush-task");
+  if (!existsSync7(skillTarget)) {
+    mkdirSync3(dirname2(skillTarget), { recursive: true });
+    try {
+      symlinkSync(storePath, skillTarget, "dir");
+      files.push({
+        path: "_symlink_skill",
+        checksum: "",
+        target: skillTarget,
+        type: "symlink"
+      });
+    } catch {
+      output.dim(
+        `  Note: Could not create symlink at ${skillTarget}. You may need to manually link the skill.`
+      );
+    }
+  } else {
+    try {
+      const stat = lstatSync(skillTarget);
+      if (stat.isSymbolicLink()) {
+        const linkTarget = readlinkSync(skillTarget);
+        if (linkTarget === storePath || resolve5(linkTarget) === storePath) {
+          files.push({
+            path: "_symlink_skill",
+            checksum: "",
+            target: skillTarget,
+            type: "symlink"
+          });
+        } else {
+          output.warn(
+            `  Skipping symlink at ${skillTarget}: already points to a different location (${linkTarget})`
+          );
+        }
+      } else {
+        output.warn(
+          `  Skipping symlink at ${skillTarget}: path already exists and is not a symlink`
+        );
+      }
+    } catch {
+    }
+  }
+  const manifest = {
+    schema_version: ASSET_SCHEMA_VERSION,
+    version: options.cliVersion,
+    cli_version: cliVersion,
+    owner: "rush-ai",
+    files,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync3(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  return manifest;
+}
+var ALLOWED_DELETE_PREFIXES = [
+  resolve5(homedir5(), ".rush", "plugins"),
+  resolve5(homedir5(), ".claude", "skills")
+];
+function isPathAllowed(targetPath) {
+  const resolved = resolve5(targetPath);
+  return ALLOWED_DELETE_PREFIXES.some(
+    (prefix) => resolved.startsWith(`${prefix}/`)
+  );
+}
+function uninstallAssets(pluginName) {
+  const manifest = loadAssetManifest(pluginName);
+  if (!manifest) return;
+  if (manifest.owner !== "rush-ai") {
+    output.warn(
+      `  Skipping asset removal: manifest owner "${manifest.owner}" is not "rush-ai"`
+    );
+    return;
+  }
+  for (const entry of manifest.files) {
+    if (!existsSync7(entry.target)) continue;
+    if (!isPathAllowed(entry.target)) {
+      output.warn(
+        `  Refusing to delete ${entry.target}: outside allowed directories`
+      );
+      continue;
+    }
+    if (entry.type === "symlink") {
+      try {
+        const stat = lstatSync(entry.target);
+        if (stat.isSymbolicLink()) {
+          unlinkSync(entry.target);
+        }
+      } catch {
+      }
+    } else if (entry.type === "file") {
+      try {
+        const currentChecksum = computeChecksum(entry.target);
+        if (currentChecksum === entry.checksum) {
+          rmSync(entry.target);
+        } else {
+          output.warn(
+            `  Skipping ${entry.path}: file was modified after installation`
+          );
+        }
+      } catch {
+      }
+    }
+  }
+  const manifestPath = getAssetManifestPath(pluginName);
+  if (existsSync7(manifestPath)) {
+    rmSync(manifestPath);
+  }
+  const storePath = getAssetStorePath(pluginName);
+  try {
+    const remaining = readdirSync(storePath);
+    if (remaining.length === 0) {
+      rmSync(storePath, { recursive: true });
+    }
+  } catch {
+  }
+}
+function collectFiles(dir, base) {
+  const files = [];
+  const baseDir = base ?? dir;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath, baseDir));
+    } else if (entry.isFile()) {
+      files.push(relative(baseDir, fullPath));
+    }
+  }
+  return files;
+}
+
+// src/commands/plugin/doctor.ts
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import path from "path";
+function findCliInPath() {
+  const pathDirs = (process.env.PATH || "").split(path.delimiter);
+  for (const dir of pathDirs) {
+    const candidate = path.join(dir, "rush-ai");
+    if (existsSync8(candidate)) return candidate;
+  }
+  return null;
+}
+function checkCliInPath() {
+  const found = findCliInPath();
+  if (found) {
+    return {
+      name: "cli_in_path",
+      label: "CLI in PATH",
+      status: "pass",
+      detail: `rush-ai found at ${found}`
+    };
+  }
+  return {
+    name: "cli_in_path",
+    label: "CLI in PATH",
+    status: "warn",
+    detail: "rush-ai not found in PATH",
+    fix: "Ensure rush-ai is installed globally or add its directory to PATH"
+  };
+}
+function checkAuth2() {
+  try {
+    const token = getAuthToken();
+    if (token) {
+      return {
+        name: "auth_status",
+        label: "Authentication",
+        status: "pass",
+        detail: "Authenticated"
+      };
+    }
+  } catch {
+  }
+  return {
+    name: "auth_status",
+    label: "Authentication",
+    status: "warn",
+    detail: "Not authenticated",
+    fix: "Run `rush-ai auth login` to authenticate"
+  };
+}
+async function checkApiConnectivity() {
+  try {
+    const client = createClient();
+    await client.get("/api/agents?limit=1");
+    return {
+      name: "api_connectivity",
+      label: "API connectivity",
+      status: "pass",
+      detail: "API is reachable"
+    };
+  } catch {
+    return {
+      name: "api_connectivity",
+      label: "API connectivity",
+      status: "warn",
+      detail: "API is unreachable",
+      fix: "Check your network connection and API URL in ~/.rush/config.json"
+    };
+  }
+}
+function checkPluginInstalled(ctx) {
+  if (ctx.manifest) {
+    return {
+      name: "plugin_installed",
+      label: "Plugin installed",
+      status: "pass",
+      detail: `v${ctx.manifest.version} (installed ${new Date(ctx.manifest.installedAt).toLocaleDateString()})`
+    };
+  }
+  return {
+    name: "plugin_installed",
+    label: "Plugin installed",
+    status: "fail",
+    detail: "Not installed",
+    fix: `Run \`rush-ai plugin install ${ctx.pluginName}\``
+  };
+}
+function checkMcpConfig(ctx) {
+  const type2 = ctx.manifest?.type ?? ctx.pluginInfo?.types?.[0];
+  let configPath;
+  if (type2 === "claude-code") {
+    configPath = path.resolve(homedir6(), ".claude", "settings.json");
+  } else if (type2 === "cursor") {
+    configPath = path.resolve(homedir6(), ".cursor", "mcp.json");
+  } else {
+    return {
+      name: "mcp_config",
+      label: "MCP config",
+      status: "warn",
+      detail: `Unknown plugin type: ${type2}`
+    };
+  }
+  if (!existsSync8(configPath)) {
+    return {
+      name: "mcp_config",
+      label: "MCP config",
+      status: "fail",
+      detail: `Config file not found: ${configPath}`,
+      fix: `Run \`rush-ai plugin install ${ctx.pluginName}\``
+    };
+  }
+  try {
+    const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+    const servers = config.mcpServers;
+    if (servers && "rush" in servers) {
+      const rushServer = servers.rush;
+      const command = rushServer?.command;
+      if (command === "rush-ai") {
+        return {
+          name: "mcp_config",
+          label: "MCP config",
+          status: "pass",
+          detail: "rush MCP server configured correctly"
+        };
+      }
+      return {
+        name: "mcp_config",
+        label: "MCP config",
+        status: "warn",
+        detail: `rush server configured, but command is "${command}" (expected "rush-ai")`,
+        fix: `Run \`rush-ai plugin update ${ctx.pluginName}\``
+      };
+    }
+    return {
+      name: "mcp_config",
+      label: "MCP config",
+      status: "fail",
+      detail: "rush MCP server not found in config",
+      fix: `Run \`rush-ai plugin install ${ctx.pluginName}\``
+    };
+  } catch {
+    return {
+      name: "mcp_config",
+      label: "MCP config",
+      status: "fail",
+      detail: `Failed to parse config: ${configPath}`,
+      fix: "Check file for JSON syntax errors"
+    };
+  }
+}
+function checkVersionMatch(ctx) {
+  if (!ctx.manifest || !ctx.pluginInfo) {
+    return {
+      name: "version_match",
+      label: "Version",
+      status: "warn",
+      detail: "Cannot check version (plugin not installed or unknown)"
+    };
+  }
+  if (ctx.manifest.version === ctx.pluginInfo.version) {
+    return {
+      name: "version_match",
+      label: "Version",
+      status: "pass",
+      detail: `Up to date (v${ctx.manifest.version})`
+    };
+  }
+  return {
+    name: "version_match",
+    label: "Version",
+    status: "warn",
+    detail: `Installed v${ctx.manifest.version}, latest v${ctx.pluginInfo.version}`,
+    fix: `Run \`rush-ai plugin update ${ctx.pluginName}\``
+  };
+}
+async function runDoctorChecks(ctx) {
+  const results = [];
+  results.push(checkCliInPath());
+  results.push(checkAuth2());
+  results.push(await checkApiConnectivity());
+  results.push(checkPluginInstalled(ctx));
+  results.push(checkMcpConfig(ctx));
+  results.push(checkVersionMatch(ctx));
+  return results;
+}
+
+// src/commands/plugin/preflight.ts
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir7 } from "os";
+import path2 from "path";
+import chalk3 from "chalk";
+async function runPreflightChecks(options) {
+  const results = [];
+  try {
+    const token = getAuthToken();
+    if (token) {
+      results.push({
+        name: "Authentication",
+        status: "pass",
+        detail: "Authenticated"
+      });
+    } else {
+      results.push({
+        name: "Authentication",
+        status: options.strict ? "fail" : "warn",
+        detail: "Not authenticated. MCP server may not work until you login."
+      });
+    }
+  } catch {
+    results.push({
+      name: "Authentication",
+      status: options.strict ? "fail" : "warn",
+      detail: "Not authenticated. MCP server may not work until you login."
+    });
+  }
+  try {
+    const client = createClient();
+    await client.get("/api/agents?limit=1");
+    results.push({
+      name: "API connectivity",
+      status: "pass",
+      detail: "API is reachable"
+    });
+  } catch {
+    results.push({
+      name: "API connectivity",
+      status: options.strict ? "fail" : "warn",
+      detail: "API is unreachable. MCP server may not work until API is reachable."
+    });
+  }
+  const rushDir = path2.resolve(homedir7(), ".rush");
+  try {
+    if (!existsSync9(rushDir)) {
+      mkdirSync4(rushDir, { recursive: true });
+    }
+    accessSync2(rushDir, constants2.W_OK);
+    results.push({
+      name: "Config directory",
+      status: "pass",
+      detail: `Config directory is writable: ${rushDir}`
+    });
+  } catch {
+    results.push({
+      name: "Config directory",
+      status: "fail",
+      detail: `Config directory is not writable: ${rushDir}`
+    });
+  }
+  if (options.json) {
+    output.log(JSON.stringify({ preflight: results }, null, 2));
+  } else {
+    output.info("Preflight checks...");
+    for (const r of results) {
+      const icon = r.status === "pass" ? chalk3.green("[PASS]") : r.status === "warn" ? chalk3.yellow("[WARN]") : chalk3.red("[FAIL]");
+      output.log(`  ${icon} ${r.name}: ${r.detail}`);
+    }
+  }
+  return !results.some((r) => r.status === "fail");
+}
+
+// src/commands/plugin/verify.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync10 } from "fs";
+async function runVerification(options) {
+  const results = [];
+  results.push(checkConfigFile(options.adapter));
+  const mcpResults = await verifyMcpConnectivity(options.mode);
+  results.push(...mcpResults);
+  results.push(checkAuthStatus());
+  return results;
+}
+function checkConfigFile(adapter) {
+  const configFile = adapter.configPath();
+  if (!existsSync10(configFile)) {
+    return {
+      name: "config_file",
+      label: "IDE config",
+      stage: "config",
+      status: "warn",
+      detail: `Config file not found: ${configFile}`,
+      fix: `Run \`rush-ai plugin install ${adapter.name}\``
+    };
+  }
+  try {
+    const config = adapter.readConfig();
+    if (!adapter.validateConfig(config)) {
+      return {
+        name: "config_file",
+        label: "IDE config",
+        stage: "config",
+        status: "fail",
+        detail: `Invalid config format: ${configFile}`,
+        fix: "Check file for JSON syntax errors"
+      };
+    }
+    const mcpServers = config.mcpServers;
+    if (mcpServers && "rush" in mcpServers) {
+      return {
+        name: "config_file",
+        label: "IDE config",
+        stage: "config",
+        status: "pass",
+        detail: "Rush MCP server configured"
+      };
+    }
+    return {
+      name: "config_file",
+      label: "IDE config",
+      stage: "config",
+      status: "fail",
+      detail: "Rush MCP server not found in config",
+      fix: `Run \`rush-ai plugin install ${adapter.name}\``
+    };
+  } catch {
+    return {
+      name: "config_file",
+      label: "IDE config",
+      stage: "config",
+      status: "fail",
+      detail: `Failed to read config: ${configFile}`,
+      fix: "Check file for JSON syntax errors"
+    };
+  }
+}
+async function verifyMcpConnectivity(mode) {
+  const results = [];
+  try {
+    execFileSync2("rush-ai", ["--version"], {
+      timeout: 5e3,
+      stdio: "pipe"
+    });
+    results.push({
+      name: "mcp_cli_exec",
+      label: "CLI executable",
+      stage: "cli",
+      status: "pass",
+      detail: "rush-ai executable responds"
+    });
+  } catch (err) {
+    results.push({
+      name: "mcp_cli_exec",
+      label: "CLI executable",
+      stage: "cli",
+      status: "fail",
+      detail: `rush-ai failed to execute: ${err instanceof Error ? err.message : "unknown error"}`,
+      fix: "Ensure rush-ai is installed and accessible in PATH"
+    });
+    return results;
+  }
+  try {
+    const { createClient: createClient2 } = await import("./client-2GSYT7IS.js");
+    const client = createClient2();
+    await client.get("/api/agents?limit=1");
+    results.push({
+      name: "mcp_api",
+      label: "API connectivity",
+      stage: "api",
+      status: "pass",
+      detail: "Rush API is reachable"
+    });
+  } catch {
+    results.push({
+      name: "mcp_api",
+      label: "API connectivity",
+      stage: "api",
+      status: mode === "install" ? "warn" : "fail",
+      detail: mode === "install" ? "API unreachable (install will continue, but MCP tools may not work until resolved)" : "API unreachable",
+      fix: "Check network connection or run `rush-ai auth login`"
+    });
+  }
+  return results;
+}
+function checkAuthStatus() {
+  try {
+    const token = getAuthToken();
+    if (token) {
+      return {
+        name: "auth_status",
+        label: "Authentication",
+        stage: "auth",
+        status: "pass",
+        detail: "Authenticated"
+      };
+    }
+  } catch {
+  }
+  return {
+    name: "auth_status",
+    label: "Authentication",
+    stage: "auth",
+    status: "warn",
+    detail: "Not authenticated",
+    fix: "Run `rush-ai auth login` to authenticate"
+  };
+}
+
+// src/commands/plugin/index.ts
+var CURRENT_SCHEMA_VERSION = 2;
+var PLUGINS_DIR = resolve6(homedir8(), ".rush", "plugins");
+var PLUGINS_FILE2 = resolve6(PLUGINS_DIR, "installed.json");
+function safeReadJson2(filePath, fallback) {
+  if (!existsSync11(filePath)) return fallback;
+  try {
+    return JSON.parse(readFileSync5(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function loadInstalledPlugins(autoMigrate = true) {
+  const raw = safeReadJson2(PLUGINS_FILE2, {
+    plugins: {}
+  });
+  const schemaVersion = raw.schema_version ?? 0;
+  if (schemaVersion < CURRENT_SCHEMA_VERSION) {
+    const migrated = migrateInstalledPlugins(raw);
+    if (autoMigrate) {
+      saveInstalledPlugins(migrated);
+    }
+    return migrated;
+  }
+  return raw;
+}
+function saveInstalledPlugins(data) {
+  if (!existsSync11(PLUGINS_DIR)) {
+    mkdirSync5(PLUGINS_DIR, { recursive: true });
+  }
+  writeFileSync4(PLUGINS_FILE2, JSON.stringify(data, null, 2), "utf-8");
+}
+function migrateInstalledPlugins(data) {
+  const result = {
+    schema_version: CURRENT_SCHEMA_VERSION,
+    plugins: {}
+  };
+  const oldPlugins = data.plugins ?? {};
+  for (const [name, manifest] of Object.entries(oldPlugins)) {
+    result.plugins[name] = {
+      name: manifest.name ?? name,
+      version: manifest.version ?? "0.1.0",
+      type: manifest.type ?? name,
+      installedAt: manifest.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      cli_version: manifest.cli_version ?? "unknown",
+      adapter: manifest.adapter ?? (manifest.type === "claude-code" ? "claude-code" : manifest.type ?? name)
+    };
+  }
+  return result;
+}
+function resolvePluginAssetsDir() {
+  const baseDir = import.meta.dirname ?? __dirname;
+  if (!baseDir) {
+    output.dim(
+      "  Warning: Could not resolve plugin assets directory (import.meta.dirname and __dirname are both unavailable)"
+    );
+    return null;
+  }
+  const bundled = resolve6(baseDir, "plugin-assets");
+  if (existsSync11(bundled)) return bundled;
+  const monorepo = resolve6(baseDir, "..", "..", "..", "..", "rush-plugin");
+  if (existsSync11(monorepo)) return monorepo;
+  return null;
+}
+function getCliVersion() {
+  try {
+    const pkgPath = resolve6(
+      import.meta.dirname ?? __dirname,
+      "..",
+      "..",
+      "package.json"
+    );
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    return pkg.version ?? "0.2.0";
+  } catch {
+    return "0.2.0";
+  }
+}
+function registerPluginCommand(program) {
+  const plugin = program.command("plugin").description("Manage IDE plugins");
+  plugin.command("list").alias("ls").description("List available and installed plugins").action(() => {
+    const format = resolveFormat(program.opts());
+    const installed = loadInstalledPlugins(false);
+    const adapters = getAdapterDescriptions();
+    const plugins = adapters.map((a) => ({
+      name: a.name,
+      description: a.description,
+      version: a.version,
+      installed: a.name in installed.plugins,
+      installedVersion: installed.plugins[a.name]?.version ?? null
+    }));
+    if (format === "json") {
+      output.log(JSON.stringify({ plugins }, null, 2));
+      return;
+    }
+    output.log(output.bold("Available plugins:"));
+    output.newline();
+    const rows = plugins.map((p) => ({
+      Name: p.name,
+      Version: p.version,
+      Status: p.installed ? "installed" : "available",
+      Description: p.description
+    }));
+    output.log(
+      formatOutput(rows, format, {
+        columns: { Description: { maxWidth: 60 } }
+      })
+    );
+  });
+  plugin.command("install").description("Install a plugin").argument("<name>", `Plugin name (${getAvailableAdapters().join(" | ")})`).option("--force", "Skip preflight checks and overwrite modified assets").option("--strict-preflight", "Fail on preflight warnings (for CI)").action(
+    async (name, options) => {
+      const format = resolveFormat(program.opts());
+      const adapter = getAdapter(name);
+      if (!adapter) {
+        throw new RushError(
+          `Unknown plugin: ${name}. Available: ${getAvailableAdapters().join(", ")}`
+        );
+      }
+      const installed = loadInstalledPlugins();
+      if (installed.plugins[name]) {
+        if (format === "json") {
+          output.log(JSON.stringify({ status: "already_installed", name }));
+        } else {
+          output.warn(`Plugin "${name}" is already installed.`);
+          output.dim("Use `rush-ai plugin update` to update.");
+        }
+        return;
+      }
+      if (!options.force) {
+        const preflightOk = await runPreflightChecks({
+          strict: options.strictPreflight ?? false,
+          json: format === "json"
+        });
+        if (!preflightOk) {
+          output.newline();
+          output.dim("Use --force to skip preflight checks.");
+          process.exit(1);
+        }
+      }
+      const config = getGlobalConfig();
+      const existing = adapter.readConfig();
+      const updated = adapter.injectMcpConfig(existing, config.api);
+      adapter.writeConfig(updated);
+      output.dim(`  MCP config injected into ${adapter.configPath()}`);
+      const cliVersion = getCliVersion();
+      if (name === "claude-code") {
+        const assetsDir = resolvePluginAssetsDir();
+        if (assetsDir) {
+          installAssets({
+            pluginName: name,
+            sourceDir: assetsDir,
+            cliVersion,
+            force: options.force
+          });
+          output.dim("  Plugin assets installed");
+        }
+      }
+      installed.plugins[name] = {
+        name,
+        version: adapter.version,
+        type: name,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cli_version: cliVersion,
+        adapter: adapter.name
+      };
+      saveInstalledPlugins(installed);
+      if (format !== "json") {
+        output.newline();
+        output.info("Post-install verification...");
+        const verifyResults = await runVerification({
+          mode: "install",
+          pluginName: name,
+          adapter
+        });
+        printVerifyResults(verifyResults);
+        const hasFail = verifyResults.some((r) => r.status === "fail");
+        if (hasFail) {
+          output.newline();
+          output.warn(
+            "Some checks failed. Plugin is installed but may not work correctly."
+          );
+          output.dim(
+            "Run `rush-ai plugin doctor` for detailed diagnostics."
+          );
+        }
+      }
+      if (format === "json") {
+        output.log(
+          JSON.stringify({
+            status: "installed",
+            name,
+            version: adapter.version
+          })
+        );
+      } else {
+        output.newline();
+        output.success(`Plugin "${name}" installed.`);
+      }
+    }
+  );
+  plugin.command("status").description("Show plugin status").argument("<name>", "Plugin name").action((name) => {
+    const format = resolveFormat(program.opts());
+    const installed = loadInstalledPlugins(false);
+    const manifest = installed.plugins[name];
+    if (format === "json") {
+      output.log(
+        JSON.stringify(
+          manifest ? { ...manifest, installed: true } : { name, installed: false }
+        )
+      );
+    } else if (manifest) {
+      output.log(output.bold(name));
+      output.log(`  Version: ${manifest.version}`);
+      output.log(`  Type: ${manifest.type}`);
+      output.log(`  CLI version: ${manifest.cli_version}`);
+      output.log(`  Adapter: ${manifest.adapter}`);
+      output.log(
+        `  Installed: ${new Date(manifest.installedAt).toLocaleString()}`
+      );
+    } else {
+      output.warn(`Plugin "${name}" is not installed.`);
+    }
+  });
+  plugin.command("update").description("Update a plugin").argument("<name>", "Plugin name").option("--force", "Overwrite modified assets").action(async (name, options) => {
+    const format = resolveFormat(program.opts());
+    const installed = loadInstalledPlugins();
+    const manifest = installed.plugins[name];
+    if (!manifest) {
+      throw new RushError(`Plugin "${name}" is not installed.`);
+    }
+    const adapter = getAdapter(name);
+    if (!adapter) {
+      throw new RushError(`Unknown plugin: ${name}`);
+    }
+    const config = getGlobalConfig();
+    const existing = adapter.readConfig();
+    const updated = adapter.injectMcpConfig(existing, config.api);
+    adapter.writeConfig(updated);
+    const cliVersion = getCliVersion();
+    if (name === "claude-code") {
+      const assetsDir = resolvePluginAssetsDir();
+      if (assetsDir) {
+        installAssets({
+          pluginName: name,
+          sourceDir: assetsDir,
+          cliVersion,
+          force: options.force
+        });
+      }
+    }
+    installed.plugins[name] = {
+      ...manifest,
+      version: adapter.version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cli_version: cliVersion,
+      adapter: adapter.name
+    };
+    saveInstalledPlugins(installed);
+    if (format === "json") {
+      output.log(
+        JSON.stringify({
+          status: "updated",
+          name,
+          version: adapter.version
+        })
+      );
+    } else {
+      output.success(`Plugin "${name}" updated to v${adapter.version}.`);
+    }
+  });
+  plugin.command("uninstall").description("Uninstall a plugin").argument("<name>", "Plugin name").action((name) => {
+    const format = resolveFormat(program.opts());
+    const installed = loadInstalledPlugins();
+    if (!installed.plugins[name]) {
+      if (format === "json") {
+        output.log(JSON.stringify({ status: "not_installed", name }));
+      } else {
+        output.warn(`Plugin "${name}" is not installed.`);
+      }
+      return;
+    }
+    const adapter = getAdapter(name);
+    if (adapter) {
+      const config = adapter.readConfig();
+      const cleaned = adapter.removeMcpConfig(config);
+      adapter.writeConfig(cleaned);
+    }
+    uninstallAssets(name);
+    delete installed.plugins[name];
+    saveInstalledPlugins(installed);
+    if (format === "json") {
+      output.log(JSON.stringify({ status: "uninstalled", name }));
+    } else {
+      output.success(`Plugin "${name}" uninstalled.`);
+    }
+  });
+  plugin.command("doctor").description("Diagnose plugin configuration issues").argument("[name]", "Plugin name (diagnose specific plugin)").action(async (name) => {
+    const format = resolveFormat(program.opts());
+    const installed = loadInstalledPlugins();
+    const pluginNames = name ? [name] : Object.keys(installed.plugins).length > 0 ? Object.keys(installed.plugins) : getAvailableAdapters();
+    if (format === "json") {
+      const jsonOutput = [];
+      for (const pluginName of pluginNames) {
+        const adapter = getAdapter(pluginName);
+        if (adapter) {
+          const results = await runVerification({
+            mode: "doctor",
+            pluginName,
+            adapter
+          });
+          const summary = { pass: 0, warn: 0, fail: 0 };
+          for (const r of results) summary[r.status]++;
+          jsonOutput.push({
+            plugin: pluginName,
+            checks: results.map((r) => ({
+              name: r.name,
+              stage: r.stage,
+              status: r.status,
+              detail: r.detail,
+              ...r.fix ? { fix: r.fix } : {}
+            })),
+            summary
+          });
+        }
+      }
+      output.log(
+        JSON.stringify(
+          jsonOutput.length === 1 ? jsonOutput[0] : jsonOutput,
+          null,
+          2
+        )
+      );
+      return;
+    }
+    for (const pluginName of pluginNames) {
+      const manifest = installed.plugins[pluginName];
+      const adapter = getAdapter(pluginName);
+      output.log(output.bold(`Plugin Doctor \u2014 ${pluginName}`));
+      output.newline();
+      const checks = await runDoctorChecks({
+        pluginName,
+        manifest: manifest ?? null,
+        pluginInfo: adapter ? {
+          description: adapter.description,
+          types: [adapter.name],
+          version: adapter.version
+        } : null
+      });
+      let pass = 0;
+      let warn = 0;
+      let fail = 0;
+      for (const check of checks) {
+        const icon = check.status === "pass" ? chalk4.green("[PASS]") : check.status === "warn" ? chalk4.yellow("[WARN]") : chalk4.red("[FAIL]");
+        output.log(`  ${icon} ${check.label}: ${check.detail}`);
+        if (check.fix) {
+          output.dim(`         Fix: ${check.fix}`);
+        }
+        if (check.status === "pass") pass++;
+        else if (check.status === "warn") warn++;
+        else fail++;
+      }
+      output.newline();
+      const parts = [];
+      if (pass > 0) parts.push(`${pass} passed`);
+      if (warn > 0) parts.push(`${warn} warning${warn > 1 ? "s" : ""}`);
+      if (fail > 0) parts.push(`${fail} failed`);
+      output.log(parts.join(", "));
+      output.newline();
+    }
+  });
+}
+function printVerifyResults(results) {
+  for (const r of results) {
+    const icon = r.status === "pass" ? chalk4.green("[PASS]") : r.status === "warn" ? chalk4.yellow("[WARN]") : chalk4.red("[FAIL]");
+    output.log(`  ${icon} ${r.label}: ${r.detail}`);
+    if (r.fix) {
+      output.dim(`         Fix: ${r.fix}`);
+    }
+  }
+}
+
+// src/commands/task/index.ts
+import { createWriteStream } from "fs";
+import { mkdir as mkdir2 } from "fs/promises";
+import path3 from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+
+// src/output/diff.ts
+import chalk5 from "chalk";
+function containsDiff(text) {
+  return /^@@\s+-\d+/m.test(text) || /^---\s+a\//m.test(text);
+}
+function colorizeDiff(text) {
+  return text.split("\n").map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---"))
+      return chalk5.bold(line);
+    if (line.startsWith("+")) return chalk5.green(line);
+    if (line.startsWith("-")) return chalk5.red(line);
+    if (line.startsWith("@@")) return chalk5.cyan(line);
+    return line;
+  }).join("\n");
+}
+
+// src/util/ci.ts
+function isEnvTruthy(value) {
+  if (!value) return false;
+  return ["1", "true", "yes"].includes(value.trim().toLowerCase());
+}
+function isCIMode(programOpts) {
+  if (process.argv.includes("--ci")) return true;
+  if (programOpts?.ci) return true;
+  if (isEnvTruthy(process.env.CI)) return true;
+  if (isEnvTruthy(process.env.RUSH_CI)) return true;
+  return false;
+}
+
+// src/util/stdin.ts
+async function readStdinIfPiped() {
+  if (process.stdin.isTTY) {
+    return null;
+  }
+  return new Promise((resolve7, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    process.stdin.on("end", () => {
+      resolve7(Buffer.concat(chunks).toString("utf-8").trim());
+    });
+    process.stdin.on("error", reject);
+  });
+}
+
+// src/commands/task/index.ts
+var VALID_CATEGORIES = ["code", "image", "document", "other"];
+function sanitizeFilePath(filePath, outputDir) {
+  let stripped = filePath.replace(/^[/\\]+/, "").replace(/^[a-zA-Z]:/, "");
+  stripped = stripped.split("/").filter((seg) => seg !== ".." && seg !== ".").join("/");
+  if (!stripped) return null;
+  const resolvedOutput = path3.resolve(outputDir);
+  const target = path3.resolve(resolvedOutput, stripped);
+  const rel = path3.relative(resolvedOutput, target);
+  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
+    return null;
+  }
+  return target;
+}
+async function downloadFile(url, destPath) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Download failed: ${response.status} ${response.statusText}`
+    );
+  }
+  if (!response.body) {
+    throw new Error("No response body");
+  }
+  await mkdir2(path3.dirname(destPath), { recursive: true });
+  const nodeStream = Readable.fromWeb(
+    response.body
+  );
+  const fileStream = createWriteStream(destPath);
+  await pipeline(nodeStream, fileStream);
+}
+function buildCategorySummary(files) {
+  const counts = {};
+  for (const f of files) {
+    counts[f.category] = (counts[f.category] || 0) + 1;
+  }
+  return Object.entries(counts).map(([cat, count]) => `${count} ${cat}`).join(", ");
+}
+function registerTaskCommand(program) {
+  const task = program.command("task").description("Create and manage tasks");
+  task.command("run").description("Run a task synchronously").requiredOption("-a, --agent <name>", "Agent name to execute the task").option("-p, --prompt <text>", "Task prompt").option("--skills <skills>", "Comma-separated skills to add", commaSplit).option("--mcp <servers>", "Comma-separated MCP servers to add", commaSplit).option("--stream", "Stream output in real-time").option("--timeout <seconds>", "Timeout in seconds", "300").action(
+    async (options) => {
+      requireAuth();
+      const format = resolveFormat(program.opts());
+      const client = createClient();
+      const prompt = options.prompt ?? await readStdinIfPiped();
+      if (!prompt) {
+        throw new RushError(
+          "No prompt provided. Use --prompt or pipe via stdin."
+        );
+      }
+      if (options.stream) {
+        const response = await client.fetchRaw("/api/agent/invoke", {
+          method: "POST",
+          body: JSON.stringify({
+            agent: options.agent,
+            prompt,
+            skills: options.skills,
+            mcpServers: options.mcp,
+            stream: true
+          })
+        });
+        if (!response.body) {
+          throw new RushError("No response body for streaming");
+        }
+        let streamError = null;
+        await consumeSSEStream(response.body, (event) => {
+          if (format === "json") {
+            output.log(JSON.stringify(event));
+          } else if (event.type === "content") {
+            process.stdout.write(event.data);
+          } else if (event.type === "error") {
+            streamError = event.data;
+            output.error(event.data);
+          } else if (event.type === "raw") {
+            process.stdout.write(event.data);
+          }
+        });
+        if (format !== "json") {
+          output.newline();
+        }
+        if (streamError) {
+          throw new TaskFailedError(`Task failed: ${streamError}`, {
+            stream: true
+          });
+        }
+        return;
+      }
+      const { data } = await client.post(
+        "/api/agent/invoke",
+        {
+          agent: options.agent,
+          prompt,
+          skills: options.skills,
+          mcpServers: options.mcp,
+          timeout: Number(options.timeout)
+        }
+      );
+      if (data.status === "failed") {
+        throw new TaskFailedError(
+          `Task ${data.id} failed${data.result?.content ? `: ${data.result.content}` : ""}`,
+          { taskId: data.id }
+        );
+      }
+      if (format === "json") {
+        output.log(JSON.stringify(data, null, 2));
+      } else {
+        output.success(`Task ${data.id} completed.`);
+        if (data.duration) {
+          output.dim(`  Duration: ${(data.duration / 1e3).toFixed(1)}s`);
+        }
+        output.newline();
+        if (data.result?.content) {
+          const content = data.result.content;
+          output.log(containsDiff(content) ? colorizeDiff(content) : content);
+        }
+      }
+    }
+  );
+  task.command("create").description("Create a task asynchronously").requiredOption("-a, --agent <name>", "Agent name to execute the task").option("-p, --prompt <text>", "Task prompt").option("--skills <skills>", "Comma-separated skills to add", commaSplit).option("--mcp <servers>", "Comma-separated MCP servers to add", commaSplit).action(
+    async (options) => {
+      requireAuth();
+      const format = resolveFormat(program.opts());
+      const client = createClient();
+      const prompt = options.prompt ?? await readStdinIfPiped();
+      if (!prompt) {
+        throw new RushError(
+          "No prompt provided. Use --prompt or pipe via stdin."
+        );
+      }
+      const { data } = await client.post("/api/tasks", {
+        agent: options.agent,
+        prompt,
+        skills: options.skills,
+        mcpServers: options.mcp
+      });
+      if (format === "json") {
+        output.log(JSON.stringify(data, null, 2));
+      } else {
+        output.success(`Task created: ${data.id}`);
+        output.dim(`Status: ${data.status}`);
+        output.dim(
+          `Run \`rush-ai task status ${data.id}\` to check progress.`
+        );
+      }
+    }
+  );
+  task.command("status").description("Check task status").argument("<id>", "Task ID").action(async (id) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    const { data } = await client.get(
+      `/api/tasks/${encodeURIComponent(id)}`
+    );
+    if (format === "json") {
+      output.log(JSON.stringify(data, null, 2));
+    } else {
+      output.log(output.bold(`Task ${data.id}`));
+      output.log(`  Agent: ${data.agent}`);
+      output.log(`  Status: ${data.status}`);
+      output.log(`  Created: ${new Date(data.createdAt).toLocaleString()}`);
+      output.log(`  Updated: ${new Date(data.updatedAt).toLocaleString()}`);
+      if (data.error) {
+        output.error(`  Error: ${data.error}`);
+      }
+    }
+    if (isCIMode(program.opts()) && data.status === "failed") {
+      throw new TaskFailedError(
+        `Task ${id} failed: ${data.error ?? "unknown error"}`,
+        { taskId: id, status: data.status }
+      );
+    }
+  });
+  task.command("result").description("Get task result").argument("<id>", "Task ID").action(async (id) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    const { data } = await client.get(
+      `/api/tasks/${encodeURIComponent(id)}/result`
+    );
+    let filesSummary = null;
+    try {
+      const { data: filesData } = await client.get(
+        `/api/chat/${encodeURIComponent(id)}/files`
+      );
+      if (filesData.totalCount > 0) {
+        filesSummary = {
+          totalCount: filesData.totalCount,
+          summary: buildCategorySummary(filesData.files)
+        };
+      }
+    } catch {
+    }
+    if (format === "json") {
+      output.log(
+        JSON.stringify(
+          { ...data, filesSummary: filesSummary ?? void 0 },
+          null,
+          2
+        )
+      );
+    } else {
+      if (typeof data.result === "string") {
+        output.log(
+          containsDiff(data.result) ? colorizeDiff(data.result) : data.result
+        );
+      } else {
+        output.log(JSON.stringify(data.result, null, 2));
+      }
+      if (filesSummary) {
+        output.newline();
+        output.dim(
+          `Files: ${filesSummary.totalCount} files (${filesSummary.summary})`
+        );
+        output.dim(`Run \`rush-ai task files ${id}\` to view details.`);
+      }
+    }
+  });
+  task.command("files").description("List and download task artifact files").argument("<id>", "Task ID").option("--download <path>", "Download a specific file by its path").option("--download-all", "Download all files").option("-o, --output <dir>", "Output directory for downloads").option(
+    "-c, --category <type>",
+    "Filter by category: code, image, document, other"
+  ).action(
+    async (id, options) => {
+      requireAuth();
+      const format = resolveFormat(program.opts());
+      const client = createClient();
+      const { data } = await client.get(
+        `/api/chat/${encodeURIComponent(id)}/files`
+      );
+      let files = data.files;
+      if (options.category && VALID_CATEGORIES.includes(options.category)) {
+        files = files.filter((f) => f.category === options.category);
+      } else if (options.category) {
+        output.warn(
+          `Unknown category "${options.category}". Showing all files.`
+        );
+      }
+      if (options.download) {
+        const file = files.find(
+          (f) => f.filePath === options.download || f.fileName === options.download
+        );
+        if (!file) {
+          output.error(`File not found: ${options.download}`);
+          process.exit(1);
+        }
+        if (!file.ossUrl) {
+          output.error(`File "${file.fileName}" has no download URL.`);
+          process.exit(1);
+        }
+        const outputDir = options.output || ".";
+        const destPath = sanitizeFilePath(file.filePath, outputDir);
+        if (!destPath) {
+          output.error(`Unsafe file path: ${file.filePath}`);
+          process.exit(1);
+        }
+        await downloadFile(file.ossUrl, destPath);
+        if (format === "json") {
+          output.log(
+            JSON.stringify(
+              { downloaded: file.filePath, dest: destPath },
+              null,
+              2
+            )
+          );
+        } else {
+          output.success(`Downloaded: ${file.filePath} -> ${destPath}`);
+        }
+        return;
+      }
+      if (options.downloadAll) {
+        const outputDir = options.output || `task-files-${id.slice(0, 8)}`;
+        let downloaded = 0;
+        let skipped = 0;
+        let failed = 0;
+        for (const file of files) {
+          if (!file.ossUrl) {
+            skipped++;
+            if (format !== "json") {
+              output.dim(`  Skipped (no URL): ${file.filePath}`);
+            }
+            continue;
+          }
+          const destPath = sanitizeFilePath(file.filePath, outputDir);
+          if (!destPath) {
+            skipped++;
+            if (format !== "json") {
+              output.warn(`  Skipped (unsafe path): ${file.filePath}`);
+            }
+            continue;
+          }
+          try {
+            await downloadFile(file.ossUrl, destPath);
+            downloaded++;
+            if (format !== "json") {
+              output.dim(`  Downloaded: ${file.filePath}`);
+            }
+          } catch {
+            failed++;
+            if (format !== "json") {
+              output.warn(`  Failed: ${file.filePath}`);
+            }
+          }
+        }
+        if (format === "json") {
+          output.log(
+            JSON.stringify(
+              { outputDir, downloaded, skipped, failed, total: files.length },
+              null,
+              2
+            )
+          );
+        } else {
+          output.newline();
+          output.success(
+            `Downloaded ${downloaded}/${files.length} files to ${outputDir}`
+          );
+          if (skipped > 0) {
+            output.dim(
+              `  ${skipped} skipped (no download URL or unsafe path)`
+            );
+          }
+          if (failed > 0) {
+            output.warn(`  ${failed} failed`);
+          }
+        }
+        return;
+      }
+      if (format === "json") {
+        output.log(
+          JSON.stringify({ files, totalCount: files.length }, null, 2)
+        );
+        return;
+      }
+      if (files.length === 0) {
+        output.info("No files found.");
+        return;
+      }
+      output.log(output.bold(`Files (${files.length} total):`));
+      output.newline();
+      const rows = files.map((f) => ({
+        Name: f.fileName,
+        Category: f.category,
+        Source: f.source,
+        Path: f.filePath
+      }));
+      output.log(formatOutput(rows, format));
+    }
+  );
+  task.command("list").alias("ls").description("List tasks").option("-l, --limit <limit>", "Maximum number of tasks", "20").option("-s, --status <status>", "Filter by status").action(async (options) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", options.limit);
+    if (options.status) params.set("status", options.status);
+    const { data } = await client.get(
+      `/api/tasks?${params.toString()}`
+    );
+    if (format === "json") {
+      output.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    if (data.tasks.length === 0) {
+      output.info("No tasks found.");
+      return;
+    }
+    output.log(output.bold(`Tasks (${data.total} total):`));
+    output.newline();
+    const rows = data.tasks.map((t) => ({
+      ID: t.id.slice(0, 8),
+      Agent: t.agent,
+      Status: t.status,
+      Created: new Date(t.createdAt).toLocaleString()
+    }));
+    output.log(formatOutput(rows, format));
+  });
+  task.command("watch").description("Watch task execution in real-time").argument("<id>", "Task ID").action(async (id) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    if (format !== "json") {
+      output.log(output.bold(`Watching task ${id}...`));
+      output.newline();
+    }
+    const TERMINAL_STATUSES = ["completed", "failed", "cancelled"];
+    const connectFn = async () => {
+      const response = await client.fetchRaw(
+        `/api/tasks/${encodeURIComponent(id)}/events`,
+        { method: "GET" }
+      );
+      if (!response.body) {
+        throw new Error("No response body for SSE");
+      }
+      return response.body;
+    };
+    let finalStatus = "";
+    await consumeSSEStreamWithReconnect(
+      connectFn,
+      (event) => {
+        if (format === "json") {
+          output.log(JSON.stringify(event));
+        } else {
+          renderTaskEvent(event);
+        }
+        if (event.type === "status") {
+          finalStatus = event.data;
+        }
+      },
+      {
+        isTerminal: (event) => event.type === "status" && TERMINAL_STATUSES.includes(event.data),
+        onReconnect: (attempt) => {
+          if (format !== "json") {
+            output.dim(
+              `\u27F3 SSE connection lost. Reconnecting (${attempt}/5)...`
+            );
+          }
+        }
+      }
+    );
+    if (format !== "json") {
+      output.newline();
+      if (finalStatus === "completed") {
+        output.success("Task completed.");
+      } else if (finalStatus === "failed") {
+        output.error("Task failed.");
+      } else if (finalStatus === "cancelled") {
+        output.info("Task cancelled.");
+      }
+    }
+  });
+  task.command("cancel").description("Cancel a running task").argument("<id>", "Task ID").action(async (id) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    await client.delete(`/api/tasks/${encodeURIComponent(id)}`);
+    if (format === "json") {
+      output.log(JSON.stringify({ id, status: "cancelled" }));
+    } else {
+      output.success(`Task ${id} cancelled.`);
+    }
+  });
+}
+function commaSplit(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function renderTaskEvent(event) {
+  switch (event.type) {
+    case "status":
+      output.info(`Status: ${event.data}`);
+      break;
+    case "content":
+      process.stdout.write(event.data);
+      break;
+    case "error":
+      output.error(event.data || "Unknown error");
+      break;
+    case "progress":
+      output.dim(`Progress: ${event.data}`);
+      break;
+    case "raw":
+      process.stdout.write(event.data);
+      break;
+    default:
+      output.dim(JSON.stringify(event));
+  }
+}
+
+// src/commands/index.ts
+function registerCommands(program) {
+  registerAuthCommand(program);
+  registerAgentCommand(program);
+  registerTaskCommand(program);
+  registerMcpCommand(program);
+  registerPluginCommand(program);
+  registerCompletionCommand(program);
+  registerConfigCommand(program);
+  registerDoctorCommand(program);
+}
+
+// src/util/update-check.ts
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname3, join as join3 } from "path";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+var REGISTRY_URL = "https://registry.npmjs.org/rush-ai/latest";
+function parseVersion(v) {
+  const segments = v.replace(/^v/, "").split("-")[0].split(".").map(Number);
+  if (segments.some((n) => Number.isNaN(n))) return null;
+  return segments;
+}
+function isNewerVersion(current, latest) {
+  const c = parseVersion(current);
+  const l = parseVersion(latest);
+  if (!c || !l) return false;
+  for (let i = 0; i < Math.max(c.length, l.length); i++) {
+    const cv = c[i] ?? 0;
+    const lv = l[i] ?? 0;
+    if (lv > cv) return true;
+    if (lv < cv) return false;
+  }
+  return false;
+}
+async function writeLastCheck(checkFile) {
+  try {
+    await mkdir3(dirname3(checkFile), { recursive: true });
+    await writeFile2(checkFile, JSON.stringify({ lastCheck: Date.now() }));
+  } catch {
+  }
+}
+async function checkForUpdate(currentVersion) {
+  const rushDir = join3(homedir9(), ".rush");
+  const checkFile = join3(rushDir, "update-check.json");
+  try {
+    if (process.env.CI) return;
+    let lastCheck = 0;
+    try {
+      const data = JSON.parse(await readFile2(checkFile, "utf-8"));
+      lastCheck = data.lastCheck ?? 0;
+    } catch {
+    }
+    if (Date.now() - lastCheck < CHECK_INTERVAL_MS) return;
+    await writeLastCheck(checkFile);
+    const response = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) return;
+    const { version: latest } = await response.json();
+    if (isNewerVersion(currentVersion, latest)) {
+      output.newline();
+      output.warn(
+        `Update available: ${currentVersion} \u2192 ${latest}
+  Run \`npm update -g rush-ai\` to update.`
+      );
+    }
+  } catch {
+  }
+}
+
+// src/index.ts
+var BANNER = `
+  ${chalk6.bold.cyan("Rush CLI")} ${chalk6.dim(`v${VERSION}`)}
+  ${chalk6.dim("The command-line interface for the Rush AI platform")}
+`;
+function showWelcomeGuide() {
+  const lines = [
+    "",
+    `  ${chalk6.bold.cyan("Rush CLI")} ${chalk6.dim(`v${VERSION}`)}`,
+    "",
+    chalk6.dim("  Quick start:"),
+    `    ${chalk6.cyan("rush-ai auth login")}          Log in to Rush platform`,
+    `    ${chalk6.cyan("rush-ai agent list")}          Browse available agents`,
+    `    ${chalk6.cyan("rush-ai task run -a <agent>")} Run a task`,
+    ""
+  ];
+  try {
+    const method = getAuthMethod();
+    if (method) {
+      lines.push(chalk6.dim("  Status:"), `    Logged in via ${method}`, "");
+    }
+  } catch {
+  }
+  lines.push(chalk6.dim("  Run rush-ai --help for all commands."), "");
+  console.error(lines.join("\n"));
+}
+function createProgram() {
+  const program = new Command();
+  program.name("rush-ai").version(VERSION, "-v, --version").description("Rush CLI - Command-line interface for the Rush AI platform").configureHelp({
+    sortSubcommands: true
+  }).addHelpText("before", BANNER).option("--no-color", "Disable color output").option("--json", "Output as JSON where supported").option("-f, --format <type>", "Output format (table, json, csv)").option(
+    "--ci",
+    "CI mode: JSON output, no interactive prompts, strict exit codes"
+  ).option("--verbose", "Show detailed output including HTTP requests").option("--debug", "Show debug-level output (implies --verbose)");
+  program.hook("preAction", (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (isCIMode(opts)) {
+      if (!opts.json) {
+        thisCommand.setOptionValue("json", true);
+      }
+    }
+    setVerbosity(!!opts.verbose, !!opts.debug);
+  });
+  program.action(() => {
+    if (process.stdout.isTTY) {
+      showWelcomeGuide();
+    } else {
+      program.help();
+    }
+  });
+  registerCommands(program);
+  return program;
+}
+async function main() {
+  if (!process.stdout.isTTY || process.argv.includes("--no-color") || isCIMode()) {
+    process.env.NO_COLOR = "1";
+  }
+  const program = createProgram();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    const ci = isCIMode(program.opts());
+    if (isRushError(error)) {
+      if (ci) {
+        output.log(
+          JSON.stringify({
+            error: true,
+            code: error.code,
+            message: error.message,
+            exitCode: error.exitCode
+          })
+        );
+      } else {
+        output.error(error.message);
+        if (error.code === "AUTH_ERROR") {
+          output.newline();
+          output.dim("Run `rush-ai auth login` to authenticate.");
+        }
+      }
+      process.exit(error.exitCode);
+    }
+    if (error instanceof Error) {
+      const exitCode = 2;
+      if (ci) {
+        output.log(
+          JSON.stringify({
+            error: true,
+            code: "UNKNOWN_ERROR",
+            message: error.message,
+            exitCode
+          })
+        );
+      } else {
+        output.error(error.message);
+        if (process.env.DEBUG) {
+          console.error(error.stack);
+        }
+      }
+      process.exit(exitCode);
+    }
+    if (ci) {
+      output.log(
+        JSON.stringify({
+          error: true,
+          code: "UNKNOWN_ERROR",
+          message: "An unexpected error occurred.",
+          exitCode: 2
+        })
+      );
+    } else {
+      output.error("An unexpected error occurred.");
+    }
+    process.exit(2);
+  }
+  void checkForUpdate(VERSION);
+}
+if (!process.env.VITEST) {
+  main();
+}
+export {
+  createProgram
+};
+//# sourceMappingURL=index.js.map