@xelauvas/xela-cli 0.1.0

package/src/commands/logout/logout.tsx

@@ -0,0 +1,82 @@
+import * as React from 'react';
+import { clearTrustedDeviceTokenCache } from '../../bridge/trustedDevice.js';
+import { Text } from '../../ink.js';
+import { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js';
+import { getGroveNoticeConfig, getGroveSettings } from '../../services/api/grove.js';
+import { clearPolicyLimitsCache } from '../../services/policyLimits/index.js';
+// flushTelemetry is loaded lazily to avoid pulling in ~1.1MB of OpenTelemetry at startup
+import { clearRemoteManagedSettingsCache } from '../../services/remoteManagedSettings/index.js';
+import { getClaudeAIOAuthTokens, removeApiKey } from '../../utils/auth.js';
+import { clearBetasCaches } from '../../utils/betas.js';
+import { saveGlobalConfig } from '../../utils/config.js';
+import { gracefulShutdownSync } from '../../utils/gracefulShutdown.js';
+import { getSecureStorage } from '../../utils/secureStorage/index.js';
+import { clearToolSchemaCache } from '../../utils/toolSchemaCache.js';
+import { resetUserCache } from '../../utils/user.js';
+export async function performLogout({
+  clearOnboarding = false
+}): Promise<void> {
+  // Flush telemetry BEFORE clearing credentials to prevent org data leakage
+  const {
+    flushTelemetry
+  } = await import('../../utils/telemetry/instrumentation.js');
+  await flushTelemetry();
+  await removeApiKey();
+
+  // Wipe all secure storage data on logout
+  const secureStorage = getSecureStorage();
+  secureStorage.delete();
+  await clearAuthRelatedCaches();
+  saveGlobalConfig(current => {
+    const updated = {
+      ...current
+    };
+    if (clearOnboarding) {
+      updated.hasCompletedOnboarding = false;
+      updated.subscriptionNoticeCount = 0;
+      updated.hasAvailableSubscription = false;
+      if (updated.customApiKeyResponses?.approved) {
+        updated.customApiKeyResponses = {
+          ...updated.customApiKeyResponses,
+          approved: []
+        };
+      }
+    }
+    updated.oauthAccount = undefined;
+    return updated;
+  });
+}
+
+// clearing anything memoized that must be invalidated when user/session/auth changes
+export async function clearAuthRelatedCaches(): Promise<void> {
+  // Clear the OAuth token cache
+  getClaudeAIOAuthTokens.cache?.clear?.();
+  clearTrustedDeviceTokenCache();
+  clearBetasCaches();
+  clearToolSchemaCache();
+
+  // Clear user data cache BEFORE GrowthBook refresh so it picks up fresh credentials
+  resetUserCache();
+  refreshGrowthBookAfterAuthChange();
+
+  // Clear Grove config cache
+  getGroveNoticeConfig.cache?.clear?.();
+  getGroveSettings.cache?.clear?.();
+
+  // Clear remotely managed settings cache
+  await clearRemoteManagedSettingsCache();
+
+  // Clear policy limits cache
+  await clearPolicyLimitsCache();
+}
+export async function call(): Promise<React.ReactNode> {
+  await performLogout({
+    clearOnboarding: true
+  });
+  const message = <Text>Successfully logged out from your Anthropic account.</Text>;
+  setTimeout(() => {
+    gracefulShutdownSync(0, 'logout');
+  }, 200);
+  return message;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/commands/mcp/addCommand.ts

@@ -0,0 +1,280 @@
+/**
+ * MCP add CLI subcommand
+ *
+ * Extracted from main.tsx to enable direct testing.
+ */
+import { type Command, Option } from '@commander-js/extra-typings'
+import { cliError, cliOk } from '../../cli/exit.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import {
+  readClientSecret,
+  saveMcpClientSecret,
+} from '../../services/mcp/auth.js'
+import { addMcpConfig } from '../../services/mcp/config.js'
+import {
+  describeMcpConfigFilePath,
+  ensureConfigScope,
+  ensureTransport,
+  parseHeaders,
+} from '../../services/mcp/utils.js'
+import {
+  getXaaIdpSettings,
+  isXaaEnabled,
+} from '../../services/mcp/xaaIdpLogin.js'
+import { parseEnvVars } from '../../utils/envUtils.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+
+/**
+ * Registers the `mcp add` subcommand on the given Commander command.
+ */
+export function registerMcpAddCommand(mcp: Command): void {
+  mcp
+    .command('add <name> <commandOrUrl> [args...]')
+    .description(
+      'Add an MCP server to Claude Code.\n\n' +
+        'Examples:\n' +
+        '  # Add HTTP server:\n' +
+        '  claude mcp add --transport http sentry https://mcp.sentry.dev/mcp\n\n' +
+        '  # Add HTTP server with headers:\n' +
+        '  claude mcp add --transport http corridor https://app.corridor.dev/api/mcp --header "Authorization: Bearer ..."\n\n' +
+        '  # Add stdio server with environment variables:\n' +
+        '  claude mcp add -e API_KEY=xxx my-server -- npx my-mcp-server\n\n' +
+        '  # Add stdio server with subprocess flags:\n' +
+        '  claude mcp add my-server -- my-command --some-flag arg1',
+    )
+    .option(
+      '-s, --scope <scope>',
+      'Configuration scope (local, user, or project)',
+      'local',
+    )
+    .option(
+      '-t, --transport <transport>',
+      'Transport type (stdio, sse, http). Defaults to stdio if not specified.',
+    )
+    .option(
+      '-e, --env <env...>',
+      'Set environment variables (e.g. -e KEY=value)',
+    )
+    .option(
+      '-H, --header <header...>',
+      'Set WebSocket headers (e.g. -H "X-Api-Key: abc123" -H "X-Custom: value")',
+    )
+    .option('--client-id <clientId>', 'OAuth client ID for HTTP/SSE servers')
+    .option(
+      '--client-secret',
+      'Prompt for OAuth client secret (or set MCP_CLIENT_SECRET env var)',
+    )
+    .option(
+      '--callback-port <port>',
+      'Fixed port for OAuth callback (for servers requiring pre-registered redirect URIs)',
+    )
+    .helpOption('-h, --help', 'Display help for command')
+    .addOption(
+      new Option(
+        '--xaa',
+        "Enable XAA (SEP-990) for this server. Requires 'claude mcp xaa setup' first. Also requires --client-id and --client-secret (for the MCP server's AS).",
+      ).hideHelp(!isXaaEnabled()),
+    )
+    .action(async (name, commandOrUrl, args, options) => {
+      // Commander.js handles -- natively: it consumes -- and everything after becomes args
+      const actualCommand = commandOrUrl
+      const actualArgs = args
+
+      // If no name is provided, error
+      if (!name) {
+        cliError(
+          'Error: Server name is required.\n' +
+            'Usage: claude mcp add <name> <command> [args...]',
+        )
+      } else if (!actualCommand) {
+        cliError(
+          'Error: Command is required when server name is provided.\n' +
+            'Usage: claude mcp add <name> <command> [args...]',
+        )
+      }
+
+      try {
+        const scope = ensureConfigScope(options.scope)
+        const transport = ensureTransport(options.transport)
+
+        // XAA fail-fast: validate at add-time, not auth-time.
+        if (options.xaa && !isXaaEnabled()) {
+          cliError(
+            'Error: --xaa requires CLAUDE_CODE_ENABLE_XAA=1 in your environment',
+          )
+        }
+        const xaa = Boolean(options.xaa)
+        if (xaa) {
+          const missing: string[] = []
+          if (!options.clientId) missing.push('--client-id')
+          if (!options.clientSecret) missing.push('--client-secret')
+          if (!getXaaIdpSettings()) {
+            missing.push(
+              "'claude mcp xaa setup' (settings.xaaIdp not configured)",
+            )
+          }
+          if (missing.length) {
+            cliError(`Error: --xaa requires: ${missing.join(', ')}`)
+          }
+        }
+
+        // Check if transport was explicitly provided
+        const transportExplicit = options.transport !== undefined
+
+        // Check if the command looks like a URL (likely incorrect usage)
+        const looksLikeUrl =
+          actualCommand.startsWith('http://') ||
+          actualCommand.startsWith('https://') ||
+          actualCommand.startsWith('localhost') ||
+          actualCommand.endsWith('/sse') ||
+          actualCommand.endsWith('/mcp')
+
+        logEvent('tengu_mcp_add', {
+          type: transport as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          scope:
+            scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          source:
+            'command' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          transport:
+            transport as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          transportExplicit: transportExplicit,
+          looksLikeUrl: looksLikeUrl,
+        })
+
+        if (transport === 'sse') {
+          if (!actualCommand) {
+            cliError('Error: URL is required for SSE transport.')
+          }
+
+          const headers = options.header
+            ? parseHeaders(options.header)
+            : undefined
+
+          const callbackPort = options.callbackPort
+            ? parseInt(options.callbackPort, 10)
+            : undefined
+          const oauth =
+            options.clientId || callbackPort || xaa
+              ? {
+                  ...(options.clientId ? { clientId: options.clientId } : {}),
+                  ...(callbackPort ? { callbackPort } : {}),
+                  ...(xaa ? { xaa: true } : {}),
+                }
+              : undefined
+
+          const clientSecret =
+            options.clientSecret && options.clientId
+              ? await readClientSecret()
+              : undefined
+
+          const serverConfig = {
+            type: 'sse' as const,
+            url: actualCommand,
+            headers,
+            oauth,
+          }
+          await addMcpConfig(name, serverConfig, scope)
+
+          if (clientSecret) {
+            saveMcpClientSecret(name, serverConfig, clientSecret)
+          }
+
+          process.stdout.write(
+            `Added SSE MCP server ${name} with URL: ${actualCommand} to ${scope} config\n`,
+          )
+          if (headers) {
+            process.stdout.write(
+              `Headers: ${jsonStringify(headers, null, 2)}\n`,
+            )
+          }
+        } else if (transport === 'http') {
+          if (!actualCommand) {
+            cliError('Error: URL is required for HTTP transport.')
+          }
+
+          const headers = options.header
+            ? parseHeaders(options.header)
+            : undefined
+
+          const callbackPort = options.callbackPort
+            ? parseInt(options.callbackPort, 10)
+            : undefined
+          const oauth =
+            options.clientId || callbackPort || xaa
+              ? {
+                  ...(options.clientId ? { clientId: options.clientId } : {}),
+                  ...(callbackPort ? { callbackPort } : {}),
+                  ...(xaa ? { xaa: true } : {}),
+                }
+              : undefined
+
+          const clientSecret =
+            options.clientSecret && options.clientId
+              ? await readClientSecret()
+              : undefined
+
+          const serverConfig = {
+            type: 'http' as const,
+            url: actualCommand,
+            headers,
+            oauth,
+          }
+          await addMcpConfig(name, serverConfig, scope)
+
+          if (clientSecret) {
+            saveMcpClientSecret(name, serverConfig, clientSecret)
+          }
+
+          process.stdout.write(
+            `Added HTTP MCP server ${name} with URL: ${actualCommand} to ${scope} config\n`,
+          )
+          if (headers) {
+            process.stdout.write(
+              `Headers: ${jsonStringify(headers, null, 2)}\n`,
+            )
+          }
+        } else {
+          if (
+            options.clientId ||
+            options.clientSecret ||
+            options.callbackPort ||
+            options.xaa
+          ) {
+            process.stderr.write(
+              `Warning: --client-id, --client-secret, --callback-port, and --xaa are only supported for HTTP/SSE transports and will be ignored for stdio.\n`,
+            )
+          }
+
+          // Warn if this looks like a URL but transport wasn't explicitly specified
+          if (!transportExplicit && looksLikeUrl) {
+            process.stderr.write(
+              `\nWarning: The command "${actualCommand}" looks like a URL, but is being interpreted as a stdio server as --transport was not specified.\n`,
+            )
+            process.stderr.write(
+              `If this is an HTTP server, use: claude mcp add --transport http ${name} ${actualCommand}\n`,
+            )
+            process.stderr.write(
+              `If this is an SSE server, use: claude mcp add --transport sse ${name} ${actualCommand}\n`,
+            )
+          }
+
+          const env = parseEnvVars(options.env)
+          await addMcpConfig(
+            name,
+            { type: 'stdio', command: actualCommand, args: actualArgs, env },
+            scope,
+          )
+
+          process.stdout.write(
+            `Added stdio MCP server ${name} with command: ${actualCommand} ${actualArgs.join(' ')} to ${scope} config\n`,
+          )
+        }
+        cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)
+      } catch (error) {
+        cliError((error as Error).message)
+      }
+    })
+}

package/src/commands/mcp/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const mcp = {
+  type: 'local-jsx',
+  name: 'mcp',
+  description: 'Manage MCP servers',
+  immediate: true,
+  argumentHint: '[enable|disable [server-name]]',
+  load: () => import('./mcp.js'),
+} satisfies Command
+
+export default mcp

package/src/commands/mcp/mcp.tsx

@@ -0,0 +1,85 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useEffect, useRef } from 'react';
+import { MCPSettings } from '../../components/mcp/index.js';
+import { MCPReconnect } from '../../components/mcp/MCPReconnect.js';
+import { useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js';
+import { useAppState } from '../../state/AppState.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { PluginSettings } from '../plugin/PluginSettings.js';
+
+// TODO: This is a hack to get the context value from toggleMcpServer (useContext only works in a component)
+// Ideally, all MCP state and functions would be in global state.
+function MCPToggle(t0) {
+  const $ = _c(7);
+  const {
+    action,
+    target,
+    onComplete
+  } = t0;
+  const mcpClients = useAppState(_temp);
+  const toggleMcpServer = useMcpToggleEnabled();
+  const didRun = useRef(false);
+  let t1;
+  let t2;
+  if ($[0] !== action || $[1] !== mcpClients || $[2] !== onComplete || $[3] !== target || $[4] !== toggleMcpServer) {
+    t1 = () => {
+      if (didRun.current) {
+        return;
+      }
+      didRun.current = true;
+      const isEnabling = action === "enable";
+      const clients = mcpClients.filter(_temp2);
+      const toToggle = target === "all" ? clients.filter(c_0 => isEnabling ? c_0.type === "disabled" : c_0.type !== "disabled") : clients.filter(c_1 => c_1.name === target);
+      if (toToggle.length === 0) {
+        onComplete(target === "all" ? `All MCP servers are already ${isEnabling ? "enabled" : "disabled"}` : `MCP server "${target}" not found`);
+        return;
+      }
+      for (const s_0 of toToggle) {
+        toggleMcpServer(s_0.name);
+      }
+      onComplete(target === "all" ? `${isEnabling ? "Enabled" : "Disabled"} ${toToggle.length} MCP server(s)` : `MCP server "${target}" ${isEnabling ? "enabled" : "disabled"}`);
+    };
+    t2 = [action, target, mcpClients, toggleMcpServer, onComplete];
+    $[0] = action;
+    $[1] = mcpClients;
+    $[2] = onComplete;
+    $[3] = target;
+    $[4] = toggleMcpServer;
+    $[5] = t1;
+    $[6] = t2;
+  } else {
+    t1 = $[5];
+    t2 = $[6];
+  }
+  useEffect(t1, t2);
+  return null;
+}
+function _temp2(c) {
+  return c.name !== "ide";
+}
+function _temp(s) {
+  return s.mcp.clients;
+}
+export async function call(onDone: LocalJSXCommandOnDone, _context: unknown, args?: string): Promise<React.ReactNode> {
+  if (args) {
+    const parts = args.trim().split(/\s+/);
+
+    // Allow /mcp no-redirect to bypass the redirect for testing
+    if (parts[0] === 'no-redirect') {
+      return <MCPSettings onComplete={onDone} />;
+    }
+    if (parts[0] === 'reconnect' && parts[1]) {
+      return <MCPReconnect serverName={parts.slice(1).join(' ')} onComplete={onDone} />;
+    }
+    if (parts[0] === 'enable' || parts[0] === 'disable') {
+      return <MCPToggle action={parts[0]} target={parts.length > 1 ? parts.slice(1).join(' ') : 'all'} onComplete={onDone} />;
+    }
+  }
+
+  // Redirect base /mcp command to /plugins installed tab for ant users
+  if ("external" === 'ant') {
+    return <PluginSettings onComplete={onDone} args="manage" showMcpRedirectMessage />;
+  }
+  return <MCPSettings onComplete={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","MCPSettings","MCPReconnect","useMcpToggleEnabled","useAppState","LocalJSXCommandOnDone","PluginSettings","MCPToggle","t0","$","_c","action","target","onComplete","mcpClients","_temp","toggleMcpServer","didRun","t1","t2","current","isEnabling","clients","filter","_temp2","toToggle","c_0","c","type","c_1","name","length","s_0","s","mcp","call","onDone","_context","args","Promise","ReactNode","parts","trim","split","slice","join"],"sources":["mcp.tsx"],"sourcesContent":["import React, { useEffect, useRef } from 'react'\nimport { MCPSettings } from '../../components/mcp/index.js'\nimport { MCPReconnect } from '../../components/mcp/MCPReconnect.js'\nimport { useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js'\nimport { useAppState } from '../../state/AppState.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { PluginSettings } from '../plugin/PluginSettings.js'\n\n// TODO: This is a hack to get the context value from toggleMcpServer (useContext only works in a component)\n// Ideally, all MCP state and functions would be in global state.\nfunction MCPToggle({\n  action,\n  target,\n  onComplete,\n}: {\n  action: 'enable' | 'disable'\n  target: string\n  onComplete: (result: string) => void\n}): null {\n  const mcpClients = useAppState(s => s.mcp.clients)\n  const toggleMcpServer = useMcpToggleEnabled()\n  const didRun = useRef(false)\n\n  useEffect(() => {\n    if (didRun.current) return\n    didRun.current = true\n\n    const isEnabling = action === 'enable'\n    const clients = mcpClients.filter(c => c.name !== 'ide')\n    const toToggle =\n      target === 'all'\n        ? clients.filter(c =>\n            isEnabling ? c.type === 'disabled' : c.type !== 'disabled',\n          )\n        : clients.filter(c => c.name === target)\n\n    if (toToggle.length === 0) {\n      onComplete(\n        target === 'all'\n          ? `All MCP servers are already ${isEnabling ? 'enabled' : 'disabled'}`\n          : `MCP server \"${target}\" not found`,\n      )\n      return\n    }\n\n    for (const s of toToggle) {\n      void toggleMcpServer(s.name)\n    }\n\n    onComplete(\n      target === 'all'\n        ? `${isEnabling ? 'Enabled' : 'Disabled'} ${toToggle.length} MCP server(s)`\n        : `MCP server \"${target}\" ${isEnabling ? 'enabled' : 'disabled'}`,\n    )\n  }, [action, target, mcpClients, toggleMcpServer, onComplete])\n\n  return null\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  _context: unknown,\n  args?: string,\n): Promise<React.ReactNode> {\n  if (args) {\n    const parts = args.trim().split(/\\s+/)\n\n    // Allow /mcp no-redirect to bypass the redirect for testing\n    if (parts[0] === 'no-redirect') {\n      return <MCPSettings onComplete={onDone} />\n    }\n\n    if (parts[0] === 'reconnect' && parts[1]) {\n      return (\n        <MCPReconnect\n          serverName={parts.slice(1).join(' ')}\n          onComplete={onDone}\n        />\n      )\n    }\n\n    if (parts[0] === 'enable' || parts[0] === 'disable') {\n      return (\n        <MCPToggle\n          action={parts[0]}\n          target={parts.length > 1 ? parts.slice(1).join(' ') : 'all'}\n          onComplete={onDone}\n        />\n      )\n    }\n  }\n\n  // Redirect base /mcp command to /plugins installed tab for ant users\n  if (\"external\" === 'ant') {\n    return (\n      <PluginSettings\n        onComplete={onDone}\n        args=\"manage\"\n        showMcpRedirectMessage\n      />\n    )\n  }\n\n  return <MCPSettings onComplete={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}