Add files using upload-large-folder tool

src/commands/add-dir/add-dir.tsx

@@ -0,0 +1,126 @@
+import { c as _c } from "react/compiler-runtime";
+import chalk from 'chalk';
+import figures from 'figures';
+import React, { useEffect } from 'react';
+import { getAdditionalDirectoriesForClaudeMd, setAdditionalDirectoriesForClaudeMd } from '../../bootstrap/state.js';
+import type { LocalJSXCommandContext } from '../../commands.js';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { AddWorkspaceDirectory } from '../../components/permissions/rules/AddWorkspaceDirectory.js';
+import { Box, Text } from '../../ink.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { applyPermissionUpdate, persistPermissionUpdate } from '../../utils/permissions/PermissionUpdate.js';
+import type { PermissionUpdateDestination } from '../../utils/permissions/PermissionUpdateSchema.js';
+import { SandboxManager } from '../../utils/sandbox/sandbox-adapter.js';
+import { addDirHelpMessage, validateDirectoryForWorkspace } from './validation.js';
+function AddDirError(t0) {
+  const $ = _c(10);
+  const {
+    message,
+    args,
+    onDone
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== onDone) {
+    t1 = () => {
+      const timer = setTimeout(onDone, 0);
+      return () => clearTimeout(timer);
+    };
+    t2 = [onDone];
+    $[0] = onDone;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[3] !== args) {
+    t3 = <Text dimColor={true}>{figures.pointer} /add-dir {args}</Text>;
+    $[3] = args;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== message) {
+    t4 = <MessageResponse><Text>{message}</Text></MessageResponse>;
+    $[5] = message;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] !== t3 || $[8] !== t4) {
+    t5 = <Box flexDirection="column">{t3}{t4}</Box>;
+    $[7] = t3;
+    $[8] = t4;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  return t5;
+}
+export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext, args?: string): Promise<React.ReactNode> {
+  const directoryPath = (args ?? '').trim();
+  const appState = context.getAppState();
+
+  // Helper to handle adding a directory (shared by both with-path and no-path cases)
+  const handleAddDirectory = async (path: string, remember = false) => {
+    const destination: PermissionUpdateDestination = remember ? 'localSettings' : 'session';
+    const permissionUpdate = {
+      type: 'addDirectories' as const,
+      directories: [path],
+      destination
+    };
+
+    // Apply to session context
+    const latestAppState = context.getAppState();
+    const updatedContext = applyPermissionUpdate(latestAppState.toolPermissionContext, permissionUpdate);
+    context.setAppState(prev => ({
+      ...prev,
+      toolPermissionContext: updatedContext
+    }));
+
+    // Update sandbox config so Bash commands can access the new directory.
+    // Bootstrap state is the source of truth for session-only dirs; persisted
+    // dirs are picked up via the settings subscription, but we refresh
+    // eagerly here to avoid a race when the user acts immediately.
+    const currentDirs = getAdditionalDirectoriesForClaudeMd();
+    if (!currentDirs.includes(path)) {
+      setAdditionalDirectoriesForClaudeMd([...currentDirs, path]);
+    }
+    SandboxManager.refreshConfig();
+    let message: string;
+    if (remember) {
+      try {
+        persistPermissionUpdate(permissionUpdate);
+        message = `Added ${chalk.bold(path)} as a working directory and saved to local settings`;
+      } catch (error) {
+        message = `Added ${chalk.bold(path)} as a working directory. Failed to save to local settings: ${error instanceof Error ? error.message : 'Unknown error'}`;
+      }
+    } else {
+      message = `Added ${chalk.bold(path)} as a working directory for this session`;
+    }
+    const messageWithHint = `${message} ${chalk.dim('· /permissions to manage')}`;
+    onDone(messageWithHint);
+  };
+
+  // When no path is provided, show AddWorkspaceDirectory input form directly
+  // and return to REPL after confirmation
+  if (!directoryPath) {
+    return <AddWorkspaceDirectory permissionContext={appState.toolPermissionContext} onAddDirectory={handleAddDirectory} onCancel={() => {
+      onDone('Did not add a working directory.');
+    }} />;
+  }
+  const result = await validateDirectoryForWorkspace(directoryPath, appState.toolPermissionContext);
+  if (result.resultType !== 'success') {
+    const message = addDirHelpMessage(result);
+    return <AddDirError message={message} args={args ?? ''} onDone={() => onDone(message)} />;
+  }
+  return <AddWorkspaceDirectory directoryPath={result.absolutePath} permissionContext={appState.toolPermissionContext} onAddDirectory={handleAddDirectory} onCancel={() => {
+    onDone(`Did not add ${chalk.bold(result.absolutePath)} as a working directory.`);
+  }} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","figures","React","useEffect","getAdditionalDirectoriesForClaudeMd","setAdditionalDirectoriesForClaudeMd","LocalJSXCommandContext","MessageResponse","AddWorkspaceDirectory","Box","Text","LocalJSXCommandOnDone","applyPermissionUpdate","persistPermissionUpdate","PermissionUpdateDestination","SandboxManager","addDirHelpMessage","validateDirectoryForWorkspace","AddDirError","t0","$","_c","message","args","onDone","t1","t2","timer","setTimeout","clearTimeout","t3","pointer","t4","t5","call","context","Promise","ReactNode","directoryPath","trim","appState","getAppState","handleAddDirectory","path","remember","destination","permissionUpdate","type","const","directories","latestAppState","updatedContext","toolPermissionContext","setAppState","prev","currentDirs","includes","refreshConfig","bold","error","Error","messageWithHint","dim","result","resultType","absolutePath"],"sources":["add-dir.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport figures from 'figures'\nimport React, { useEffect } from 'react'\nimport {\n  getAdditionalDirectoriesForClaudeMd,\n  setAdditionalDirectoriesForClaudeMd,\n} from '../../bootstrap/state.js'\nimport type { LocalJSXCommandContext } from '../../commands.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { AddWorkspaceDirectory } from '../../components/permissions/rules/AddWorkspaceDirectory.js'\nimport { Box, Text } from '../../ink.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport {\n  applyPermissionUpdate,\n  persistPermissionUpdate,\n} from '../../utils/permissions/PermissionUpdate.js'\nimport type { PermissionUpdateDestination } from '../../utils/permissions/PermissionUpdateSchema.js'\nimport { SandboxManager } from '../../utils/sandbox/sandbox-adapter.js'\nimport {\n  addDirHelpMessage,\n  validateDirectoryForWorkspace,\n} from './validation.js'\n\nfunction AddDirError({\n  message,\n  args,\n  onDone,\n}: {\n  message: string\n  args: string\n  onDone: () => void\n}): React.ReactNode {\n  useEffect(() => {\n    // We need to defer calling onDone to avoid the \"return null\" bug where\n    // the component unmounts before React can render the error message.\n    // Using setTimeout ensures the error displays before the command exits.\n    const timer = setTimeout(onDone, 0)\n    return () => clearTimeout(timer)\n  }, [onDone])\n\n  return (\n    <Box flexDirection=\"column\">\n      <Text dimColor>\n        {figures.pointer} /add-dir {args}\n      </Text>\n      <MessageResponse>\n        <Text>{message}</Text>\n      </MessageResponse>\n    </Box>\n  )\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: LocalJSXCommandContext,\n  args?: string,\n): Promise<React.ReactNode> {\n  const directoryPath = (args ?? '').trim()\n  const appState = context.getAppState()\n\n  // Helper to handle adding a directory (shared by both with-path and no-path cases)\n  const handleAddDirectory = async (path: string, remember = false) => {\n    const destination: PermissionUpdateDestination = remember\n      ? 'localSettings'\n      : 'session'\n\n    const permissionUpdate = {\n      type: 'addDirectories' as const,\n      directories: [path],\n      destination,\n    }\n\n    // Apply to session context\n    const latestAppState = context.getAppState()\n    const updatedContext = applyPermissionUpdate(\n      latestAppState.toolPermissionContext,\n      permissionUpdate,\n    )\n    context.setAppState(prev => ({\n      ...prev,\n      toolPermissionContext: updatedContext,\n    }))\n\n    // Update sandbox config so Bash commands can access the new directory.\n    // Bootstrap state is the source of truth for session-only dirs; persisted\n    // dirs are picked up via the settings subscription, but we refresh\n    // eagerly here to avoid a race when the user acts immediately.\n    const currentDirs = getAdditionalDirectoriesForClaudeMd()\n    if (!currentDirs.includes(path)) {\n      setAdditionalDirectoriesForClaudeMd([...currentDirs, path])\n    }\n    SandboxManager.refreshConfig()\n\n    let message: string\n\n    if (remember) {\n      try {\n        persistPermissionUpdate(permissionUpdate)\n        message = `Added ${chalk.bold(path)} as a working directory and saved to local settings`\n      } catch (error) {\n        message = `Added ${chalk.bold(path)} as a working directory. Failed to save to local settings: ${error instanceof Error ? error.message : 'Unknown error'}`\n      }\n    } else {\n      message = `Added ${chalk.bold(path)} as a working directory for this session`\n    }\n\n    const messageWithHint = `${message} ${chalk.dim('· /permissions to manage')}`\n    onDone(messageWithHint)\n  }\n\n  // When no path is provided, show AddWorkspaceDirectory input form directly\n  // and return to REPL after confirmation\n  if (!directoryPath) {\n    return (\n      <AddWorkspaceDirectory\n        permissionContext={appState.toolPermissionContext}\n        onAddDirectory={handleAddDirectory}\n        onCancel={() => {\n          onDone('Did not add a working directory.')\n        }}\n      />\n    )\n  }\n\n  const result = await validateDirectoryForWorkspace(\n    directoryPath,\n    appState.toolPermissionContext,\n  )\n\n  if (result.resultType !== 'success') {\n    const message = addDirHelpMessage(result)\n\n    return (\n      <AddDirError\n        message={message}\n        args={args ?? ''}\n        onDone={() => onDone(message)}\n      />\n    )\n  }\n\n  return (\n    <AddWorkspaceDirectory\n      directoryPath={result.absolutePath}\n      permissionContext={appState.toolPermissionContext}\n      onAddDirectory={handleAddDirectory}\n      onCancel={() => {\n        onDone(\n          `Did not add ${chalk.bold(result.absolutePath)} as a working directory.`,\n        )\n      }}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/add-dir/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const addDir = {
+  type: 'local-jsx',
+  name: 'add-dir',
+  description: 'Add a new working directory',
+  argumentHint: '<path>',
+  load: () => import('./add-dir.js'),
+} satisfies Command
+
+export default addDir

src/commands/agents/agents.tsx

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { AgentsMenu } from '../../components/agents/AgentsMenu.js';
+import type { ToolUseContext } from '../../Tool.js';
+import { getTools } from '../../tools.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+export async function call(onDone: LocalJSXCommandOnDone, context: ToolUseContext): Promise<React.ReactNode> {
+  const appState = context.getAppState();
+  const permissionContext = appState.toolPermissionContext;
+  const tools = getTools(permissionContext);
+  return <AgentsMenu tools={tools} onExit={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkFnZW50c01lbnUiLCJUb29sVXNlQ29udGV4dCIsImdldFRvb2xzIiwiTG9jYWxKU1hDb21tYW5kT25Eb25lIiwiY2FsbCIsIm9uRG9uZSIsImNvbnRleHQiLCJQcm9taXNlIiwiUmVhY3ROb2RlIiwiYXBwU3RhdGUiLCJnZXRBcHBTdGF0ZSIsInBlcm1pc3Npb25Db250ZXh0IiwidG9vbFBlcm1pc3Npb25Db250ZXh0IiwidG9vbHMiXSwic291cmNlcyI6WyJhZ2VudHMudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgQWdlbnRzTWVudSB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvYWdlbnRzL0FnZW50c01lbnUuanMnXG5pbXBvcnQgdHlwZSB7IFRvb2xVc2VDb250ZXh0IH0gZnJvbSAnLi4vLi4vVG9vbC5qcydcbmltcG9ydCB7IGdldFRvb2xzIH0gZnJvbSAnLi4vLi4vdG9vbHMuanMnXG5pbXBvcnQgdHlwZSB7IExvY2FsSlNYQ29tbWFuZE9uRG9uZSB9IGZyb20gJy4uLy4uL3R5cGVzL2NvbW1hbmQuanMnXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBjYWxsKFxuICBvbkRvbmU6IExvY2FsSlNYQ29tbWFuZE9uRG9uZSxcbiAgY29udGV4dDogVG9vbFVzZUNvbnRleHQsXG4pOiBQcm9taXNlPFJlYWN0LlJlYWN0Tm9kZT4ge1xuICBjb25zdCBhcHBTdGF0ZSA9IGNvbnRleHQuZ2V0QXBwU3RhdGUoKVxuICBjb25zdCBwZXJtaXNzaW9uQ29udGV4dCA9IGFwcFN0YXRlLnRvb2xQZXJtaXNzaW9uQ29udGV4dFxuICBjb25zdCB0b29scyA9IGdldFRvb2xzKHBlcm1pc3Npb25Db250ZXh0KVxuXG4gIHJldHVybiA8QWdlbnRzTWVudSB0b29scz17dG9vbHN9IG9uRXhpdD17b25Eb25lfSAvPlxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUtBLEtBQUssTUFBTSxPQUFPO0FBQzlCLFNBQVNDLFVBQVUsUUFBUSx1Q0FBdUM7QUFDbEUsY0FBY0MsY0FBYyxRQUFRLGVBQWU7QUFDbkQsU0FBU0MsUUFBUSxRQUFRLGdCQUFnQjtBQUN6QyxjQUFjQyxxQkFBcUIsUUFBUSx3QkFBd0I7QUFFbkUsT0FBTyxlQUFlQyxJQUFJQSxDQUN4QkMsTUFBTSxFQUFFRixxQkFBcUIsRUFDN0JHLE9BQU8sRUFBRUwsY0FBYyxDQUN4QixFQUFFTSxPQUFPLENBQUNSLEtBQUssQ0FBQ1MsU0FBUyxDQUFDLENBQUM7RUFDMUIsTUFBTUMsUUFBUSxHQUFHSCxPQUFPLENBQUNJLFdBQVcsQ0FBQyxDQUFDO0VBQ3RDLE1BQU1DLGlCQUFpQixHQUFHRixRQUFRLENBQUNHLHFCQUFxQjtFQUN4RCxNQUFNQyxLQUFLLEdBQUdYLFFBQVEsQ0FBQ1MsaUJBQWlCLENBQUM7RUFFekMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQ0UsS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUNSLE1BQU0sQ0FBQyxHQUFHO0FBQ3JEIiwiaWdub3JlTGlzdCI6W119

src/commands/agents/index.ts

@@ -0,0 +1,10 @@
+import type { Command } from '../../commands.js'
+
+const agents = {
+  type: 'local-jsx',
+  name: 'agents',
+  description: 'Manage agent configurations',
+  load: () => import('./agents.js'),
+} satisfies Command
+
+export default agents

src/commands/ant-trace/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/autofix-pr/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/branch/branch.ts

@@ -0,0 +1,296 @@
+import { randomUUID, type UUID } from 'crypto'
+import { mkdir, readFile, writeFile } from 'fs/promises'
+import { getOriginalCwd, getSessionId } from '../../bootstrap/state.js'
+import type { LocalJSXCommandContext } from '../../commands.js'
+import { logEvent } from '../../services/analytics/index.js'
+import type { LocalJSXCommandOnDone } from '../../types/command.js'
+import type {
+  ContentReplacementEntry,
+  Entry,
+  LogOption,
+  SerializedMessage,
+  TranscriptMessage,
+} from '../../types/logs.js'
+import { parseJSONL } from '../../utils/json.js'
+import {
+  getProjectDir,
+  getTranscriptPath,
+  getTranscriptPathForSession,
+  isTranscriptMessage,
+  saveCustomTitle,
+  searchSessionsByCustomTitle,
+} from '../../utils/sessionStorage.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import { escapeRegExp } from '../../utils/stringUtils.js'
+
+type TranscriptEntry = TranscriptMessage & {
+  forkedFrom?: {
+    sessionId: string
+    messageUuid: UUID
+  }
+}
+
+/**
+ * Derive a single-line title base from the first user message.
+ * Collapses whitespace — multiline first messages (pasted stacks, code)
+ * otherwise flow into the saved title and break the resume hint.
+ */
+export function deriveFirstPrompt(
+  firstUserMessage: Extract<SerializedMessage, { type: 'user' }> | undefined,
+): string {
+  const content = firstUserMessage?.message?.content
+  if (!content) return 'Branched conversation'
+  const raw =
+    typeof content === 'string'
+      ? content
+      : content.find(
+          (block): block is { type: 'text'; text: string } =>
+            block.type === 'text',
+        )?.text
+  if (!raw) return 'Branched conversation'
+  return (
+    raw.replace(/\s+/g, ' ').trim().slice(0, 100) || 'Branched conversation'
+  )
+}
+
+/**
+ * Creates a fork of the current conversation by copying from the transcript file.
+ * Preserves all original metadata (timestamps, gitBranch, etc.) while updating
+ * sessionId and adding forkedFrom traceability.
+ */
+async function createFork(customTitle?: string): Promise<{
+  sessionId: UUID
+  title: string | undefined
+  forkPath: string
+  serializedMessages: SerializedMessage[]
+  contentReplacementRecords: ContentReplacementEntry['replacements']
+}> {
+  const forkSessionId = randomUUID() as UUID
+  const originalSessionId = getSessionId()
+  const projectDir = getProjectDir(getOriginalCwd())
+  const forkSessionPath = getTranscriptPathForSession(forkSessionId)
+  const currentTranscriptPath = getTranscriptPath()
+
+  // Ensure project directory exists
+  await mkdir(projectDir, { recursive: true, mode: 0o700 })
+
+  // Read current transcript file
+  let transcriptContent: Buffer
+  try {
+    transcriptContent = await readFile(currentTranscriptPath)
+  } catch {
+    throw new Error('No conversation to branch')
+  }
+
+  if (transcriptContent.length === 0) {
+    throw new Error('No conversation to branch')
+  }
+
+  // Parse all transcript entries (messages + metadata entries like content-replacement)
+  const entries = parseJSONL<Entry>(transcriptContent)
+
+  // Filter to only main conversation messages (exclude sidechains and non-message entries)
+  const mainConversationEntries = entries.filter(
+    (entry): entry is TranscriptMessage =>
+      isTranscriptMessage(entry) && !entry.isSidechain,
+  )
+
+  // Content-replacement entries for the original session. These record which
+  // tool_result blocks were replaced with previews by the per-message budget.
+  // Without them in the fork JSONL, `claude -r {forkId}` reconstructs state
+  // with an empty replacements Map → previously-replaced results are classified
+  // as FROZEN and sent as full content (prompt cache miss + permanent overage).
+  // sessionId must be rewritten since loadTranscriptFile keys lookup by the
+  // session's messages' sessionId.
+  const contentReplacementRecords = entries
+    .filter(
+      (entry): entry is ContentReplacementEntry =>
+        entry.type === 'content-replacement' &&
+        entry.sessionId === originalSessionId,
+    )
+    .flatMap(entry => entry.replacements)
+
+  if (mainConversationEntries.length === 0) {
+    throw new Error('No messages to branch')
+  }
+
+  // Build forked entries with new sessionId and preserved metadata
+  let parentUuid: UUID | null = null
+  const lines: string[] = []
+  const serializedMessages: SerializedMessage[] = []
+
+  for (const entry of mainConversationEntries) {
+    // Create forked transcript entry preserving all original metadata
+    const forkedEntry: TranscriptEntry = {
+      ...entry,
+      sessionId: forkSessionId,
+      parentUuid,
+      isSidechain: false,
+      forkedFrom: {
+        sessionId: originalSessionId,
+        messageUuid: entry.uuid,
+      },
+    }
+
+    // Build serialized message for LogOption
+    const serialized: SerializedMessage = {
+      ...entry,
+      sessionId: forkSessionId,
+    }
+
+    serializedMessages.push(serialized)
+    lines.push(jsonStringify(forkedEntry))
+    if (entry.type !== 'progress') {
+      parentUuid = entry.uuid
+    }
+  }
+
+  // Append content-replacement entry (if any) with the fork's sessionId.
+  // Written as a SINGLE entry (same shape as insertContentReplacement) so
+  // loadTranscriptFile's content-replacement branch picks it up.
+  if (contentReplacementRecords.length > 0) {
+    const forkedReplacementEntry: ContentReplacementEntry = {
+      type: 'content-replacement',
+      sessionId: forkSessionId,
+      replacements: contentReplacementRecords,
+    }
+    lines.push(jsonStringify(forkedReplacementEntry))
+  }
+
+  // Write the fork session file
+  await writeFile(forkSessionPath, lines.join('\n') + '\n', {
+    encoding: 'utf8',
+    mode: 0o600,
+  })
+
+  return {
+    sessionId: forkSessionId,
+    title: customTitle,
+    forkPath: forkSessionPath,
+    serializedMessages,
+    contentReplacementRecords,
+  }
+}
+
+/**
+ * Generates a unique fork name by checking for collisions with existing session names.
+ * If "baseName (Branch)" already exists, tries "baseName (Branch 2)", "baseName (Branch 3)", etc.
+ */
+async function getUniqueForkName(baseName: string): Promise<string> {
+  const candidateName = `${baseName} (Branch)`
+
+  // Check if this exact name already exists
+  const existingWithExactName = await searchSessionsByCustomTitle(
+    candidateName,
+    { exact: true },
+  )
+
+  if (existingWithExactName.length === 0) {
+    return candidateName
+  }
+
+  // Name collision - find a unique numbered suffix
+  // Search for all sessions that start with the base pattern
+  const existingForks = await searchSessionsByCustomTitle(`${baseName} (Branch`)
+
+  // Extract existing fork numbers to find the next available
+  const usedNumbers = new Set<number>([1]) // Consider " (Branch)" as number 1
+  const forkNumberPattern = new RegExp(
+    `^${escapeRegExp(baseName)} \\(Branch(?: (\\d+))?\\)$`,
+  )
+
+  for (const session of existingForks) {
+    const match = session.customTitle?.match(forkNumberPattern)
+    if (match) {
+      if (match[1]) {
+        usedNumbers.add(parseInt(match[1], 10))
+      } else {
+        usedNumbers.add(1) // " (Branch)" without number is treated as 1
+      }
+    }
+  }
+
+  // Find the next available number
+  let nextNumber = 2
+  while (usedNumbers.has(nextNumber)) {
+    nextNumber++
+  }
+
+  return `${baseName} (Branch ${nextNumber})`
+}
+
+export async function call(
+  onDone: LocalJSXCommandOnDone,
+  context: LocalJSXCommandContext,
+  args: string,
+): Promise<React.ReactNode> {
+  const customTitle = args?.trim() || undefined
+
+  const originalSessionId = getSessionId()
+
+  try {
+    const {
+      sessionId,
+      title,
+      forkPath,
+      serializedMessages,
+      contentReplacementRecords,
+    } = await createFork(customTitle)
+
+    // Build LogOption for resume
+    const now = new Date()
+    const firstPrompt = deriveFirstPrompt(
+      serializedMessages.find(m => m.type === 'user'),
+    )
+
+    // Save custom title - use provided title or firstPrompt as default
+    // This ensures /status and /resume show the same session name
+    // Always add " (Branch)" suffix to make it clear this is a branched session
+    // Handle collisions by adding a number suffix (e.g., " (Branch 2)", " (Branch 3)")
+    const baseName = title ?? firstPrompt
+    const effectiveTitle = await getUniqueForkName(baseName)
+    await saveCustomTitle(sessionId, effectiveTitle, forkPath)
+
+    logEvent('tengu_conversation_forked', {
+      message_count: serializedMessages.length,
+      has_custom_title: !!title,
+    })
+
+    const forkLog: LogOption = {
+      date: now.toISOString().split('T')[0]!,
+      messages: serializedMessages,
+      fullPath: forkPath,
+      value: now.getTime(),
+      created: now,
+      modified: now,
+      firstPrompt,
+      messageCount: serializedMessages.length,
+      isSidechain: false,
+      sessionId,
+      customTitle: effectiveTitle,
+      contentReplacements: contentReplacementRecords,
+    }
+
+    // Resume into the fork
+    const titleInfo = title ? ` "${title}"` : ''
+    const resumeHint = `\nTo resume the original: claude -r ${originalSessionId}`
+    const successMessage = `Branched conversation${titleInfo}. You are now in the branch.${resumeHint}`
+
+    if (context.resume) {
+      await context.resume(sessionId, forkLog, 'fork')
+      onDone(successMessage, { display: 'system' })
+    } else {
+      // Fallback if resume not available
+      onDone(
+        `Branched conversation${titleInfo}. Resume with: /resume ${sessionId}`,
+      )
+    }
+
+    return null
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : 'Unknown error occurred'
+    onDone(`Failed to branch conversation: ${message}`)
+    return null
+  }
+}

src/commands/branch/index.ts

@@ -0,0 +1,14 @@
+import { feature } from 'bun:bundle'
+import type { Command } from '../../commands.js'
+
+const branch = {
+  type: 'local-jsx',
+  name: 'branch',
+  // 'fork' alias only when /fork doesn't exist as its own command
+  aliases: feature('FORK_SUBAGENT') ? [] : ['fork'],
+  description: 'Create a branch of the current conversation at this point',
+  argumentHint: '[name]',
+  load: () => import('./branch.js'),
+} satisfies Command
+
+export default branch

src/commands/break-cache/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/btw/index.ts

@@ -0,0 +1,13 @@
+import type { Command } from '../../commands.js'
+
+const btw = {
+  type: 'local-jsx',
+  name: 'btw',
+  description:
+    'Ask a quick side question without interrupting the main conversation',
+  immediate: true,
+  argumentHint: '<question>',
+  load: () => import('./btw.js'),
+} satisfies Command
+
+export default btw

src/commands/chrome/index.ts

@@ -0,0 +1,13 @@
+import { getIsNonInteractiveSession } from '../../bootstrap/state.js'
+import type { Command } from '../../commands.js'
+
+const command: Command = {
+  name: 'chrome',
+  description: 'Claude in Chrome (Beta) settings',
+  availability: ['claude-ai'],
+  isEnabled: () => !getIsNonInteractiveSession(),
+  type: 'local-jsx',
+  load: () => import('./chrome.js'),
+}
+
+export default command

src/commands/clear/clear.ts

@@ -0,0 +1,7 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { clearConversation } from './conversation.js'
+
+export const call: LocalCommandCall = async (_, context) => {
+  await clearConversation(context)
+  return { type: 'text', value: '' }
+}

src/commands/clear/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Clear command - minimal metadata only.
+ * Implementation is lazy-loaded from clear.ts to reduce startup time.
+ * Utility functions:
+ * - clearSessionCaches: import from './clear/caches.js'
+ * - clearConversation: import from './clear/conversation.js'
+ */
+import type { Command } from '../../commands.js'
+
+const clear = {
+  type: 'local',
+  name: 'clear',
+  description: 'Clear conversation history and free up context',
+  aliases: ['reset', 'new'],
+  supportsNonInteractive: false, // Should just create a new session
+  load: () => import('./clear.js'),
+} satisfies Command
+
+export default clear

src/commands/color/color.ts

@@ -0,0 +1,93 @@
+import type { UUID } from 'crypto'
+import { getSessionId } from '../../bootstrap/state.js'
+import type { ToolUseContext } from '../../Tool.js'
+import {
+  AGENT_COLORS,
+  type AgentColorName,
+} from '../../tools/AgentTool/agentColorManager.js'
+import type {
+  LocalJSXCommandContext,
+  LocalJSXCommandOnDone,
+} from '../../types/command.js'
+import {
+  getTranscriptPath,
+  saveAgentColor,
+} from '../../utils/sessionStorage.js'
+import { isTeammate } from '../../utils/teammate.js'
+
+const RESET_ALIASES = ['default', 'reset', 'none', 'gray', 'grey'] as const
+
+export async function call(
+  onDone: LocalJSXCommandOnDone,
+  context: ToolUseContext & LocalJSXCommandContext,
+  args: string,
+): Promise<null> {
+  // Teammates cannot set their own color
+  if (isTeammate()) {
+    onDone(
+      'Cannot set color: This session is a swarm teammate. Teammate colors are assigned by the team leader.',
+      { display: 'system' },
+    )
+    return null
+  }
+
+  if (!args || args.trim() === '') {
+    const colorList = AGENT_COLORS.join(', ')
+    onDone(`Please provide a color. Available colors: ${colorList}, default`, {
+      display: 'system',
+    })
+    return null
+  }
+
+  const colorArg = args.trim().toLowerCase()
+
+  // Handle reset to default (gray)
+  if (RESET_ALIASES.includes(colorArg as (typeof RESET_ALIASES)[number])) {
+    const sessionId = getSessionId() as UUID
+    const fullPath = getTranscriptPath()
+
+    // Use "default" sentinel (not empty string) so truthiness guards
+    // in sessionStorage.ts persist the reset across session restarts
+    await saveAgentColor(sessionId, 'default', fullPath)
+
+    context.setAppState(prev => ({
+      ...prev,
+      standaloneAgentContext: {
+        ...prev.standaloneAgentContext,
+        name: prev.standaloneAgentContext?.name ?? '',
+        color: undefined,
+      },
+    }))
+
+    onDone('Session color reset to default', { display: 'system' })
+    return null
+  }
+
+  if (!AGENT_COLORS.includes(colorArg as AgentColorName)) {
+    const colorList = AGENT_COLORS.join(', ')
+    onDone(
+      `Invalid color "${colorArg}". Available colors: ${colorList}, default`,
+      { display: 'system' },
+    )
+    return null
+  }
+
+  const sessionId = getSessionId() as UUID
+  const fullPath = getTranscriptPath()
+
+  // Save to transcript for persistence across sessions
+  await saveAgentColor(sessionId, colorArg, fullPath)
+
+  // Update AppState for immediate effect
+  context.setAppState(prev => ({
+    ...prev,
+    standaloneAgentContext: {
+      ...prev.standaloneAgentContext,
+      name: prev.standaloneAgentContext?.name ?? '',
+      color: colorArg as AgentColorName,
+    },
+  }))
+
+  onDone(`Session color set to: ${colorArg}`, { display: 'system' })
+  return null
+}

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

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

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":";AAAA,OAAOA,KAAK,IAAIC,SAAS,EAAEC,MAAM,QAAQ,OAAO;AAChD,SAASC,WAAW,QAAQ,+BAA+B;AAC3D,SAASC,YAAY,QAAQ,sCAAsC;AACnE,SAASC,mBAAmB,QAAQ,4CAA4C;AAChF,SAASC,WAAW,QAAQ,yBAAyB;AACrD,cAAcC,qBAAqB,QAAQ,wBAAwB;AACnE,SAASC,cAAc,QAAQ,6BAA6B;;AAE5D;AACA;AACA,SAAAC,UAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAmB;IAAAC,MAAA;IAAAC,MAAA;IAAAC;EAAA,IAAAL,EAQlB;EACC,MAAAM,UAAA,GAAmBV,WAAW,CAACW,KAAkB,CAAC;EAClD,MAAAC,eAAA,GAAwBb,mBAAmB,CAAC,CAAC;EAC7C,MAAAc,MAAA,GAAejB,MAAM,CAAC,KAAK,CAAC;EAAA,IAAAkB,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAV,CAAA,QAAAE,MAAA,IAAAF,CAAA,QAAAK,UAAA,IAAAL,CAAA,QAAAI,UAAA,IAAAJ,CAAA,QAAAG,MAAA,IAAAH,CAAA,QAAAO,eAAA;IAElBE,EAAA,GAAAA,CAAA;MACR,IAAID,MAAM,CAAAG,OAAQ;QAAA;MAAA;MAClBH,MAAM,CAAAG,OAAA,GAAW,IAAH;MAEd,MAAAC,UAAA,GAAmBV,MAAM,KAAK,QAAQ;MACtC,MAAAW,OAAA,GAAgBR,UAAU,CAAAS,MAAO,CAACC,MAAqB,CAAC;MACxD,MAAAC,QAAA,GACEb,MAAM,KAAK,KAI+B,GAHtCU,OAAO,CAAAC,MAAO,CAACG,GAAA,IACbL,UAAU,GAAGM,GAAC,CAAAC,IAAK,KAAK,UAAkC,GAArBD,GAAC,CAAAC,IAAK,KAAK,UAEb,CAAC,GAAtCN,OAAO,CAAAC,MAAO,CAACM,GAAA,IAAKF,GAAC,CAAAG,IAAK,KAAKlB,MAAM,CAAC;MAE5C,IAAIa,QAAQ,CAAAM,MAAO,KAAK,CAAC;QACvBlB,UAAU,CACRD,MAAM,KAAK,KAE2B,GAFtC,+BACmCS,UAAU,GAAV,SAAmC,GAAnC,UAAmC,EAChC,GAFtC,eAEmBT,MAAM,aAC3B,CAAC;QAAA;MAAA;MAIH,KAAK,MAAAoB,GAAO,IAAIP,QAAQ;QACjBT,eAAe,CAACiB,GAAC,CAAAH,IAAK,CAAC;MAAA;MAG9BjB,UAAU,CACRD,MAAM,KAAK,KAEwD,GAFnE,GACOS,UAAU,GAAV,SAAmC,GAAnC,UAAmC,IAAII,QAAQ,CAAAM,MAAO,gBACM,GAFnE,eAEmBnB,MAAM,KAAKS,UAAU,GAAV,SAAmC,GAAnC,UAAmC,EACnE,CAAC;IAAA,CACF;IAAEF,EAAA,IAACR,MAAM,EAAEC,MAAM,EAAEE,UAAU,EAAEE,eAAe,EAAEH,UAAU,CAAC;IAAAJ,CAAA,MAAAE,MAAA;IAAAF,CAAA,MAAAK,UAAA;IAAAL,CAAA,MAAAI,UAAA;IAAAJ,CAAA,MAAAG,MAAA;IAAAH,CAAA,MAAAO,eAAA;IAAAP,CAAA,MAAAS,EAAA;IAAAT,CAAA,MAAAU,EAAA;EAAA;IAAAD,EAAA,GAAAT,CAAA;IAAAU,EAAA,GAAAV,CAAA;EAAA;EA/B5DV,SAAS,CAACmB,EA+BT,EAAEC,EAAyD,CAAC;EAAA,OAEtD,IAAI;AAAA;AA9Cb,SAAAK,OAAAG,CAAA;EAAA,OAkB2CA,CAAC,CAAAG,IAAK,KAAK,KAAK;AAAA;AAlB3D,SAAAf,MAAAkB,CAAA;EAAA,OASsCA,CAAC,CAAAC,GAAI,CAAAZ,OAAQ;AAAA;AAwCnD,OAAO,eAAea,IAAIA,CACxBC,MAAM,EAAE/B,qBAAqB,EAC7BgC,QAAQ,EAAE,OAAO,EACjBC,IAAa,CAAR,EAAE,MAAM,CACd,EAAEC,OAAO,CAACzC,KAAK,CAAC0C,SAAS,CAAC,CAAC;EAC1B,IAAIF,IAAI,EAAE;IACR,MAAMG,KAAK,GAAGH,IAAI,CAACI,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,KAAK,CAAC;;IAEtC;IACA,IAAIF,KAAK,CAAC,CAAC,CAAC,KAAK,aAAa,EAAE;MAC9B,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAACL,MAAM,CAAC,GAAG;IAC5C;IAEA,IAAIK,KAAK,CAAC,CAAC,CAAC,KAAK,WAAW,IAAIA,KAAK,CAAC,CAAC,CAAC,EAAE;MACxC,OACE,CAAC,YAAY,CACX,UAAU,CAAC,CAACA,KAAK,CAACG,KAAK,CAAC,CAAC,CAAC,CAACC,IAAI,CAAC,GAAG,CAAC,CAAC,CACrC,UAAU,CAAC,CAACT,MAAM,CAAC,GACnB;IAEN;IAEA,IAAIK,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAIA,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE;MACnD,OACE,CAAC,SAAS,CACR,MAAM,CAAC,CAACA,KAAK,CAAC,CAAC,CAAC,CAAC,CACjB,MAAM,CAAC,CAACA,KAAK,CAACV,MAAM,GAAG,CAAC,GAAGU,KAAK,CAACG,KAAK,CAAC,CAAC,CAAC,CAACC,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAC5D,UAAU,CAAC,CAACT,MAAM,CAAC,GACnB;IAEN;EACF;;EAEA;EACA,IAAI,UAAU,KAAK,KAAK,EAAE;IACxB,OACE,CAAC,cAAc,CACb,UAAU,CAAC,CAACA,MAAM,CAAC,CACnB,IAAI,CAAC,QAAQ,CACb,sBAAsB,GACtB;EAEN;EAEA,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAACA,MAAM,CAAC,GAAG;AAC5C","ignoreList":[]}

src/commands/mcp/xaaIdpCommand.ts

@@ -0,0 +1,266 @@
+/**
+ * `claude mcp xaa` — manage the XAA (SEP-990) IdP connection.
+ *
+ * The IdP connection is user-level: configure once, all XAA-enabled MCP
+ * servers reuse it. Lives in settings.xaaIdp (non-secret) + a keychain slot
+ * keyed by issuer (secret). Separate trust domain from per-server AS secrets.
+ */
+import type { Command } from '@commander-js/extra-typings'
+import { cliError, cliOk } from '../../cli/exit.js'
+import {
+  acquireIdpIdToken,
+  clearIdpClientSecret,
+  clearIdpIdToken,
+  getCachedIdpIdToken,
+  getIdpClientSecret,
+  getXaaIdpSettings,
+  issuerKey,
+  saveIdpClientSecret,
+  saveIdpIdTokenFromJwt,
+} from '../../services/mcp/xaaIdpLogin.js'
+import { errorMessage } from '../../utils/errors.js'
+import { updateSettingsForSource } from '../../utils/settings/settings.js'
+
+export function registerMcpXaaIdpCommand(mcp: Command): void {
+  const xaaIdp = mcp
+    .command('xaa')
+    .description('Manage the XAA (SEP-990) IdP connection')
+
+  xaaIdp
+    .command('setup')
+    .description(
+      'Configure the IdP connection (one-time setup for all XAA-enabled servers)',
+    )
+    .requiredOption('--issuer <url>', 'IdP issuer URL (OIDC discovery)')
+    .requiredOption('--client-id <id>', "Claude Code's client_id at the IdP")
+    .option(
+      '--client-secret',
+      'Read IdP client secret from MCP_XAA_IDP_CLIENT_SECRET env var',
+    )
+    .option(
+      '--callback-port <port>',
+      'Fixed loopback callback port (only if IdP does not honor RFC 8252 port-any matching)',
+    )
+    .action(options => {
+      // Validate everything BEFORE any writes. An exit(1) mid-write leaves
+      // settings configured but keychain missing — confusing state.
+      // updateSettingsForSource doesn't schema-check on write; a non-URL
+      // issuer lands on disk and then poisons the whole userSettings source
+      // on next launch (SettingsSchema .url() fails → parseSettingsFile
+      // returns { settings: null }, dropping everything, not just xaaIdp).
+      let issuerUrl: URL
+      try {
+        issuerUrl = new URL(options.issuer)
+      } catch {
+        return cliError(
+          `Error: --issuer must be a valid URL (got "${options.issuer}")`,
+        )
+      }
+      // OIDC discovery + token exchange run against this host. Allow http://
+      // only for loopback (conformance harness mock IdP); anything else leaks
+      // the client secret and authorization code over plaintext.
+      if (
+        issuerUrl.protocol !== 'https:' &&
+        !(
+          issuerUrl.protocol === 'http:' &&
+          (issuerUrl.hostname === 'localhost' ||
+            issuerUrl.hostname === '127.0.0.1' ||
+            issuerUrl.hostname === '[::1]')
+        )
+      ) {
+        return cliError(
+          `Error: --issuer must use https:// (got "${issuerUrl.protocol}//${issuerUrl.host}")`,
+        )
+      }
+      const callbackPort = options.callbackPort
+        ? parseInt(options.callbackPort, 10)
+        : undefined
+      // callbackPort <= 0 fails Zod's .positive() on next launch — same
+      // settings-poisoning failure mode as the issuer check above.
+      if (
+        callbackPort !== undefined &&
+        (!Number.isInteger(callbackPort) || callbackPort <= 0)
+      ) {
+        return cliError('Error: --callback-port must be a positive integer')
+      }
+      const secret = options.clientSecret
+        ? process.env.MCP_XAA_IDP_CLIENT_SECRET
+        : undefined
+      if (options.clientSecret && !secret) {
+        return cliError(
+          'Error: --client-secret requires MCP_XAA_IDP_CLIENT_SECRET env var',
+        )
+      }
+
+      // Read old config now (before settings overwrite) so we can clear stale
+      // keychain slots after a successful write. `clear` can't do this after
+      // the fact — it reads the *current* settings.xaaIdp, which by then is
+      // the new one.
+      const old = getXaaIdpSettings()
+      const oldIssuer = old?.issuer
+      const oldClientId = old?.clientId
+
+      // callbackPort MUST be present (even as undefined) — mergeWith deep-merges
+      // and only deletes on explicit `undefined`, not on absent key. A conditional
+      // spread would leak a prior fixed port into a new IdP's config.
+      const { error } = updateSettingsForSource('userSettings', {
+        xaaIdp: {
+          issuer: options.issuer,
+          clientId: options.clientId,
+          callbackPort,
+        },
+      })
+      if (error) {
+        return cliError(`Error writing settings: ${error.message}`)
+      }
+
+      // Clear stale keychain slots only after settings write succeeded —
+      // otherwise a write failure leaves settings pointing at oldIssuer with
+      // its secret already gone. Compare via issuerKey(): trailing-slash or
+      // host-case differences normalize to the same keychain slot.
+      if (oldIssuer) {
+        if (issuerKey(oldIssuer) !== issuerKey(options.issuer)) {
+          clearIdpIdToken(oldIssuer)
+          clearIdpClientSecret(oldIssuer)
+        } else if (oldClientId !== options.clientId) {
+          // Same issuer slot but different OAuth client registration — the
+          // cached id_token's aud claim and the stored secret are both for the
+          // old client. `xaa login` would send {new clientId, old secret} and
+          // fail with opaque `invalid_client`; downstream SEP-990 exchange
+          // would fail aud validation. Keep both when clientId is unchanged:
+          // re-setup without --client-secret means "tweak port, keep secret".
+          clearIdpIdToken(oldIssuer)
+          clearIdpClientSecret(oldIssuer)
+        }
+      }
+
+      if (secret) {
+        const { success, warning } = saveIdpClientSecret(options.issuer, secret)
+        if (!success) {
+          return cliError(
+            `Error: settings written but keychain save failed${warning ? ` — ${warning}` : ''}. ` +
+              `Re-run with --client-secret once keychain is available.`,
+          )
+        }
+      }
+
+      cliOk(`XAA IdP connection configured for ${options.issuer}`)
+    })
+
+  xaaIdp
+    .command('login')
+    .description(
+      'Cache an IdP id_token so XAA-enabled MCP servers authenticate ' +
+        'silently. Default: run the OIDC browser login. With --id-token: ' +
+        'write a pre-obtained JWT directly (used by conformance/e2e tests ' +
+        'where the mock IdP does not serve /authorize).',
+    )
+    .option(
+      '--force',
+      'Ignore any cached id_token and re-login (useful after IdP-side revocation)',
+    )
+    // TODO(paulc): read the JWT from stdin instead of argv to keep it out of
+    // shell history. Fine for conformance (docker exec uses argv directly,
+    // no shell parser), but a real user would want `echo $TOKEN | ... --stdin`.
+    .option(
+      '--id-token <jwt>',
+      'Write this pre-obtained id_token directly to cache, skipping the OIDC browser login',
+    )
+    .action(async options => {
+      const idp = getXaaIdpSettings()
+      if (!idp) {
+        return cliError(
+          "Error: no XAA IdP connection. Run 'claude mcp xaa setup' first.",
+        )
+      }
+
+      // Direct-inject path: skip cache check, skip OIDC. Writing IS the
+      // operation. Issuer comes from settings (single source of truth), not
+      // a separate flag — one less thing to desync.
+      if (options.idToken) {
+        const expiresAt = saveIdpIdTokenFromJwt(idp.issuer, options.idToken)
+        return cliOk(
+          `id_token cached for ${idp.issuer} (expires ${new Date(expiresAt).toISOString()})`,
+        )
+      }
+
+      if (options.force) {
+        clearIdpIdToken(idp.issuer)
+      }
+
+      const wasCached = getCachedIdpIdToken(idp.issuer) !== undefined
+      if (wasCached) {
+        return cliOk(
+          `Already logged in to ${idp.issuer} (cached id_token still valid). Use --force to re-login.`,
+        )
+      }
+
+      process.stdout.write(`Opening browser for IdP login at ${idp.issuer}…\n`)
+      try {
+        await acquireIdpIdToken({
+          idpIssuer: idp.issuer,
+          idpClientId: idp.clientId,
+          idpClientSecret: getIdpClientSecret(idp.issuer),
+          callbackPort: idp.callbackPort,
+          onAuthorizationUrl: url => {
+            process.stdout.write(
+              `If the browser did not open, visit:\n  ${url}\n`,
+            )
+          },
+        })
+        cliOk(
+          `Logged in. MCP servers with --xaa will now authenticate silently.`,
+        )
+      } catch (e) {
+        cliError(`IdP login failed: ${errorMessage(e)}`)
+      }
+    })
+
+  xaaIdp
+    .command('show')
+    .description('Show the current IdP connection config')
+    .action(() => {
+      const idp = getXaaIdpSettings()
+      if (!idp) {
+        return cliOk('No XAA IdP connection configured.')
+      }
+      const hasSecret = getIdpClientSecret(idp.issuer) !== undefined
+      const hasIdToken = getCachedIdpIdToken(idp.issuer) !== undefined
+      process.stdout.write(`Issuer:        ${idp.issuer}\n`)
+      process.stdout.write(`Client ID:     ${idp.clientId}\n`)
+      if (idp.callbackPort !== undefined) {
+        process.stdout.write(`Callback port: ${idp.callbackPort}\n`)
+      }
+      process.stdout.write(
+        `Client secret: ${hasSecret ? '(stored in keychain)' : '(not set — PKCE-only)'}\n`,
+      )
+      process.stdout.write(
+        `Logged in:     ${hasIdToken ? 'yes (id_token cached)' : "no — run 'claude mcp xaa login'"}\n`,
+      )
+      cliOk()
+    })
+
+  xaaIdp
+    .command('clear')
+    .description('Clear the IdP connection config and cached id_token')
+    .action(() => {
+      // Read issuer first so we can clear the right keychain slots.
+      const idp = getXaaIdpSettings()
+      // updateSettingsForSource uses mergeWith: set to undefined (not delete)
+      // to signal key removal.
+      const { error } = updateSettingsForSource('userSettings', {
+        xaaIdp: undefined,
+      })
+      if (error) {
+        return cliError(`Error writing settings: ${error.message}`)
+      }
+      // Clear keychain only after settings write succeeded — otherwise a
+      // write failure leaves settings pointing at the IdP with its secrets
+      // already gone (same pattern as `setup`'s old-issuer cleanup).
+      if (idp) {
+        clearIdpIdToken(idp.issuer)
+        clearIdpClientSecret(idp.issuer)
+      }
+      cliOk('XAA IdP connection cleared')
+    })
+}

src/commands/memory/index.ts

@@ -0,0 +1,10 @@
+import type { Command } from '../../commands.js'
+
+const memory: Command = {
+  type: 'local-jsx',
+  name: 'memory',
+  description: 'Edit Claude memory files',
+  load: () => import('./memory.js'),
+}
+
+export default memory

src/commands/memory/memory.tsx

@@ -0,0 +1,90 @@
+import { mkdir, writeFile } from 'fs/promises';
+import * as React from 'react';
+import type { CommandResultDisplay } from '../../commands.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { MemoryFileSelector } from '../../components/memory/MemoryFileSelector.js';
+import { getRelativeMemoryPath } from '../../components/memory/MemoryUpdateNotification.js';
+import { Box, Link, Text } from '../../ink.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+import { clearMemoryFileCaches, getMemoryFiles } from '../../utils/claudemd.js';
+import { getClaudeConfigHomeDir } from '../../utils/envUtils.js';
+import { getErrnoCode } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { editFileInEditor } from '../../utils/promptEditor.js';
+function MemoryCommand({
+  onDone
+}: {
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+}): React.ReactNode {
+  const handleSelectMemoryFile = async (memoryPath: string) => {
+    try {
+      // Create claude directory if it doesn't exist (idempotent with recursive)
+      if (memoryPath.includes(getClaudeConfigHomeDir())) {
+        await mkdir(getClaudeConfigHomeDir(), {
+          recursive: true
+        });
+      }
+
+      // Create file if it doesn't exist (wx flag fails if file exists,
+      // which we catch to preserve existing content)
+      try {
+        await writeFile(memoryPath, '', {
+          encoding: 'utf8',
+          flag: 'wx'
+        });
+      } catch (e: unknown) {
+        if (getErrnoCode(e) !== 'EEXIST') {
+          throw e;
+        }
+      }
+      await editFileInEditor(memoryPath);
+
+      // Determine which environment variable controls the editor
+      let editorSource = 'default';
+      let editorValue = '';
+      if (process.env.VISUAL) {
+        editorSource = '$VISUAL';
+        editorValue = process.env.VISUAL;
+      } else if (process.env.EDITOR) {
+        editorSource = '$EDITOR';
+        editorValue = process.env.EDITOR;
+      }
+      const editorInfo = editorSource !== 'default' ? `Using ${editorSource}="${editorValue}".` : '';
+      const editorHint = editorInfo ? `> ${editorInfo} To change editor, set $EDITOR or $VISUAL environment variable.` : `> To use a different editor, set the $EDITOR or $VISUAL environment variable.`;
+      onDone(`Opened memory file at ${getRelativeMemoryPath(memoryPath)}\n\n${editorHint}`, {
+        display: 'system'
+      });
+    } catch (error) {
+      logError(error);
+      onDone(`Error opening memory file: ${error}`);
+    }
+  };
+  const handleCancel = () => {
+    onDone('Cancelled memory editing', {
+      display: 'system'
+    });
+  };
+  return <Dialog title="Memory" onCancel={handleCancel} color="remember">
+      <Box flexDirection="column">
+        <React.Suspense fallback={null}>
+          <MemoryFileSelector onSelect={handleSelectMemoryFile} onCancel={handleCancel} />
+        </React.Suspense>
+
+        <Box marginTop={1}>
+          <Text dimColor>
+            Learn more: <Link url="https://code.claude.com/docs/en/memory" />
+          </Text>
+        </Box>
+      </Box>
+    </Dialog>;
+}
+export const call: LocalJSXCommandCall = async onDone => {
+  // Clear + prime before rendering — Suspense handles the unprimed case,
+  // but awaiting here avoids a fallback flash on initial open.
+  clearMemoryFileCaches();
+  await getMemoryFiles();
+  return <MemoryCommand onDone={onDone} />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mkdir","writeFile","React","CommandResultDisplay","Dialog","MemoryFileSelector","getRelativeMemoryPath","Box","Link","Text","LocalJSXCommandCall","clearMemoryFileCaches","getMemoryFiles","getClaudeConfigHomeDir","getErrnoCode","logError","editFileInEditor","MemoryCommand","onDone","result","options","display","ReactNode","handleSelectMemoryFile","memoryPath","includes","recursive","encoding","flag","e","editorSource","editorValue","process","env","VISUAL","EDITOR","editorInfo","editorHint","error","handleCancel","call"],"sources":["memory.tsx"],"sourcesContent":["import { mkdir, writeFile } from 'fs/promises'\nimport * as React from 'react'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { MemoryFileSelector } from '../../components/memory/MemoryFileSelector.js'\nimport { getRelativeMemoryPath } from '../../components/memory/MemoryUpdateNotification.js'\nimport { Box, Link, Text } from '../../ink.js'\nimport type { LocalJSXCommandCall } from '../../types/command.js'\nimport { clearMemoryFileCaches, getMemoryFiles } from '../../utils/claudemd.js'\nimport { getClaudeConfigHomeDir } from '../../utils/envUtils.js'\nimport { getErrnoCode } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { editFileInEditor } from '../../utils/promptEditor.js'\n\nfunction MemoryCommand({\n  onDone,\n}: {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}): React.ReactNode {\n  const handleSelectMemoryFile = async (memoryPath: string) => {\n    try {\n      // Create claude directory if it doesn't exist (idempotent with recursive)\n      if (memoryPath.includes(getClaudeConfigHomeDir())) {\n        await mkdir(getClaudeConfigHomeDir(), { recursive: true })\n      }\n\n      // Create file if it doesn't exist (wx flag fails if file exists,\n      // which we catch to preserve existing content)\n      try {\n        await writeFile(memoryPath, '', { encoding: 'utf8', flag: 'wx' })\n      } catch (e: unknown) {\n        if (getErrnoCode(e) !== 'EEXIST') {\n          throw e\n        }\n      }\n\n      await editFileInEditor(memoryPath)\n\n      // Determine which environment variable controls the editor\n      let editorSource = 'default'\n      let editorValue = ''\n      if (process.env.VISUAL) {\n        editorSource = '$VISUAL'\n        editorValue = process.env.VISUAL\n      } else if (process.env.EDITOR) {\n        editorSource = '$EDITOR'\n        editorValue = process.env.EDITOR\n      }\n\n      const editorInfo =\n        editorSource !== 'default'\n          ? `Using ${editorSource}=\"${editorValue}\".`\n          : ''\n\n      const editorHint = editorInfo\n        ? `> ${editorInfo} To change editor, set $EDITOR or $VISUAL environment variable.`\n        : `> To use a different editor, set the $EDITOR or $VISUAL environment variable.`\n\n      onDone(\n        `Opened memory file at ${getRelativeMemoryPath(memoryPath)}\\n\\n${editorHint}`,\n        { display: 'system' },\n      )\n    } catch (error) {\n      logError(error)\n      onDone(`Error opening memory file: ${error}`)\n    }\n  }\n\n  const handleCancel = () => {\n    onDone('Cancelled memory editing', { display: 'system' })\n  }\n\n  return (\n    <Dialog title=\"Memory\" onCancel={handleCancel} color=\"remember\">\n      <Box flexDirection=\"column\">\n        <React.Suspense fallback={null}>\n          <MemoryFileSelector\n            onSelect={handleSelectMemoryFile}\n            onCancel={handleCancel}\n          />\n        </React.Suspense>\n\n        <Box marginTop={1}>\n          <Text dimColor>\n            Learn more: <Link url=\"https://code.claude.com/docs/en/memory\" />\n          </Text>\n        </Box>\n      </Box>\n    </Dialog>\n  )\n}\n\nexport const call: LocalJSXCommandCall = async onDone => {\n  // Clear + prime before rendering — Suspense handles the unprimed case,\n  // but awaiting here avoids a fallback flash on initial open.\n  clearMemoryFileCaches()\n  await getMemoryFiles()\n  return <MemoryCommand onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/mobile/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const mobile = {
+  type: 'local-jsx',
+  name: 'mobile',
+  aliases: ['ios', 'android'],
+  description: 'Show QR code to download the Claude mobile app',
+  load: () => import('./mobile.js'),
+} satisfies Command
+
+export default mobile

src/commands/mobile/mobile.tsx

@@ -0,0 +1,274 @@
+import { c as _c } from "react/compiler-runtime";
+import { toString as qrToString } from 'qrcode';
+import * as React from 'react';
+import { useCallback, useEffect, useState } from 'react';
+import { Pane } from '../../components/design-system/Pane.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import { Box, Text } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+type Platform = 'ios' | 'android';
+type Props = {
+  onDone: () => void;
+};
+const PLATFORMS: Record<Platform, {
+  url: string;
+}> = {
+  ios: {
+    url: 'https://apps.apple.com/app/claude-by-anthropic/id6473753684'
+  },
+  android: {
+    url: 'https://play.google.com/store/apps/details?id=com.anthropic.claude'
+  }
+};
+function MobileQRCode(t0) {
+  const $ = _c(52);
+  const {
+    onDone
+  } = t0;
+  const [platform, setPlatform] = useState("ios");
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = {
+      ios: "",
+      android: ""
+    };
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const [qrCodes, setQrCodes] = useState(t1);
+  const {
+    url
+  } = PLATFORMS[platform];
+  const qrCode = qrCodes[platform];
+  let t2;
+  let t3;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = () => {
+      const generateQRCodes = async function generateQRCodes() {
+        const [ios, android] = await Promise.all([qrToString(PLATFORMS.ios.url, {
+          type: "utf8",
+          errorCorrectionLevel: "L"
+        }), qrToString(PLATFORMS.android.url, {
+          type: "utf8",
+          errorCorrectionLevel: "L"
+        })]);
+        setQrCodes({
+          ios,
+          android
+        });
+      };
+      generateQRCodes().catch(_temp);
+    };
+    t3 = [];
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t2 = $[1];
+    t3 = $[2];
+  }
+  useEffect(t2, t3);
+  let t4;
+  if ($[3] !== onDone) {
+    t4 = () => {
+      onDone();
+    };
+    $[3] = onDone;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  const handleClose = t4;
+  let t5;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = {
+      context: "Confirmation"
+    };
+    $[5] = t5;
+  } else {
+    t5 = $[5];
+  }
+  useKeybinding("confirm:no", handleClose, t5);
+  let t6;
+  if ($[6] !== onDone) {
+    t6 = function handleKeyDown(e) {
+      if (e.key === "q" || e.ctrl && e.key === "c") {
+        e.preventDefault();
+        onDone();
+        return;
+      }
+      if (e.key === "tab" || e.key === "left" || e.key === "right") {
+        e.preventDefault();
+        setPlatform(_temp2);
+      }
+    };
+    $[6] = onDone;
+    $[7] = t6;
+  } else {
+    t6 = $[7];
+  }
+  const handleKeyDown = t6;
+  let T0;
+  let T1;
+  let t10;
+  let t11;
+  let t12;
+  let t13;
+  let t7;
+  let t8;
+  let t9;
+  if ($[8] !== handleKeyDown || $[9] !== qrCode) {
+    const lines = qrCode.split("\n").filter(_temp3);
+    T1 = Pane;
+    T0 = Box;
+    t7 = "column";
+    t8 = 0;
+    t9 = true;
+    t10 = handleKeyDown;
+    if ($[19] === Symbol.for("react.memo_cache_sentinel")) {
+      t11 = <Text> </Text>;
+      t12 = <Text> </Text>;
+      $[19] = t11;
+      $[20] = t12;
+    } else {
+      t11 = $[19];
+      t12 = $[20];
+    }
+    t13 = lines.map(_temp4);
+    $[8] = handleKeyDown;
+    $[9] = qrCode;
+    $[10] = T0;
+    $[11] = T1;
+    $[12] = t10;
+    $[13] = t11;
+    $[14] = t12;
+    $[15] = t13;
+    $[16] = t7;
+    $[17] = t8;
+    $[18] = t9;
+  } else {
+    T0 = $[10];
+    T1 = $[11];
+    t10 = $[12];
+    t11 = $[13];
+    t12 = $[14];
+    t13 = $[15];
+    t7 = $[16];
+    t8 = $[17];
+    t9 = $[18];
+  }
+  let t14;
+  let t15;
+  if ($[21] === Symbol.for("react.memo_cache_sentinel")) {
+    t14 = <Text> </Text>;
+    t15 = <Text> </Text>;
+    $[21] = t14;
+    $[22] = t15;
+  } else {
+    t14 = $[21];
+    t15 = $[22];
+  }
+  const t16 = platform === "ios";
+  const t17 = platform === "ios";
+  let t18;
+  if ($[23] !== t16 || $[24] !== t17) {
+    t18 = <Text bold={t16} underline={t17}>iOS</Text>;
+    $[23] = t16;
+    $[24] = t17;
+    $[25] = t18;
+  } else {
+    t18 = $[25];
+  }
+  let t19;
+  if ($[26] === Symbol.for("react.memo_cache_sentinel")) {
+    t19 = <Text dimColor={true}>{" / "}</Text>;
+    $[26] = t19;
+  } else {
+    t19 = $[26];
+  }
+  const t20 = platform === "android";
+  const t21 = platform === "android";
+  let t22;
+  if ($[27] !== t20 || $[28] !== t21) {
+    t22 = <Text bold={t20} underline={t21}>Android</Text>;
+    $[27] = t20;
+    $[28] = t21;
+    $[29] = t22;
+  } else {
+    t22 = $[29];
+  }
+  let t23;
+  if ($[30] !== t18 || $[31] !== t22) {
+    t23 = <Text>{t18}{t19}{t22}</Text>;
+    $[30] = t18;
+    $[31] = t22;
+    $[32] = t23;
+  } else {
+    t23 = $[32];
+  }
+  let t24;
+  if ($[33] === Symbol.for("react.memo_cache_sentinel")) {
+    t24 = <Text dimColor={true}>(tab to switch, esc to close)</Text>;
+    $[33] = t24;
+  } else {
+    t24 = $[33];
+  }
+  let t25;
+  if ($[34] !== t23) {
+    t25 = <Box flexDirection="row" gap={2}>{t23}{t24}</Box>;
+    $[34] = t23;
+    $[35] = t25;
+  } else {
+    t25 = $[35];
+  }
+  let t26;
+  if ($[36] !== url) {
+    t26 = <Text dimColor={true}>{url}</Text>;
+    $[36] = url;
+    $[37] = t26;
+  } else {
+    t26 = $[37];
+  }
+  let t27;
+  if ($[38] !== T0 || $[39] !== t10 || $[40] !== t11 || $[41] !== t12 || $[42] !== t13 || $[43] !== t25 || $[44] !== t26 || $[45] !== t7 || $[46] !== t8 || $[47] !== t9) {
+    t27 = <T0 flexDirection={t7} tabIndex={t8} autoFocus={t9} onKeyDown={t10}>{t11}{t12}{t13}{t14}{t15}{t25}{t26}</T0>;
+    $[38] = T0;
+    $[39] = t10;
+    $[40] = t11;
+    $[41] = t12;
+    $[42] = t13;
+    $[43] = t25;
+    $[44] = t26;
+    $[45] = t7;
+    $[46] = t8;
+    $[47] = t9;
+    $[48] = t27;
+  } else {
+    t27 = $[48];
+  }
+  let t28;
+  if ($[49] !== T1 || $[50] !== t27) {
+    t28 = <T1>{t27}</T1>;
+    $[49] = T1;
+    $[50] = t27;
+    $[51] = t28;
+  } else {
+    t28 = $[51];
+  }
+  return t28;
+}
+function _temp4(line_0, i) {
+  return <Text key={i}>{line_0}</Text>;
+}
+function _temp3(line) {
+  return line.length > 0;
+}
+function _temp2(prev) {
+  return prev === "ios" ? "android" : "ios";
+}
+function _temp() {}
+export async function call(onDone: LocalJSXCommandOnDone): Promise<React.ReactNode> {
+  return <MobileQRCode onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["toString","qrToString","React","useCallback","useEffect","useState","Pane","KeyboardEvent","Box","Text","useKeybinding","LocalJSXCommandOnDone","Platform","Props","onDone","PLATFORMS","Record","url","ios","android","MobileQRCode","t0","$","_c","platform","setPlatform","t1","Symbol","for","qrCodes","setQrCodes","qrCode","t2","t3","generateQRCodes","Promise","all","type","errorCorrectionLevel","catch","_temp","t4","handleClose","t5","context","t6","handleKeyDown","e","key","ctrl","preventDefault","_temp2","T0","T1","t10","t11","t12","t13","t7","t8","t9","lines","split","filter","_temp3","map","_temp4","t14","t15","t16","t17","t18","t19","t20","t21","t22","t23","t24","t25","t26","t27","t28","line_0","i","line","length","prev","call","ReactNode"],"sources":["mobile.tsx"],"sourcesContent":["import { toString as qrToString } from 'qrcode'\nimport * as React from 'react'\nimport { useCallback, useEffect, useState } from 'react'\nimport { Pane } from '../../components/design-system/Pane.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\n\ntype Platform = 'ios' | 'android'\n\ntype Props = {\n  onDone: () => void\n}\n\nconst PLATFORMS: Record<Platform, { url: string }> = {\n  ios: {\n    url: 'https://apps.apple.com/app/claude-by-anthropic/id6473753684',\n  },\n  android: {\n    url: 'https://play.google.com/store/apps/details?id=com.anthropic.claude',\n  },\n}\n\nfunction MobileQRCode({ onDone }: Props): React.ReactNode {\n  const [platform, setPlatform] = useState<Platform>('ios')\n  const [qrCodes, setQrCodes] = useState<Record<Platform, string>>({\n    ios: '',\n    android: '',\n  })\n\n  const { url } = PLATFORMS[platform]\n  const qrCode = qrCodes[platform]\n\n  // Generate both QR codes upfront to avoid flicker when switching\n  useEffect(() => {\n    async function generateQRCodes(): Promise<void> {\n      const [ios, android] = await Promise.all([\n        qrToString(PLATFORMS.ios.url, {\n          type: 'utf8',\n          errorCorrectionLevel: 'L',\n        }),\n        qrToString(PLATFORMS.android.url, {\n          type: 'utf8',\n          errorCorrectionLevel: 'L',\n        }),\n      ])\n      setQrCodes({ ios, android })\n    }\n    generateQRCodes().catch(() => {\n      // QR generation failed, leave empty\n    })\n  }, [])\n\n  const handleClose = useCallback(() => {\n    onDone()\n  }, [onDone])\n\n  useKeybinding('confirm:no', handleClose, { context: 'Confirmation' })\n\n  function handleKeyDown(e: KeyboardEvent): void {\n    if (e.key === 'q' || (e.ctrl && e.key === 'c')) {\n      e.preventDefault()\n      onDone()\n      return\n    }\n    if (e.key === 'tab' || e.key === 'left' || e.key === 'right') {\n      e.preventDefault()\n      setPlatform(prev => (prev === 'ios' ? 'android' : 'ios'))\n    }\n  }\n\n  const lines = qrCode.split('\\n').filter(line => line.length > 0)\n\n  return (\n    <Pane>\n      <Box\n        flexDirection=\"column\"\n        tabIndex={0}\n        autoFocus\n        onKeyDown={handleKeyDown}\n      >\n        <Text> </Text>\n        <Text> </Text>\n        {lines.map((line, i) => (\n          <Text key={i}>{line}</Text>\n        ))}\n        <Text> </Text>\n        <Text> </Text>\n\n        {/* Controls */}\n        <Box flexDirection=\"row\" gap={2}>\n          <Text>\n            <Text bold={platform === 'ios'} underline={platform === 'ios'}>\n              iOS\n            </Text>\n            <Text dimColor>{' / '}</Text>\n            <Text\n              bold={platform === 'android'}\n              underline={platform === 'android'}\n            >\n              Android\n            </Text>\n          </Text>\n          <Text dimColor>(tab to switch, esc to close)</Text>\n        </Box>\n        <Text dimColor>{url}</Text>\n      </Box>\n    </Pane>\n  )\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n): Promise<React.ReactNode> {\n  return <MobileQRCode onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/mock-limits/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/model/index.ts

@@ -0,0 +1,16 @@
+import type { Command } from '../../commands.js'
+import { shouldInferenceConfigCommandBeImmediate } from '../../utils/immediateCommand.js'
+import { getMainLoopModel, renderModelName } from '../../utils/model/model.js'
+
+export default {
+  type: 'local-jsx',
+  name: 'model',
+  get description() {
+    return `Set the AI model for Claude Code (currently ${renderModelName(getMainLoopModel())})`
+  },
+  argumentHint: '[model]',
+  get immediate() {
+    return shouldInferenceConfigCommandBeImmediate()
+  },
+  load: () => import('./model.js'),
+} satisfies Command

src/commands/model/model.tsx

@@ -0,0 +1,297 @@
+import { c as _c } from "react/compiler-runtime";
+import chalk from 'chalk';
+import * as React from 'react';
+import type { CommandResultDisplay } from '../../commands.js';
+import { ModelPicker } from '../../components/ModelPicker.js';
+import { COMMON_HELP_ARGS, COMMON_INFO_ARGS } from '../../constants/xml.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
+import { useAppState, useSetAppState } from '../../state/AppState.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+import type { EffortLevel } from '../../utils/effort.js';
+import { isBilledAsExtraUsage } from '../../utils/extraUsage.js';
+import { clearFastModeCooldown, isFastModeAvailable, isFastModeEnabled, isFastModeSupportedByModel } from '../../utils/fastMode.js';
+import { MODEL_ALIASES } from '../../utils/model/aliases.js';
+import { checkOpus1mAccess, checkSonnet1mAccess } from '../../utils/model/check1mAccess.js';
+import { getDefaultMainLoopModelSetting, isOpus1mMergeEnabled, renderDefaultModelSetting } from '../../utils/model/model.js';
+import { isModelAllowed } from '../../utils/model/modelAllowlist.js';
+import { validateModel } from '../../utils/model/validateModel.js';
+function ModelPickerWrapper(t0) {
+  const $ = _c(17);
+  const {
+    onDone
+  } = t0;
+  const mainLoopModel = useAppState(_temp);
+  const mainLoopModelForSession = useAppState(_temp2);
+  const isFastMode = useAppState(_temp3);
+  const setAppState = useSetAppState();
+  let t1;
+  if ($[0] !== mainLoopModel || $[1] !== onDone) {
+    t1 = function handleCancel() {
+      logEvent("tengu_model_command_menu", {
+        action: "cancel" as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      const displayModel = renderModelLabel(mainLoopModel);
+      onDone(`Kept model as ${chalk.bold(displayModel)}`, {
+        display: "system"
+      });
+    };
+    $[0] = mainLoopModel;
+    $[1] = onDone;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const handleCancel = t1;
+  let t2;
+  if ($[3] !== isFastMode || $[4] !== mainLoopModel || $[5] !== onDone || $[6] !== setAppState) {
+    t2 = function handleSelect(model, effort) {
+      logEvent("tengu_model_command_menu", {
+        action: model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        from_model: mainLoopModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        to_model: model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      setAppState(prev => ({
+        ...prev,
+        mainLoopModel: model,
+        mainLoopModelForSession: null
+      }));
+      let message = `Set model to ${chalk.bold(renderModelLabel(model))}`;
+      if (effort !== undefined) {
+        message = message + ` with ${chalk.bold(effort)} effort`;
+      }
+      let wasFastModeToggledOn = undefined;
+      if (isFastModeEnabled()) {
+        clearFastModeCooldown();
+        if (!isFastModeSupportedByModel(model) && isFastMode) {
+          setAppState(_temp4);
+          wasFastModeToggledOn = false;
+        } else {
+          if (isFastModeSupportedByModel(model) && isFastModeAvailable() && isFastMode) {
+            message = message + " \xB7 Fast mode ON";
+            wasFastModeToggledOn = true;
+          }
+        }
+      }
+      if (isBilledAsExtraUsage(model, wasFastModeToggledOn === true, isOpus1mMergeEnabled())) {
+        message = message + " \xB7 Billed as extra usage";
+      }
+      if (wasFastModeToggledOn === false) {
+        message = message + " \xB7 Fast mode OFF";
+      }
+      onDone(message);
+    };
+    $[3] = isFastMode;
+    $[4] = mainLoopModel;
+    $[5] = onDone;
+    $[6] = setAppState;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const handleSelect = t2;
+  let t3;
+  if ($[8] !== isFastMode || $[9] !== mainLoopModel) {
+    t3 = isFastModeEnabled() && isFastMode && isFastModeSupportedByModel(mainLoopModel) && isFastModeAvailable();
+    $[8] = isFastMode;
+    $[9] = mainLoopModel;
+    $[10] = t3;
+  } else {
+    t3 = $[10];
+  }
+  let t4;
+  if ($[11] !== handleCancel || $[12] !== handleSelect || $[13] !== mainLoopModel || $[14] !== mainLoopModelForSession || $[15] !== t3) {
+    t4 = <ModelPicker initial={mainLoopModel} sessionModel={mainLoopModelForSession} onSelect={handleSelect} onCancel={handleCancel} isStandaloneCommand={true} showFastModeNotice={t3} />;
+    $[11] = handleCancel;
+    $[12] = handleSelect;
+    $[13] = mainLoopModel;
+    $[14] = mainLoopModelForSession;
+    $[15] = t3;
+    $[16] = t4;
+  } else {
+    t4 = $[16];
+  }
+  return t4;
+}
+function _temp4(prev_0) {
+  return {
+    ...prev_0,
+    fastMode: false
+  };
+}
+function _temp3(s_1) {
+  return s_1.fastMode;
+}
+function _temp2(s_0) {
+  return s_0.mainLoopModelForSession;
+}
+function _temp(s) {
+  return s.mainLoopModel;
+}
+function SetModelAndClose({
+  args,
+  onDone
+}: {
+  args: string;
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+}): React.ReactNode {
+  const isFastMode = useAppState(s => s.fastMode);
+  const setAppState = useSetAppState();
+  const model = args === 'default' ? null : args;
+  React.useEffect(() => {
+    async function handleModelChange(): Promise<void> {
+      if (model && !isModelAllowed(model)) {
+        onDone(`Model '${model}' is not available. Your organization restricts model selection.`, {
+          display: 'system'
+        });
+        return;
+      }
+
+      // @[MODEL LAUNCH]: Update check for 1M access.
+      if (model && isOpus1mUnavailable(model)) {
+        onDone(`Opus 4.6 with 1M context is not available for your account. Learn more: https://code.claude.com/docs/en/model-config#extended-context-with-1m`, {
+          display: 'system'
+        });
+        return;
+      }
+      if (model && isSonnet1mUnavailable(model)) {
+        onDone(`Sonnet 4.6 with 1M context is not available for your account. Learn more: https://code.claude.com/docs/en/model-config#extended-context-with-1m`, {
+          display: 'system'
+        });
+        return;
+      }
+
+      // Skip validation for default model
+      if (!model) {
+        setModel(null);
+        return;
+      }
+
+      // Skip validation for known aliases - they're predefined and should work
+      if (isKnownAlias(model)) {
+        setModel(model);
+        return;
+      }
+
+      // Validate and set custom model
+      try {
+        // Don't use parseUserSpecifiedModel for non-aliases since it lowercases the input
+        // and model names are case-sensitive
+        const {
+          valid,
+          error: error_0
+        } = await validateModel(model);
+        if (valid) {
+          setModel(model);
+        } else {
+          onDone(error_0 || `Model '${model}' not found`, {
+            display: 'system'
+          });
+        }
+      } catch (error) {
+        onDone(`Failed to validate model: ${(error as Error).message}`, {
+          display: 'system'
+        });
+      }
+    }
+    function setModel(modelValue: string | null): void {
+      setAppState(prev => ({
+        ...prev,
+        mainLoopModel: modelValue,
+        mainLoopModelForSession: null
+      }));
+      let message = `Set model to ${chalk.bold(renderModelLabel(modelValue))}`;
+      let wasFastModeToggledOn = undefined;
+      if (isFastModeEnabled()) {
+        clearFastModeCooldown();
+        if (!isFastModeSupportedByModel(modelValue) && isFastMode) {
+          setAppState(prev_0 => ({
+            ...prev_0,
+            fastMode: false
+          }));
+          wasFastModeToggledOn = false;
+          // Do not update fast mode in settings since this is an automatic downgrade
+        } else if (isFastModeSupportedByModel(modelValue) && isFastMode) {
+          message += ` · Fast mode ON`;
+          wasFastModeToggledOn = true;
+        }
+      }
+      if (isBilledAsExtraUsage(modelValue, wasFastModeToggledOn === true, isOpus1mMergeEnabled())) {
+        message += ` · Billed as extra usage`;
+      }
+      if (wasFastModeToggledOn === false) {
+        // Fast mode was toggled off, show suffix after extra usage billing
+        message += ` · Fast mode OFF`;
+      }
+      onDone(message);
+    }
+    void handleModelChange();
+  }, [model, onDone, setAppState]);
+  return null;
+}
+function isKnownAlias(model: string): boolean {
+  return (MODEL_ALIASES as readonly string[]).includes(model.toLowerCase().trim());
+}
+function isOpus1mUnavailable(model: string): boolean {
+  const m = model.toLowerCase();
+  return !checkOpus1mAccess() && !isOpus1mMergeEnabled() && m.includes('opus') && m.includes('[1m]');
+}
+function isSonnet1mUnavailable(model: string): boolean {
+  const m = model.toLowerCase();
+  // Warn about Sonnet and Sonnet 4.6, but not Sonnet 4.5 since that had
+  // a different access criteria.
+  return !checkSonnet1mAccess() && (m.includes('sonnet[1m]') || m.includes('sonnet-4-6[1m]'));
+}
+function ShowModelAndClose(t0) {
+  const {
+    onDone
+  } = t0;
+  const mainLoopModel = useAppState(_temp7);
+  const mainLoopModelForSession = useAppState(_temp8);
+  const effortValue = useAppState(_temp9);
+  const displayModel = renderModelLabel(mainLoopModel);
+  const effortInfo = effortValue !== undefined ? ` (effort: ${effortValue})` : "";
+  if (mainLoopModelForSession) {
+    onDone(`Current model: ${chalk.bold(renderModelLabel(mainLoopModelForSession))} (session override from plan mode)\nBase model: ${displayModel}${effortInfo}`);
+  } else {
+    onDone(`Current model: ${displayModel}${effortInfo}`);
+  }
+  return null;
+}
+function _temp9(s_1) {
+  return s_1.effortValue;
+}
+function _temp8(s_0) {
+  return s_0.mainLoopModelForSession;
+}
+function _temp7(s) {
+  return s.mainLoopModel;
+}
+export const call: LocalJSXCommandCall = async (onDone, _context, args) => {
+  args = args?.trim() || '';
+  if (COMMON_INFO_ARGS.includes(args)) {
+    logEvent('tengu_model_command_inline_help', {
+      args: args as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    return <ShowModelAndClose onDone={onDone} />;
+  }
+  if (COMMON_HELP_ARGS.includes(args)) {
+    onDone('Run /model to open the model selection menu, or /model [modelName] to set the model.', {
+      display: 'system'
+    });
+    return;
+  }
+  if (args) {
+    logEvent('tengu_model_command_inline', {
+      args: args as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    return <SetModelAndClose args={args} onDone={onDone} />;
+  }
+  return <ModelPickerWrapper onDone={onDone} />;
+};
+function renderModelLabel(model: string | null): string {
+  const rendered = renderDefaultModelSetting(model ?? getDefaultMainLoopModelSetting());
+  return model === null ? `${rendered} (default)` : rendered;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","React","CommandResultDisplay","ModelPicker","COMMON_HELP_ARGS","COMMON_INFO_ARGS","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","useAppState","useSetAppState","LocalJSXCommandCall","EffortLevel","isBilledAsExtraUsage","clearFastModeCooldown","isFastModeAvailable","isFastModeEnabled","isFastModeSupportedByModel","MODEL_ALIASES","checkOpus1mAccess","checkSonnet1mAccess","getDefaultMainLoopModelSetting","isOpus1mMergeEnabled","renderDefaultModelSetting","isModelAllowed","validateModel","ModelPickerWrapper","t0","$","_c","onDone","mainLoopModel","_temp","mainLoopModelForSession","_temp2","isFastMode","_temp3","setAppState","t1","handleCancel","action","displayModel","renderModelLabel","bold","display","t2","handleSelect","model","effort","from_model","to_model","prev","message","undefined","wasFastModeToggledOn","_temp4","t3","t4","prev_0","fastMode","s_1","s","s_0","SetModelAndClose","args","result","options","ReactNode","useEffect","handleModelChange","Promise","isOpus1mUnavailable","isSonnet1mUnavailable","setModel","isKnownAlias","valid","error","Error","modelValue","includes","toLowerCase","trim","m","ShowModelAndClose","_temp7","_temp8","effortValue","_temp9","effortInfo","call","_context","rendered"],"sources":["model.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport * as React from 'react'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport { ModelPicker } from '../../components/ModelPicker.js'\nimport { COMMON_HELP_ARGS, COMMON_INFO_ARGS } from '../../constants/xml.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { useAppState, useSetAppState } from '../../state/AppState.js'\nimport type { LocalJSXCommandCall } from '../../types/command.js'\nimport type { EffortLevel } from '../../utils/effort.js'\nimport { isBilledAsExtraUsage } from '../../utils/extraUsage.js'\nimport {\n  clearFastModeCooldown,\n  isFastModeAvailable,\n  isFastModeEnabled,\n  isFastModeSupportedByModel,\n} from '../../utils/fastMode.js'\nimport { MODEL_ALIASES } from '../../utils/model/aliases.js'\nimport {\n  checkOpus1mAccess,\n  checkSonnet1mAccess,\n} from '../../utils/model/check1mAccess.js'\nimport {\n  getDefaultMainLoopModelSetting,\n  isOpus1mMergeEnabled,\n  renderDefaultModelSetting,\n} from '../../utils/model/model.js'\nimport { isModelAllowed } from '../../utils/model/modelAllowlist.js'\nimport { validateModel } from '../../utils/model/validateModel.js'\n\nfunction ModelPickerWrapper({\n  onDone,\n}: {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}): React.ReactNode {\n  const mainLoopModel = useAppState(s => s.mainLoopModel)\n  const mainLoopModelForSession = useAppState(s => s.mainLoopModelForSession)\n  const isFastMode = useAppState(s => s.fastMode)\n  const setAppState = useSetAppState()\n\n  function handleCancel(): void {\n    logEvent('tengu_model_command_menu', {\n      action:\n        'cancel' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    const displayModel = renderModelLabel(mainLoopModel)\n    onDone(`Kept model as ${chalk.bold(displayModel)}`, {\n      display: 'system',\n    })\n  }\n\n  function handleSelect(\n    model: string | null,\n    effort: EffortLevel | undefined,\n  ): void {\n    logEvent('tengu_model_command_menu', {\n      action:\n        model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      from_model:\n        mainLoopModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      to_model:\n        model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    setAppState(prev => ({\n      ...prev,\n      mainLoopModel: model,\n      mainLoopModelForSession: null,\n    }))\n\n    let message = `Set model to ${chalk.bold(renderModelLabel(model))}`\n    if (effort !== undefined) {\n      message += ` with ${chalk.bold(effort)} effort`\n    }\n\n    // Turn off fast mode if switching to unsupported model\n    let wasFastModeToggledOn = undefined\n    if (isFastModeEnabled()) {\n      clearFastModeCooldown()\n      if (!isFastModeSupportedByModel(model) && isFastMode) {\n        setAppState(prev => ({\n          ...prev,\n          fastMode: false,\n        }))\n        wasFastModeToggledOn = false\n        // Do not update fast mode in settings since this is an automatic downgrade\n      } else if (\n        isFastModeSupportedByModel(model) &&\n        isFastModeAvailable() &&\n        isFastMode\n      ) {\n        message += ` · Fast mode ON`\n        wasFastModeToggledOn = true\n      }\n    }\n\n    if (\n      isBilledAsExtraUsage(\n        model,\n        wasFastModeToggledOn === true,\n        isOpus1mMergeEnabled(),\n      )\n    ) {\n      message += ` · Billed as extra usage`\n    }\n\n    if (wasFastModeToggledOn === false) {\n      // Fast mode was toggled off, show suffix after extra usage billing\n      message += ` · Fast mode OFF`\n    }\n\n    onDone(message)\n  }\n\n  return (\n    <ModelPicker\n      initial={mainLoopModel}\n      sessionModel={mainLoopModelForSession}\n      onSelect={handleSelect}\n      onCancel={handleCancel}\n      isStandaloneCommand\n      showFastModeNotice={\n        isFastModeEnabled() &&\n        isFastMode &&\n        isFastModeSupportedByModel(mainLoopModel) &&\n        isFastModeAvailable()\n      }\n    />\n  )\n}\n\nfunction SetModelAndClose({\n  args,\n  onDone,\n}: {\n  args: string\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}): React.ReactNode {\n  const isFastMode = useAppState(s => s.fastMode)\n  const setAppState = useSetAppState()\n  const model = args === 'default' ? null : args\n\n  React.useEffect(() => {\n    async function handleModelChange(): Promise<void> {\n      if (model && !isModelAllowed(model)) {\n        onDone(\n          `Model '${model}' is not available. Your organization restricts model selection.`,\n          { display: 'system' },\n        )\n        return\n      }\n\n      // @[MODEL LAUNCH]: Update check for 1M access.\n      if (model && isOpus1mUnavailable(model)) {\n        onDone(\n          `Opus 4.6 with 1M context is not available for your account. Learn more: https://code.claude.com/docs/en/model-config#extended-context-with-1m`,\n          { display: 'system' },\n        )\n        return\n      }\n\n      if (model && isSonnet1mUnavailable(model)) {\n        onDone(\n          `Sonnet 4.6 with 1M context is not available for your account. Learn more: https://code.claude.com/docs/en/model-config#extended-context-with-1m`,\n          { display: 'system' },\n        )\n        return\n      }\n\n      // Skip validation for default model\n      if (!model) {\n        setModel(null)\n        return\n      }\n\n      // Skip validation for known aliases - they're predefined and should work\n      if (isKnownAlias(model)) {\n        setModel(model)\n        return\n      }\n\n      // Validate and set custom model\n      try {\n        // Don't use parseUserSpecifiedModel for non-aliases since it lowercases the input\n        // and model names are case-sensitive\n        const { valid, error } = await validateModel(model)\n\n        if (valid) {\n          setModel(model)\n        } else {\n          onDone(error || `Model '${model}' not found`, {\n            display: 'system',\n          })\n        }\n      } catch (error) {\n        onDone(`Failed to validate model: ${(error as Error).message}`, {\n          display: 'system',\n        })\n      }\n    }\n\n    function setModel(modelValue: string | null): void {\n      setAppState(prev => ({\n        ...prev,\n        mainLoopModel: modelValue,\n        mainLoopModelForSession: null,\n      }))\n      let message = `Set model to ${chalk.bold(renderModelLabel(modelValue))}`\n\n      let wasFastModeToggledOn = undefined\n      if (isFastModeEnabled()) {\n        clearFastModeCooldown()\n        if (!isFastModeSupportedByModel(modelValue) && isFastMode) {\n          setAppState(prev => ({\n            ...prev,\n            fastMode: false,\n          }))\n          wasFastModeToggledOn = false\n          // Do not update fast mode in settings since this is an automatic downgrade\n        } else if (isFastModeSupportedByModel(modelValue) && isFastMode) {\n          message += ` · Fast mode ON`\n          wasFastModeToggledOn = true\n        }\n      }\n\n      if (\n        isBilledAsExtraUsage(\n          modelValue,\n          wasFastModeToggledOn === true,\n          isOpus1mMergeEnabled(),\n        )\n      ) {\n        message += ` · Billed as extra usage`\n      }\n\n      if (wasFastModeToggledOn === false) {\n        // Fast mode was toggled off, show suffix after extra usage billing\n        message += ` · Fast mode OFF`\n      }\n\n      onDone(message)\n    }\n\n    void handleModelChange()\n  }, [model, onDone, setAppState])\n\n  return null\n}\n\nfunction isKnownAlias(model: string): boolean {\n  return (MODEL_ALIASES as readonly string[]).includes(\n    model.toLowerCase().trim(),\n  )\n}\n\nfunction isOpus1mUnavailable(model: string): boolean {\n  const m = model.toLowerCase()\n  return (\n    !checkOpus1mAccess() &&\n    !isOpus1mMergeEnabled() &&\n    m.includes('opus') &&\n    m.includes('[1m]')\n  )\n}\n\nfunction isSonnet1mUnavailable(model: string): boolean {\n  const m = model.toLowerCase()\n  // Warn about Sonnet and Sonnet 4.6, but not Sonnet 4.5 since that had\n  // a different access criteria.\n  return (\n    !checkSonnet1mAccess() &&\n    (m.includes('sonnet[1m]') || m.includes('sonnet-4-6[1m]'))\n  )\n}\n\nfunction ShowModelAndClose({\n  onDone,\n}: {\n  onDone: (result?: string) => void\n}): React.ReactNode {\n  const mainLoopModel = useAppState(s => s.mainLoopModel)\n  const mainLoopModelForSession = useAppState(s => s.mainLoopModelForSession)\n  const effortValue = useAppState(s => s.effortValue)\n  const displayModel = renderModelLabel(mainLoopModel)\n  const effortInfo =\n    effortValue !== undefined ? ` (effort: ${effortValue})` : ''\n\n  if (mainLoopModelForSession) {\n    onDone(\n      `Current model: ${chalk.bold(renderModelLabel(mainLoopModelForSession))} (session override from plan mode)\\nBase model: ${displayModel}${effortInfo}`,\n    )\n  } else {\n    onDone(`Current model: ${displayModel}${effortInfo}`)\n  }\n\n  return null\n}\n\nexport const call: LocalJSXCommandCall = async (onDone, _context, args) => {\n  args = args?.trim() || ''\n  if (COMMON_INFO_ARGS.includes(args)) {\n    logEvent('tengu_model_command_inline_help', {\n      args: args as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    return <ShowModelAndClose onDone={onDone} />\n  }\n  if (COMMON_HELP_ARGS.includes(args)) {\n    onDone(\n      'Run /model to open the model selection menu, or /model [modelName] to set the model.',\n      { display: 'system' },\n    )\n    return\n  }\n\n  if (args) {\n    logEvent('tengu_model_command_inline', {\n      args: args as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    return <SetModelAndClose args={args} onDone={onDone} />\n  }\n\n  return <ModelPickerWrapper onDone={onDone} />\n}\n\nfunction renderModelLabel(model: string | null): string {\n  const rendered = renderDefaultModelSetting(\n    model ?? getDefaultMainLoopModelSetting(),\n  )\n  return model === null ? `${rendered} (default)` : rendered\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/oauth-refresh/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/onboarding/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/output-style/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const outputStyle = {
+  type: 'local-jsx',
+  name: 'output-style',
+  description: 'Deprecated: use /config to change output style',
+  isHidden: true,
+  load: () => import('./output-style.js'),
+} satisfies Command
+
+export default outputStyle

src/commands/output-style/output-style.tsx

@@ -0,0 +1,7 @@
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+export async function call(onDone: LocalJSXCommandOnDone): Promise<undefined> {
+  onDone('/output-style has been deprecated. Use /config to change your output style, or set it in your settings file. Changes take effect on the next session.', {
+    display: 'system'
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJMb2NhbEpTWENvbW1hbmRPbkRvbmUiLCJjYWxsIiwib25Eb25lIiwiUHJvbWlzZSIsImRpc3BsYXkiXSwic291cmNlcyI6WyJvdXRwdXQtc3R5bGUudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTG9jYWxKU1hDb21tYW5kT25Eb25lIH0gZnJvbSAnLi4vLi4vdHlwZXMvY29tbWFuZC5qcydcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGNhbGwob25Eb25lOiBMb2NhbEpTWENvbW1hbmRPbkRvbmUpOiBQcm9taXNlPHVuZGVmaW5lZD4ge1xuICBvbkRvbmUoXG4gICAgJy9vdXRwdXQtc3R5bGUgaGFzIGJlZW4gZGVwcmVjYXRlZC4gVXNlIC9jb25maWcgdG8gY2hhbmdlIHlvdXIgb3V0cHV0IHN0eWxlLCBvciBzZXQgaXQgaW4geW91ciBzZXR0aW5ncyBmaWxlLiBDaGFuZ2VzIHRha2UgZWZmZWN0IG9uIHRoZSBuZXh0IHNlc3Npb24uJyxcbiAgICB7IGRpc3BsYXk6ICdzeXN0ZW0nIH0sXG4gIClcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsY0FBY0EscUJBQXFCLFFBQVEsd0JBQXdCO0FBRW5FLE9BQU8sZUFBZUMsSUFBSUEsQ0FBQ0MsTUFBTSxFQUFFRixxQkFBcUIsQ0FBQyxFQUFFRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7RUFDNUVELE1BQU0sQ0FDSix1SkFBdUosRUFDdko7SUFBRUUsT0FBTyxFQUFFO0VBQVMsQ0FDdEIsQ0FBQztBQUNIIiwiaWdub3JlTGlzdCI6W119

src/commands/passes/index.ts

@@ -0,0 +1,22 @@
+import type { Command } from '../../commands.js'
+import {
+  checkCachedPassesEligibility,
+  getCachedReferrerReward,
+} from '../../services/api/referral.js'
+
+export default {
+  type: 'local-jsx',
+  name: 'passes',
+  get description() {
+    const reward = getCachedReferrerReward()
+    if (reward) {
+      return 'Share a free week of Claude Code with friends and earn extra usage'
+    }
+    return 'Share a free week of Claude Code with friends'
+  },
+  get isHidden() {
+    const { eligible, hasCache } = checkCachedPassesEligibility()
+    return !eligible || !hasCache
+  },
+  load: () => import('./passes.js'),
+} satisfies Command

src/commands/passes/passes.tsx

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { Passes } from '../../components/Passes/Passes.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { getCachedRemainingPasses } from '../../services/api/referral.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+export async function call(onDone: LocalJSXCommandOnDone): Promise<React.ReactNode> {
+  // Mark that user has visited /passes so we stop showing the upsell
+  const config = getGlobalConfig();
+  const isFirstVisit = !config.hasVisitedPasses;
+  if (isFirstVisit) {
+    const remaining = getCachedRemainingPasses();
+    saveGlobalConfig(current => ({
+      ...current,
+      hasVisitedPasses: true,
+      passesLastSeenRemaining: remaining ?? current.passesLastSeenRemaining
+    }));
+  }
+  logEvent('tengu_guest_passes_visited', {
+    is_first_visit: isFirstVisit
+  });
+  return <Passes onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/commands/perf-issue/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

src/commands/permissions/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const permissions = {
+  type: 'local-jsx',
+  name: 'permissions',
+  aliases: ['allowed-tools'],
+  description: 'Manage allow & deny tool permission rules',
+  load: () => import('./permissions.js'),
+} satisfies Command
+
+export default permissions

src/commands/permissions/permissions.tsx

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { PermissionRuleList } from '../../components/permissions/rules/PermissionRuleList.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+import { createPermissionRetryMessage } from '../../utils/messages.js';
+export const call: LocalJSXCommandCall = async (onDone, context) => {
+  return <PermissionRuleList onExit={onDone} onRetryDenials={commands => {
+    context.setMessages(prev => [...prev, createPermissionRetryMessage(commands)]);
+  }} />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlBlcm1pc3Npb25SdWxlTGlzdCIsIkxvY2FsSlNYQ29tbWFuZENhbGwiLCJjcmVhdGVQZXJtaXNzaW9uUmV0cnlNZXNzYWdlIiwiY2FsbCIsIm9uRG9uZSIsImNvbnRleHQiLCJjb21tYW5kcyIsInNldE1lc3NhZ2VzIiwicHJldiJdLCJzb3VyY2VzIjpbInBlcm1pc3Npb25zLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tICdyZWFjdCdcbmltcG9ydCB7IFBlcm1pc3Npb25SdWxlTGlzdCB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvcGVybWlzc2lvbnMvcnVsZXMvUGVybWlzc2lvblJ1bGVMaXN0LmpzJ1xuaW1wb3J0IHR5cGUgeyBMb2NhbEpTWENvbW1hbmRDYWxsIH0gZnJvbSAnLi4vLi4vdHlwZXMvY29tbWFuZC5qcydcbmltcG9ydCB7IGNyZWF0ZVBlcm1pc3Npb25SZXRyeU1lc3NhZ2UgfSBmcm9tICcuLi8uLi91dGlscy9tZXNzYWdlcy5qcydcblxuZXhwb3J0IGNvbnN0IGNhbGw6IExvY2FsSlNYQ29tbWFuZENhbGwgPSBhc3luYyAob25Eb25lLCBjb250ZXh0KSA9PiB7XG4gIHJldHVybiAoXG4gICAgPFBlcm1pc3Npb25SdWxlTGlzdFxuICAgICAgb25FeGl0PXtvbkRvbmV9XG4gICAgICBvblJldHJ5RGVuaWFscz17Y29tbWFuZHMgPT4ge1xuICAgICAgICBjb250ZXh0LnNldE1lc3NhZ2VzKHByZXYgPT4gW1xuICAgICAgICAgIC4uLnByZXYsXG4gICAgICAgICAgY3JlYXRlUGVybWlzc2lvblJldHJ5TWVzc2FnZShjb21tYW5kcyksXG4gICAgICAgIF0pXG4gICAgICB9fVxuICAgIC8+XG4gIClcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLQSxLQUFLLE1BQU0sT0FBTztBQUM5QixTQUFTQyxrQkFBa0IsUUFBUSwwREFBMEQ7QUFDN0YsY0FBY0MsbUJBQW1CLFFBQVEsd0JBQXdCO0FBQ2pFLFNBQVNDLDRCQUE0QixRQUFRLHlCQUF5QjtBQUV0RSxPQUFPLE1BQU1DLElBQUksRUFBRUYsbUJBQW1CLEdBQUcsTUFBQUUsQ0FBT0MsTUFBTSxFQUFFQyxPQUFPLEtBQUs7RUFDbEUsT0FDRSxDQUFDLGtCQUFrQixDQUNqQixNQUFNLENBQUMsQ0FBQ0QsTUFBTSxDQUFDLENBQ2YsY0FBYyxDQUFDLENBQUNFLFFBQVEsSUFBSTtJQUMxQkQsT0FBTyxDQUFDRSxXQUFXLENBQUNDLElBQUksSUFBSSxDQUMxQixHQUFHQSxJQUFJLEVBQ1BOLDRCQUE0QixDQUFDSSxRQUFRLENBQUMsQ0FDdkMsQ0FBQztFQUNKLENBQUMsQ0FBQyxHQUNGO0FBRU4sQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

src/commands/plan/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const plan = {
+  type: 'local-jsx',
+  name: 'plan',
+  description: 'Enable plan mode or view the current session plan',
+  argumentHint: '[open|<description>]',
+  load: () => import('./plan.js'),
+} satisfies Command
+
+export default plan

src/commands/plan/plan.tsx

@@ -0,0 +1,122 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { handlePlanModeTransition } from '../../bootstrap/state.js';
+import type { LocalJSXCommandContext } from '../../commands.js';
+import { Box, Text } from '../../ink.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { getExternalEditor } from '../../utils/editor.js';
+import { toIDEDisplayName } from '../../utils/ide.js';
+import { applyPermissionUpdate } from '../../utils/permissions/PermissionUpdate.js';
+import { prepareContextForPlanMode } from '../../utils/permissions/permissionSetup.js';
+import { getPlan, getPlanFilePath } from '../../utils/plans.js';
+import { editFileInEditor } from '../../utils/promptEditor.js';
+import { renderToString } from '../../utils/staticRender.js';
+function PlanDisplay(t0) {
+  const $ = _c(11);
+  const {
+    planContent,
+    planPath,
+    editorName
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <Text bold={true}>Current Plan</Text>;
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  let t2;
+  if ($[1] !== planPath) {
+    t2 = <Text dimColor={true}>{planPath}</Text>;
+    $[1] = planPath;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] !== planContent) {
+    t3 = <Box marginTop={1}><Text>{planContent}</Text></Box>;
+    $[3] = planContent;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== editorName) {
+    t4 = editorName && <Box marginTop={1}><Text dimColor={true}>"/plan open"</Text><Text dimColor={true}> to edit this plan in </Text><Text bold={true} dimColor={true}>{editorName}</Text></Box>;
+    $[5] = editorName;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] !== t2 || $[8] !== t3 || $[9] !== t4) {
+    t5 = <Box flexDirection="column">{t1}{t2}{t3}{t4}</Box>;
+    $[7] = t2;
+    $[8] = t3;
+    $[9] = t4;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  return t5;
+}
+export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext, args: string): Promise<React.ReactNode> {
+  const {
+    getAppState,
+    setAppState
+  } = context;
+  const appState = getAppState();
+  const currentMode = appState.toolPermissionContext.mode;
+
+  // If not in plan mode, enable it
+  if (currentMode !== 'plan') {
+    handlePlanModeTransition(currentMode, 'plan');
+    setAppState(prev => ({
+      ...prev,
+      toolPermissionContext: applyPermissionUpdate(prepareContextForPlanMode(prev.toolPermissionContext), {
+        type: 'setMode',
+        mode: 'plan',
+        destination: 'session'
+      })
+    }));
+    const description = args.trim();
+    if (description && description !== 'open') {
+      onDone('Enabled plan mode', {
+        shouldQuery: true
+      });
+    } else {
+      onDone('Enabled plan mode');
+    }
+    return null;
+  }
+
+  // Already in plan mode - show the current plan
+  const planContent = getPlan();
+  const planPath = getPlanFilePath();
+  if (!planContent) {
+    onDone('Already in plan mode. No plan written yet.');
+    return null;
+  }
+
+  // If user typed "/plan open", open in editor
+  const argList = args.trim().split(/\s+/);
+  if (argList[0] === 'open') {
+    const result = await editFileInEditor(planPath);
+    if (result.error) {
+      onDone(`Failed to open plan in editor: ${result.error}`);
+    } else {
+      onDone(`Opened plan in editor: ${planPath}`);
+    }
+    return null;
+  }
+  const editor = getExternalEditor();
+  const editorName = editor ? toIDEDisplayName(editor) : undefined;
+  const display = <PlanDisplay planContent={planContent} planPath={planPath} editorName={editorName} />;
+
+  // Render to string and pass to onDone like local commands do
+  const output = await renderToString(display);
+  onDone(output);
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","handlePlanModeTransition","LocalJSXCommandContext","Box","Text","LocalJSXCommandOnDone","getExternalEditor","toIDEDisplayName","applyPermissionUpdate","prepareContextForPlanMode","getPlan","getPlanFilePath","editFileInEditor","renderToString","PlanDisplay","t0","$","_c","planContent","planPath","editorName","t1","Symbol","for","t2","t3","t4","t5","call","onDone","context","args","Promise","ReactNode","getAppState","setAppState","appState","currentMode","toolPermissionContext","mode","prev","type","destination","description","trim","shouldQuery","argList","split","result","error","editor","undefined","display","output"],"sources":["plan.tsx"],"sourcesContent":["import * as React from 'react'\nimport { handlePlanModeTransition } from '../../bootstrap/state.js'\nimport type { LocalJSXCommandContext } from '../../commands.js'\nimport { Box, Text } from '../../ink.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { getExternalEditor } from '../../utils/editor.js'\nimport { toIDEDisplayName } from '../../utils/ide.js'\nimport { applyPermissionUpdate } from '../../utils/permissions/PermissionUpdate.js'\nimport { prepareContextForPlanMode } from '../../utils/permissions/permissionSetup.js'\nimport { getPlan, getPlanFilePath } from '../../utils/plans.js'\nimport { editFileInEditor } from '../../utils/promptEditor.js'\nimport { renderToString } from '../../utils/staticRender.js'\n\nfunction PlanDisplay({\n  planContent,\n  planPath,\n  editorName,\n}: {\n  planContent: string\n  planPath: string\n  editorName: string | undefined\n}): React.ReactNode {\n  return (\n    <Box flexDirection=\"column\">\n      <Text bold>Current Plan</Text>\n      <Text dimColor>{planPath}</Text>\n      <Box marginTop={1}>\n        <Text>{planContent}</Text>\n      </Box>\n      {editorName && (\n        <Box marginTop={1}>\n          <Text dimColor>&quot;/plan open&quot;</Text>\n          <Text dimColor> to edit this plan in </Text>\n          <Text bold dimColor>\n            {editorName}\n          </Text>\n        </Box>\n      )}\n    </Box>\n  )\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: LocalJSXCommandContext,\n  args: string,\n): Promise<React.ReactNode> {\n  const { getAppState, setAppState } = context\n  const appState = getAppState()\n  const currentMode = appState.toolPermissionContext.mode\n\n  // If not in plan mode, enable it\n  if (currentMode !== 'plan') {\n    handlePlanModeTransition(currentMode, 'plan')\n    setAppState(prev => ({\n      ...prev,\n      toolPermissionContext: applyPermissionUpdate(\n        prepareContextForPlanMode(prev.toolPermissionContext),\n        { type: 'setMode', mode: 'plan', destination: 'session' },\n      ),\n    }))\n    const description = args.trim()\n    if (description && description !== 'open') {\n      onDone('Enabled plan mode', { shouldQuery: true })\n    } else {\n      onDone('Enabled plan mode')\n    }\n    return null\n  }\n\n  // Already in plan mode - show the current plan\n  const planContent = getPlan()\n  const planPath = getPlanFilePath()\n\n  if (!planContent) {\n    onDone('Already in plan mode. No plan written yet.')\n    return null\n  }\n\n  // If user typed \"/plan open\", open in editor\n  const argList = args.trim().split(/\\s+/)\n  if (argList[0] === 'open') {\n    const result = await editFileInEditor(planPath)\n    if (result.error) {\n      onDone(`Failed to open plan in editor: ${result.error}`)\n    } else {\n      onDone(`Opened plan in editor: ${planPath}`)\n    }\n    return null\n  }\n\n  const editor = getExternalEditor()\n  const editorName = editor ? toIDEDisplayName(editor) : undefined\n\n  const display = (\n    <PlanDisplay\n      planContent={planContent}\n      planPath={planPath}\n      editorName={editorName}\n    />\n  )\n\n  // Render to string and pass to onDone like local commands do\n  const output = await renderToString(display)\n  onDone(output)\n  return null\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/plugin/AddMarketplace.tsx

@@ -0,0 +1,162 @@
+import * as React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js';
+import { Byline } from '../../components/design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+import { Spinner } from '../../components/Spinner.js';
+import TextInput from '../../components/TextInput.js';
+import { Box, Text } from '../../ink.js';
+import { toError } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { clearAllCaches } from '../../utils/plugins/cacheUtils.js';
+import { addMarketplaceSource, saveMarketplaceToSettings } from '../../utils/plugins/marketplaceManager.js';
+import { parseMarketplaceInput } from '../../utils/plugins/parseMarketplaceInput.js';
+import type { ViewState } from './types.js';
+type Props = {
+  inputValue: string;
+  setInputValue: (value: string) => void;
+  cursorOffset: number;
+  setCursorOffset: (offset: number) => void;
+  error: string | null;
+  setError: (error: string | null) => void;
+  result: string | null;
+  setResult: (result: string | null) => void;
+  setViewState: (state: ViewState) => void;
+  onAddComplete?: () => void | Promise<void>;
+  cliMode?: boolean;
+};
+export function AddMarketplace({
+  inputValue,
+  setInputValue,
+  cursorOffset,
+  setCursorOffset,
+  error,
+  setError,
+  result,
+  setResult,
+  setViewState,
+  onAddComplete,
+  cliMode = false
+}: Props): React.ReactNode {
+  const hasAttemptedAutoAdd = useRef(false);
+  const [isLoading, setLoading] = useState(false);
+  const [progressMessage, setProgressMessage] = useState<string>('');
+  const handleAdd = async () => {
+    const input = inputValue.trim();
+    if (!input) {
+      setError('Please enter a marketplace source');
+      return;
+    }
+    const parsed = await parseMarketplaceInput(input);
+    if (!parsed) {
+      setError('Invalid marketplace source format. Try: owner/repo, https://..., or ./path');
+      return;
+    }
+
+    // Check if parseMarketplaceInput returned an error
+    if ('error' in parsed) {
+      setError(parsed.error);
+      return;
+    }
+    setError(null);
+    try {
+      setLoading(true);
+      setProgressMessage('');
+      const {
+        name,
+        resolvedSource
+      } = await addMarketplaceSource(parsed, message => {
+        setProgressMessage(message);
+      });
+      saveMarketplaceToSettings(name, {
+        source: resolvedSource
+      });
+      clearAllCaches();
+      let sourceType = parsed.source;
+      if (parsed.source === 'github') {
+        sourceType = parsed.repo as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
+      }
+      logEvent('tengu_marketplace_added', {
+        source_type: sourceType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+      if (onAddComplete) {
+        await onAddComplete();
+      }
+      setProgressMessage('');
+      setLoading(false);
+      if (cliMode) {
+        // In CLI mode, set result to trigger completion
+        setResult(`Successfully added marketplace: ${name}`);
+      } else {
+        // In interactive mode, switch to browse view
+        setViewState({
+          type: 'browse-marketplace',
+          targetMarketplace: name
+        });
+      }
+    } catch (err) {
+      const error = toError(err);
+      logError(error);
+      setError(error.message);
+      setProgressMessage('');
+      setLoading(false);
+      if (cliMode) {
+        // In CLI mode, set result with error to trigger completion
+        setResult(`Error: ${error.message}`);
+      } else {
+        setResult(null);
+      }
+    }
+  };
+
+  // Auto-add if inputValue is provided
+  useEffect(() => {
+    if (inputValue && !hasAttemptedAutoAdd.current && !error && !result) {
+      hasAttemptedAutoAdd.current = true;
+      void handleAdd();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional
+  }, []); // Only run once on mount
+
+  return <Box flexDirection="column">
+      <Box flexDirection="column" paddingX={1} borderStyle="round">
+        <Box marginBottom={1}>
+          <Text bold>Add Marketplace</Text>
+        </Box>
+        <Box flexDirection="column">
+          <Text>Enter marketplace source:</Text>
+          <Text dimColor>Examples:</Text>
+          <Text dimColor> · owner/repo (GitHub)</Text>
+          <Text dimColor> · git@github.com:owner/repo.git (SSH)</Text>
+          <Text dimColor> · https://example.com/marketplace.json</Text>
+          <Text dimColor> · ./path/to/marketplace</Text>
+          <Box marginTop={1}>
+            <TextInput value={inputValue} onChange={setInputValue} onSubmit={handleAdd} columns={80} cursorOffset={cursorOffset} onChangeCursorOffset={setCursorOffset} focus showCursor />
+          </Box>
+        </Box>
+        {isLoading && <Box marginTop={1}>
+            <Spinner />
+            <Text>
+              {progressMessage || 'Adding marketplace to configuration…'}
+            </Text>
+          </Box>}
+        {error && <Box marginTop={1}>
+            <Text color="error">{error}</Text>
+          </Box>}
+        {result && <Box marginTop={1}>
+            <Text>{result}</Text>
+          </Box>}
+      </Box>
+      <Box marginLeft={3}>
+        <Text dimColor italic>
+          <Byline>
+            <KeyboardShortcutHint shortcut="Enter" action="add" />
+            <ConfigurableShortcutHint action="confirm:no" context="Settings" fallback="Esc" description="cancel" />
+          </Byline>
+        </Text>
+      </Box>
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","ConfigurableShortcutHint","Byline","KeyboardShortcutHint","Spinner","TextInput","Box","Text","toError","logError","clearAllCaches","addMarketplaceSource","saveMarketplaceToSettings","parseMarketplaceInput","ViewState","Props","inputValue","setInputValue","value","cursorOffset","setCursorOffset","offset","error","setError","result","setResult","setViewState","state","onAddComplete","Promise","cliMode","AddMarketplace","ReactNode","hasAttemptedAutoAdd","isLoading","setLoading","progressMessage","setProgressMessage","handleAdd","input","trim","parsed","name","resolvedSource","message","source","sourceType","repo","source_type","type","targetMarketplace","err","current"],"sources":["AddMarketplace.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useRef, useState } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\nimport { Spinner } from '../../components/Spinner.js'\nimport TextInput from '../../components/TextInput.js'\nimport { Box, Text } from '../../ink.js'\nimport { toError } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport {\n  addMarketplaceSource,\n  saveMarketplaceToSettings,\n} from '../../utils/plugins/marketplaceManager.js'\nimport { parseMarketplaceInput } from '../../utils/plugins/parseMarketplaceInput.js'\nimport type { ViewState } from './types.js'\n\ntype Props = {\n  inputValue: string\n  setInputValue: (value: string) => void\n  cursorOffset: number\n  setCursorOffset: (offset: number) => void\n  error: string | null\n  setError: (error: string | null) => void\n  result: string | null\n  setResult: (result: string | null) => void\n  setViewState: (state: ViewState) => void\n  onAddComplete?: () => void | Promise<void>\n  cliMode?: boolean\n}\n\nexport function AddMarketplace({\n  inputValue,\n  setInputValue,\n  cursorOffset,\n  setCursorOffset,\n  error,\n  setError,\n  result,\n  setResult,\n  setViewState,\n  onAddComplete,\n  cliMode = false,\n}: Props): React.ReactNode {\n  const hasAttemptedAutoAdd = useRef(false)\n  const [isLoading, setLoading] = useState(false)\n  const [progressMessage, setProgressMessage] = useState<string>('')\n\n  const handleAdd = async () => {\n    const input = inputValue.trim()\n    if (!input) {\n      setError('Please enter a marketplace source')\n      return\n    }\n\n    const parsed = await parseMarketplaceInput(input)\n    if (!parsed) {\n      setError(\n        'Invalid marketplace source format. Try: owner/repo, https://..., or ./path',\n      )\n      return\n    }\n\n    // Check if parseMarketplaceInput returned an error\n    if ('error' in parsed) {\n      setError(parsed.error)\n      return\n    }\n\n    setError(null)\n\n    try {\n      setLoading(true)\n      setProgressMessage('')\n      const { name, resolvedSource } = await addMarketplaceSource(\n        parsed,\n        message => {\n          setProgressMessage(message)\n        },\n      )\n      saveMarketplaceToSettings(name, { source: resolvedSource })\n      clearAllCaches()\n\n      let sourceType = parsed.source\n      if (parsed.source === 'github') {\n        sourceType =\n          parsed.repo as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n      }\n\n      logEvent('tengu_marketplace_added', {\n        source_type:\n          sourceType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      if (onAddComplete) {\n        await onAddComplete()\n      }\n\n      setProgressMessage('')\n      setLoading(false)\n\n      if (cliMode) {\n        // In CLI mode, set result to trigger completion\n        setResult(`Successfully added marketplace: ${name}`)\n      } else {\n        // In interactive mode, switch to browse view\n        setViewState({ type: 'browse-marketplace', targetMarketplace: name })\n      }\n    } catch (err) {\n      const error = toError(err)\n      logError(error)\n      setError(error.message)\n      setProgressMessage('')\n      setLoading(false)\n\n      if (cliMode) {\n        // In CLI mode, set result with error to trigger completion\n        setResult(`Error: ${error.message}`)\n      } else {\n        setResult(null)\n      }\n    }\n  }\n\n  // Auto-add if inputValue is provided\n  useEffect(() => {\n    if (inputValue && !hasAttemptedAutoAdd.current && !error && !result) {\n      hasAttemptedAutoAdd.current = true\n      void handleAdd()\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  }, []) // Only run once on mount\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box flexDirection=\"column\" paddingX={1} borderStyle=\"round\">\n        <Box marginBottom={1}>\n          <Text bold>Add Marketplace</Text>\n        </Box>\n        <Box flexDirection=\"column\">\n          <Text>Enter marketplace source:</Text>\n          <Text dimColor>Examples:</Text>\n          <Text dimColor> · owner/repo (GitHub)</Text>\n          <Text dimColor> · git@github.com:owner/repo.git (SSH)</Text>\n          <Text dimColor> · https://example.com/marketplace.json</Text>\n          <Text dimColor> · ./path/to/marketplace</Text>\n          <Box marginTop={1}>\n            <TextInput\n              value={inputValue}\n              onChange={setInputValue}\n              onSubmit={handleAdd}\n              columns={80}\n              cursorOffset={cursorOffset}\n              onChangeCursorOffset={setCursorOffset}\n              focus\n              showCursor\n            />\n          </Box>\n        </Box>\n        {isLoading && (\n          <Box marginTop={1}>\n            <Spinner />\n            <Text>\n              {progressMessage || 'Adding marketplace to configuration…'}\n            </Text>\n          </Box>\n        )}\n        {error && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{error}</Text>\n          </Box>\n        )}\n        {result && (\n          <Box marginTop={1}>\n            <Text>{result}</Text>\n          </Box>\n        )}\n      </Box>\n      <Box marginLeft={3}>\n        <Text dimColor italic>\n          <Byline>\n            <KeyboardShortcutHint shortcut=\"Enter\" action=\"add\" />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Settings\"\n              fallback=\"Esc\"\n              description=\"cancel\"\n            />\n          </Byline>\n        </Text>\n      </Box>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/plugin/PluginErrors.tsx

@@ -0,0 +1,124 @@
+import { getPluginErrorMessage, type PluginError } from '../../types/plugin.js';
+export function formatErrorMessage(error: PluginError): string {
+  switch (error.type) {
+    case 'path-not-found':
+      return `${error.component} path not found: ${error.path}`;
+    case 'git-auth-failed':
+      return `Git ${error.authType.toUpperCase()} authentication failed for ${error.gitUrl}`;
+    case 'git-timeout':
+      return `Git ${error.operation} timed out for ${error.gitUrl}`;
+    case 'network-error':
+      return `Network error accessing ${error.url}${error.details ? `: ${error.details}` : ''}`;
+    case 'manifest-parse-error':
+      return `Failed to parse manifest at ${error.manifestPath}: ${error.parseError}`;
+    case 'manifest-validation-error':
+      return `Invalid manifest at ${error.manifestPath}: ${error.validationErrors.join(', ')}`;
+    case 'plugin-not-found':
+      return `Plugin "${error.pluginId}" not found in marketplace "${error.marketplace}"`;
+    case 'marketplace-not-found':
+      return `Marketplace "${error.marketplace}" not found`;
+    case 'marketplace-load-failed':
+      return `Failed to load marketplace "${error.marketplace}": ${error.reason}`;
+    case 'mcp-config-invalid':
+      return `Invalid MCP server config for "${error.serverName}": ${error.validationError}`;
+    case 'mcp-server-suppressed-duplicate':
+      {
+        const dup = error.duplicateOf.startsWith('plugin:') ? `server provided by plugin "${error.duplicateOf.split(':')[1] ?? '?'}"` : `already-configured "${error.duplicateOf}"`;
+        return `MCP server "${error.serverName}" skipped — same command/URL as ${dup}`;
+      }
+    case 'hook-load-failed':
+      return `Failed to load hooks from ${error.hookPath}: ${error.reason}`;
+    case 'component-load-failed':
+      return `Failed to load ${error.component} from ${error.path}: ${error.reason}`;
+    case 'mcpb-download-failed':
+      return `Failed to download MCPB from ${error.url}: ${error.reason}`;
+    case 'mcpb-extract-failed':
+      return `Failed to extract MCPB ${error.mcpbPath}: ${error.reason}`;
+    case 'mcpb-invalid-manifest':
+      return `MCPB manifest invalid at ${error.mcpbPath}: ${error.validationError}`;
+    case 'marketplace-blocked-by-policy':
+      return error.blockedByBlocklist ? `Marketplace "${error.marketplace}" is blocked by enterprise policy` : `Marketplace "${error.marketplace}" is not in the allowed marketplace list`;
+    case 'dependency-unsatisfied':
+      return error.reason === 'not-enabled' ? `Dependency "${error.dependency}" is disabled` : `Dependency "${error.dependency}" is not installed`;
+    case 'lsp-config-invalid':
+      return `Invalid LSP server config for "${error.serverName}": ${error.validationError}`;
+    case 'lsp-server-start-failed':
+      return `LSP server "${error.serverName}" failed to start: ${error.reason}`;
+    case 'lsp-server-crashed':
+      return error.signal ? `LSP server "${error.serverName}" crashed with signal ${error.signal}` : `LSP server "${error.serverName}" crashed with exit code ${error.exitCode ?? 'unknown'}`;
+    case 'lsp-request-timeout':
+      return `LSP server "${error.serverName}" timed out on ${error.method} after ${error.timeoutMs}ms`;
+    case 'lsp-request-failed':
+      return `LSP server "${error.serverName}" ${error.method} failed: ${error.error}`;
+    case 'plugin-cache-miss':
+      return `Plugin "${error.plugin}" not cached at ${error.installPath}`;
+    case 'generic-error':
+      return error.error;
+  }
+  const _exhaustive: never = error;
+  return getPluginErrorMessage(_exhaustive);
+}
+export function getErrorGuidance(error: PluginError): string | null {
+  switch (error.type) {
+    case 'path-not-found':
+      return 'Check that the path in your manifest or marketplace config is correct';
+    case 'git-auth-failed':
+      return error.authType === 'ssh' ? 'Configure SSH keys or use HTTPS URL instead' : 'Configure credentials or use SSH URL instead';
+    case 'git-timeout':
+    case 'network-error':
+      return 'Check your internet connection and try again';
+    case 'manifest-parse-error':
+      return 'Check manifest file syntax in the plugin directory';
+    case 'manifest-validation-error':
+      return 'Check manifest file follows the required schema';
+    case 'plugin-not-found':
+      return `Plugin may not exist in marketplace "${error.marketplace}"`;
+    case 'marketplace-not-found':
+      return error.availableMarketplaces.length > 0 ? `Available marketplaces: ${error.availableMarketplaces.join(', ')}` : 'Add the marketplace first using /plugin marketplace add';
+    case 'mcp-config-invalid':
+      return 'Check MCP server configuration in .mcp.json or manifest';
+    case 'mcp-server-suppressed-duplicate':
+      {
+        // duplicateOf is "plugin:name:srv" when another plugin won dedup —
+        // users can't remove plugin-provided servers from their MCP config,
+        // so point them at the winning plugin instead.
+        if (error.duplicateOf.startsWith('plugin:')) {
+          const winningPlugin = error.duplicateOf.split(':')[1] ?? 'the other plugin';
+          return `Disable plugin "${winningPlugin}" if you want this plugin's version instead`;
+        }
+        return `Remove "${error.duplicateOf}" from your MCP config if you want the plugin's version instead`;
+      }
+    case 'hook-load-failed':
+      return 'Check hooks.json file syntax and structure';
+    case 'component-load-failed':
+      return `Check ${error.component} directory structure and file permissions`;
+    case 'mcpb-download-failed':
+      return 'Check your internet connection and URL accessibility';
+    case 'mcpb-extract-failed':
+      return 'Verify the MCPB file is valid and not corrupted';
+    case 'mcpb-invalid-manifest':
+      return 'Contact the plugin author about the invalid manifest';
+    case 'marketplace-blocked-by-policy':
+      if (error.blockedByBlocklist) {
+        return 'This marketplace source is explicitly blocked by your administrator';
+      }
+      return error.allowedSources.length > 0 ? `Allowed sources: ${error.allowedSources.join(', ')}` : 'Contact your administrator to configure allowed marketplace sources';
+    case 'dependency-unsatisfied':
+      return error.reason === 'not-enabled' ? `Enable "${error.dependency}" or uninstall "${error.plugin}"` : `Install "${error.dependency}" or uninstall "${error.plugin}"`;
+    case 'lsp-config-invalid':
+      return 'Check LSP server configuration in the plugin manifest';
+    case 'lsp-server-start-failed':
+    case 'lsp-server-crashed':
+    case 'lsp-request-timeout':
+    case 'lsp-request-failed':
+      return 'Check LSP server logs with --debug for details';
+    case 'plugin-cache-miss':
+      return 'Run /plugins to refresh the plugin cache';
+    case 'marketplace-load-failed':
+    case 'generic-error':
+      return null;
+  }
+  const _exhaustive: never = error;
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getPluginErrorMessage","PluginError","formatErrorMessage","error","type","component","path","authType","toUpperCase","gitUrl","operation","url","details","manifestPath","parseError","validationErrors","join","pluginId","marketplace","reason","serverName","validationError","dup","duplicateOf","startsWith","split","hookPath","mcpbPath","blockedByBlocklist","dependency","signal","exitCode","method","timeoutMs","plugin","installPath","_exhaustive","getErrorGuidance","availableMarketplaces","length","winningPlugin","allowedSources"],"sources":["PluginErrors.tsx"],"sourcesContent":["import { getPluginErrorMessage, type PluginError } from '../../types/plugin.js'\n\nexport function formatErrorMessage(error: PluginError): string {\n  switch (error.type) {\n    case 'path-not-found':\n      return `${error.component} path not found: ${error.path}`\n    case 'git-auth-failed':\n      return `Git ${error.authType.toUpperCase()} authentication failed for ${error.gitUrl}`\n    case 'git-timeout':\n      return `Git ${error.operation} timed out for ${error.gitUrl}`\n    case 'network-error':\n      return `Network error accessing ${error.url}${error.details ? `: ${error.details}` : ''}`\n    case 'manifest-parse-error':\n      return `Failed to parse manifest at ${error.manifestPath}: ${error.parseError}`\n    case 'manifest-validation-error':\n      return `Invalid manifest at ${error.manifestPath}: ${error.validationErrors.join(', ')}`\n    case 'plugin-not-found':\n      return `Plugin \"${error.pluginId}\" not found in marketplace \"${error.marketplace}\"`\n    case 'marketplace-not-found':\n      return `Marketplace \"${error.marketplace}\" not found`\n    case 'marketplace-load-failed':\n      return `Failed to load marketplace \"${error.marketplace}\": ${error.reason}`\n    case 'mcp-config-invalid':\n      return `Invalid MCP server config for \"${error.serverName}\": ${error.validationError}`\n    case 'mcp-server-suppressed-duplicate': {\n      const dup = error.duplicateOf.startsWith('plugin:')\n        ? `server provided by plugin \"${error.duplicateOf.split(':')[1] ?? '?'}\"`\n        : `already-configured \"${error.duplicateOf}\"`\n      return `MCP server \"${error.serverName}\" skipped — same command/URL as ${dup}`\n    }\n    case 'hook-load-failed':\n      return `Failed to load hooks from ${error.hookPath}: ${error.reason}`\n    case 'component-load-failed':\n      return `Failed to load ${error.component} from ${error.path}: ${error.reason}`\n    case 'mcpb-download-failed':\n      return `Failed to download MCPB from ${error.url}: ${error.reason}`\n    case 'mcpb-extract-failed':\n      return `Failed to extract MCPB ${error.mcpbPath}: ${error.reason}`\n    case 'mcpb-invalid-manifest':\n      return `MCPB manifest invalid at ${error.mcpbPath}: ${error.validationError}`\n    case 'marketplace-blocked-by-policy':\n      return error.blockedByBlocklist\n        ? `Marketplace \"${error.marketplace}\" is blocked by enterprise policy`\n        : `Marketplace \"${error.marketplace}\" is not in the allowed marketplace list`\n    case 'dependency-unsatisfied':\n      return error.reason === 'not-enabled'\n        ? `Dependency \"${error.dependency}\" is disabled`\n        : `Dependency \"${error.dependency}\" is not installed`\n    case 'lsp-config-invalid':\n      return `Invalid LSP server config for \"${error.serverName}\": ${error.validationError}`\n    case 'lsp-server-start-failed':\n      return `LSP server \"${error.serverName}\" failed to start: ${error.reason}`\n    case 'lsp-server-crashed':\n      return error.signal\n        ? `LSP server \"${error.serverName}\" crashed with signal ${error.signal}`\n        : `LSP server \"${error.serverName}\" crashed with exit code ${error.exitCode ?? 'unknown'}`\n    case 'lsp-request-timeout':\n      return `LSP server \"${error.serverName}\" timed out on ${error.method} after ${error.timeoutMs}ms`\n    case 'lsp-request-failed':\n      return `LSP server \"${error.serverName}\" ${error.method} failed: ${error.error}`\n    case 'plugin-cache-miss':\n      return `Plugin \"${error.plugin}\" not cached at ${error.installPath}`\n    case 'generic-error':\n      return error.error\n  }\n  const _exhaustive: never = error\n  return getPluginErrorMessage(_exhaustive)\n}\n\nexport function getErrorGuidance(error: PluginError): string | null {\n  switch (error.type) {\n    case 'path-not-found':\n      return 'Check that the path in your manifest or marketplace config is correct'\n    case 'git-auth-failed':\n      return error.authType === 'ssh'\n        ? 'Configure SSH keys or use HTTPS URL instead'\n        : 'Configure credentials or use SSH URL instead'\n    case 'git-timeout':\n    case 'network-error':\n      return 'Check your internet connection and try again'\n    case 'manifest-parse-error':\n      return 'Check manifest file syntax in the plugin directory'\n    case 'manifest-validation-error':\n      return 'Check manifest file follows the required schema'\n    case 'plugin-not-found':\n      return `Plugin may not exist in marketplace \"${error.marketplace}\"`\n    case 'marketplace-not-found':\n      return error.availableMarketplaces.length > 0\n        ? `Available marketplaces: ${error.availableMarketplaces.join(', ')}`\n        : 'Add the marketplace first using /plugin marketplace add'\n    case 'mcp-config-invalid':\n      return 'Check MCP server configuration in .mcp.json or manifest'\n    case 'mcp-server-suppressed-duplicate': {\n      // duplicateOf is \"plugin:name:srv\" when another plugin won dedup —\n      // users can't remove plugin-provided servers from their MCP config,\n      // so point them at the winning plugin instead.\n      if (error.duplicateOf.startsWith('plugin:')) {\n        const winningPlugin =\n          error.duplicateOf.split(':')[1] ?? 'the other plugin'\n        return `Disable plugin \"${winningPlugin}\" if you want this plugin's version instead`\n      }\n      return `Remove \"${error.duplicateOf}\" from your MCP config if you want the plugin's version instead`\n    }\n    case 'hook-load-failed':\n      return 'Check hooks.json file syntax and structure'\n    case 'component-load-failed':\n      return `Check ${error.component} directory structure and file permissions`\n    case 'mcpb-download-failed':\n      return 'Check your internet connection and URL accessibility'\n    case 'mcpb-extract-failed':\n      return 'Verify the MCPB file is valid and not corrupted'\n    case 'mcpb-invalid-manifest':\n      return 'Contact the plugin author about the invalid manifest'\n    case 'marketplace-blocked-by-policy':\n      if (error.blockedByBlocklist) {\n        return 'This marketplace source is explicitly blocked by your administrator'\n      }\n      return error.allowedSources.length > 0\n        ? `Allowed sources: ${error.allowedSources.join(', ')}`\n        : 'Contact your administrator to configure allowed marketplace sources'\n    case 'dependency-unsatisfied':\n      return error.reason === 'not-enabled'\n        ? `Enable \"${error.dependency}\" or uninstall \"${error.plugin}\"`\n        : `Install \"${error.dependency}\" or uninstall \"${error.plugin}\"`\n    case 'lsp-config-invalid':\n      return 'Check LSP server configuration in the plugin manifest'\n    case 'lsp-server-start-failed':\n    case 'lsp-server-crashed':\n    case 'lsp-request-timeout':\n    case 'lsp-request-failed':\n      return 'Check LSP server logs with --debug for details'\n    case 'plugin-cache-miss':\n      return 'Run /plugins to refresh the plugin cache'\n    case 'marketplace-load-failed':\n    case 'generic-error':\n      return null\n  }\n  const _exhaustive: never = error\n  return null\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/plugin/PluginOptionsDialog.tsx

@@ -0,0 +1,357 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import React, { useCallback, useState } from 'react';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw text input for config dialog
+import { Box, Text, useInput } from '../../ink.js';
+import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import type { PluginOptionSchema, PluginOptionValues } from '../../utils/plugins/pluginOptionsStorage.js';
+
+/**
+ * Build the onSave payload from collected string inputs.
+ *
+ * Sensitive fields are never prepopulated in the text buffer (security), so
+ * by the time the user reaches the last field every sensitive field they
+ * stepped through contains '' in collected. To avoid silently wiping saved
+ * secrets on reconfigure: if a sensitive field is '' AND initialValues has
+ * a value for it, OMIT the key entirely. savePluginOptions only writes keys
+ * it receives, so omitting = keep existing.
+ *
+ * Exported for unit testing.
+ */
+export function buildFinalValues(fields: string[], collected: Record<string, string>, configSchema: PluginOptionSchema, initialValues: PluginOptionValues | undefined): PluginOptionValues {
+  const finalValues: PluginOptionValues = {};
+  for (const fieldKey of fields) {
+    const schema = configSchema[fieldKey];
+    const value = collected[fieldKey] ?? '';
+    if (schema?.sensitive === true && value === '' && initialValues?.[fieldKey] !== undefined) {
+      continue;
+    }
+    if (schema?.type === 'number') {
+      // Number('') returns 0, not NaN — omit blank number inputs so
+      // validateUserConfig's required check actually catches them.
+      if (value.trim() === '') continue;
+      const num = Number(value);
+      finalValues[fieldKey] = Number.isNaN(num) ? value : num;
+    } else if (schema?.type === 'boolean') {
+      finalValues[fieldKey] = isEnvTruthy(value);
+    } else {
+      finalValues[fieldKey] = value;
+    }
+  }
+  return finalValues;
+}
+type Props = {
+  title: string;
+  subtitle: string;
+  configSchema: PluginOptionSchema;
+  /** Pre-fill fields when reconfiguring. Sensitive fields are not prepopulated. */
+  initialValues?: PluginOptionValues;
+  onSave: (config: PluginOptionValues) => void;
+  onCancel: () => void;
+};
+export function PluginOptionsDialog(t0) {
+  const $ = _c(70);
+  const {
+    title,
+    subtitle,
+    configSchema,
+    initialValues,
+    onSave,
+    onCancel
+  } = t0;
+  let t1;
+  if ($[0] !== configSchema) {
+    t1 = Object.keys(configSchema);
+    $[0] = configSchema;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const fields = t1;
+  let t2;
+  if ($[2] !== configSchema || $[3] !== initialValues) {
+    t2 = key => {
+      if (configSchema[key]?.sensitive === true) {
+        return "";
+      }
+      const v = initialValues?.[key];
+      return v === undefined ? "" : String(v);
+    };
+    $[2] = configSchema;
+    $[3] = initialValues;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const initialFor = t2;
+  const [currentFieldIndex, setCurrentFieldIndex] = useState(0);
+  let t3;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = {};
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const [values, setValues] = useState(t3);
+  let t4;
+  if ($[6] !== fields[0] || $[7] !== initialFor) {
+    t4 = () => fields[0] ? initialFor(fields[0]) : "";
+    $[6] = fields[0];
+    $[7] = initialFor;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  const [currentInput, setCurrentInput] = useState(t4);
+  const currentField = fields[currentFieldIndex];
+  const fieldSchema = currentField ? configSchema[currentField] : null;
+  let t5;
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = {
+      context: "Settings"
+    };
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  useKeybinding("confirm:no", onCancel, t5);
+  let t6;
+  if ($[10] !== currentField || $[11] !== currentFieldIndex || $[12] !== currentInput || $[13] !== fields || $[14] !== initialFor) {
+    t6 = () => {
+      if (currentFieldIndex < fields.length - 1 && currentField) {
+        setValues(prev => ({
+          ...prev,
+          [currentField]: currentInput
+        }));
+        setCurrentFieldIndex(_temp);
+        const nextKey = fields[currentFieldIndex + 1];
+        setCurrentInput(nextKey ? initialFor(nextKey) : "");
+      }
+    };
+    $[10] = currentField;
+    $[11] = currentFieldIndex;
+    $[12] = currentInput;
+    $[13] = fields;
+    $[14] = initialFor;
+    $[15] = t6;
+  } else {
+    t6 = $[15];
+  }
+  const handleNextField = t6;
+  let t7;
+  if ($[16] !== configSchema || $[17] !== currentField || $[18] !== currentFieldIndex || $[19] !== currentInput || $[20] !== fields || $[21] !== initialFor || $[22] !== initialValues || $[23] !== onSave || $[24] !== values) {
+    t7 = () => {
+      if (!currentField) {
+        return;
+      }
+      const newValues = {
+        ...values,
+        [currentField]: currentInput
+      };
+      if (currentFieldIndex === fields.length - 1) {
+        onSave(buildFinalValues(fields, newValues, configSchema, initialValues));
+      } else {
+        setValues(newValues);
+        setCurrentFieldIndex(_temp2);
+        const nextKey_0 = fields[currentFieldIndex + 1];
+        setCurrentInput(nextKey_0 ? initialFor(nextKey_0) : "");
+      }
+    };
+    $[16] = configSchema;
+    $[17] = currentField;
+    $[18] = currentFieldIndex;
+    $[19] = currentInput;
+    $[20] = fields;
+    $[21] = initialFor;
+    $[22] = initialValues;
+    $[23] = onSave;
+    $[24] = values;
+    $[25] = t7;
+  } else {
+    t7 = $[25];
+  }
+  const handleConfirm = t7;
+  let t8;
+  if ($[26] !== handleConfirm || $[27] !== handleNextField) {
+    t8 = {
+      "confirm:nextField": handleNextField,
+      "confirm:yes": handleConfirm
+    };
+    $[26] = handleConfirm;
+    $[27] = handleNextField;
+    $[28] = t8;
+  } else {
+    t8 = $[28];
+  }
+  let t9;
+  if ($[29] === Symbol.for("react.memo_cache_sentinel")) {
+    t9 = {
+      context: "Confirmation"
+    };
+    $[29] = t9;
+  } else {
+    t9 = $[29];
+  }
+  useKeybindings(t8, t9);
+  let t10;
+  if ($[30] === Symbol.for("react.memo_cache_sentinel")) {
+    t10 = (char, key_0) => {
+      if (key_0.backspace || key_0.delete) {
+        setCurrentInput(_temp3);
+        return;
+      }
+      if (char && !key_0.ctrl && !key_0.meta && !key_0.tab && !key_0.return) {
+        setCurrentInput(prev_3 => prev_3 + char);
+      }
+    };
+    $[30] = t10;
+  } else {
+    t10 = $[30];
+  }
+  useInput(t10);
+  if (!fieldSchema || !currentField) {
+    return null;
+  }
+  const isSensitive = fieldSchema.sensitive === true;
+  const isRequired = fieldSchema.required === true;
+  let t11;
+  if ($[31] !== currentInput || $[32] !== isSensitive) {
+    t11 = isSensitive ? "*".repeat(stringWidth(currentInput)) : currentInput;
+    $[31] = currentInput;
+    $[32] = isSensitive;
+    $[33] = t11;
+  } else {
+    t11 = $[33];
+  }
+  const displayValue = t11;
+  const t12 = fieldSchema.title || currentField;
+  let t13;
+  if ($[34] !== isRequired) {
+    t13 = isRequired && <Text color="error"> *</Text>;
+    $[34] = isRequired;
+    $[35] = t13;
+  } else {
+    t13 = $[35];
+  }
+  let t14;
+  if ($[36] !== t12 || $[37] !== t13) {
+    t14 = <Text bold={true}>{t12}{t13}</Text>;
+    $[36] = t12;
+    $[37] = t13;
+    $[38] = t14;
+  } else {
+    t14 = $[38];
+  }
+  let t15;
+  if ($[39] !== fieldSchema.description) {
+    t15 = fieldSchema.description && <Text dimColor={true}>{fieldSchema.description}</Text>;
+    $[39] = fieldSchema.description;
+    $[40] = t15;
+  } else {
+    t15 = $[40];
+  }
+  let t16;
+  if ($[41] === Symbol.for("react.memo_cache_sentinel")) {
+    t16 = <Text>{figures.pointerSmall} </Text>;
+    $[41] = t16;
+  } else {
+    t16 = $[41];
+  }
+  let t17;
+  if ($[42] !== displayValue) {
+    t17 = <Text>{displayValue}</Text>;
+    $[42] = displayValue;
+    $[43] = t17;
+  } else {
+    t17 = $[43];
+  }
+  let t18;
+  if ($[44] === Symbol.for("react.memo_cache_sentinel")) {
+    t18 = <Text>█</Text>;
+    $[44] = t18;
+  } else {
+    t18 = $[44];
+  }
+  let t19;
+  if ($[45] !== t17) {
+    t19 = <Box marginTop={1}>{t16}{t17}{t18}</Box>;
+    $[45] = t17;
+    $[46] = t19;
+  } else {
+    t19 = $[46];
+  }
+  let t20;
+  if ($[47] !== t14 || $[48] !== t15 || $[49] !== t19) {
+    t20 = <Box flexDirection="column">{t14}{t15}{t19}</Box>;
+    $[47] = t14;
+    $[48] = t15;
+    $[49] = t19;
+    $[50] = t20;
+  } else {
+    t20 = $[50];
+  }
+  const t21 = currentFieldIndex + 1;
+  let t22;
+  if ($[51] !== fields.length || $[52] !== t21) {
+    t22 = <Text dimColor={true}>Field {t21} of {fields.length}</Text>;
+    $[51] = fields.length;
+    $[52] = t21;
+    $[53] = t22;
+  } else {
+    t22 = $[53];
+  }
+  let t23;
+  if ($[54] !== currentFieldIndex || $[55] !== fields.length) {
+    t23 = currentFieldIndex < fields.length - 1 && <Text dimColor={true}>Tab: Next field · Enter: Save and continue</Text>;
+    $[54] = currentFieldIndex;
+    $[55] = fields.length;
+    $[56] = t23;
+  } else {
+    t23 = $[56];
+  }
+  let t24;
+  if ($[57] !== currentFieldIndex || $[58] !== fields.length) {
+    t24 = currentFieldIndex === fields.length - 1 && <Text dimColor={true}>Enter: Save configuration</Text>;
+    $[57] = currentFieldIndex;
+    $[58] = fields.length;
+    $[59] = t24;
+  } else {
+    t24 = $[59];
+  }
+  let t25;
+  if ($[60] !== t22 || $[61] !== t23 || $[62] !== t24) {
+    t25 = <Box flexDirection="column">{t22}{t23}{t24}</Box>;
+    $[60] = t22;
+    $[61] = t23;
+    $[62] = t24;
+    $[63] = t25;
+  } else {
+    t25 = $[63];
+  }
+  let t26;
+  if ($[64] !== onCancel || $[65] !== subtitle || $[66] !== t20 || $[67] !== t25 || $[68] !== title) {
+    t26 = <Dialog title={title} subtitle={subtitle} onCancel={onCancel} isCancelActive={false}>{t20}{t25}</Dialog>;
+    $[64] = onCancel;
+    $[65] = subtitle;
+    $[66] = t20;
+    $[67] = t25;
+    $[68] = title;
+    $[69] = t26;
+  } else {
+    t26 = $[69];
+  }
+  return t26;
+}
+function _temp3(prev_2) {
+  return prev_2.slice(0, -1);
+}
+function _temp2(prev_1) {
+  return prev_1 + 1;
+}
+function _temp(prev_0) {
+  return prev_0 + 1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useCallback","useState","Dialog","stringWidth","Box","Text","useInput","useKeybinding","useKeybindings","isEnvTruthy","PluginOptionSchema","PluginOptionValues","buildFinalValues","fields","collected","Record","configSchema","initialValues","finalValues","fieldKey","schema","value","sensitive","undefined","type","trim","num","Number","isNaN","Props","title","subtitle","onSave","config","onCancel","PluginOptionsDialog","t0","$","_c","t1","Object","keys","t2","key","v","String","initialFor","currentFieldIndex","setCurrentFieldIndex","t3","Symbol","for","values","setValues","t4","currentInput","setCurrentInput","currentField","fieldSchema","t5","context","t6","length","prev","_temp","nextKey","handleNextField","t7","newValues","_temp2","nextKey_0","handleConfirm","t8","t9","t10","char","key_0","backspace","delete","_temp3","ctrl","meta","tab","return","prev_3","isSensitive","isRequired","required","t11","repeat","displayValue","t12","t13","t14","t15","description","t16","pointerSmall","t17","t18","t19","t20","t21","t22","t23","t24","t25","t26","prev_2","slice","prev_1","prev_0"],"sources":["PluginOptionsDialog.tsx"],"sourcesContent":["import figures from 'figures'\nimport React, { useCallback, useState } from 'react'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw text input for config dialog\nimport { Box, Text, useInput } from '../../ink.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport type {\n  PluginOptionSchema,\n  PluginOptionValues,\n} from '../../utils/plugins/pluginOptionsStorage.js'\n\n/**\n * Build the onSave payload from collected string inputs.\n *\n * Sensitive fields are never prepopulated in the text buffer (security), so\n * by the time the user reaches the last field every sensitive field they\n * stepped through contains '' in collected. To avoid silently wiping saved\n * secrets on reconfigure: if a sensitive field is '' AND initialValues has\n * a value for it, OMIT the key entirely. savePluginOptions only writes keys\n * it receives, so omitting = keep existing.\n *\n * Exported for unit testing.\n */\nexport function buildFinalValues(\n  fields: string[],\n  collected: Record<string, string>,\n  configSchema: PluginOptionSchema,\n  initialValues: PluginOptionValues | undefined,\n): PluginOptionValues {\n  const finalValues: PluginOptionValues = {}\n  for (const fieldKey of fields) {\n    const schema = configSchema[fieldKey]\n    const value = collected[fieldKey] ?? ''\n\n    if (\n      schema?.sensitive === true &&\n      value === '' &&\n      initialValues?.[fieldKey] !== undefined\n    ) {\n      continue\n    }\n\n    if (schema?.type === 'number') {\n      // Number('') returns 0, not NaN — omit blank number inputs so\n      // validateUserConfig's required check actually catches them.\n      if (value.trim() === '') continue\n      const num = Number(value)\n      finalValues[fieldKey] = Number.isNaN(num) ? value : num\n    } else if (schema?.type === 'boolean') {\n      finalValues[fieldKey] = isEnvTruthy(value)\n    } else {\n      finalValues[fieldKey] = value\n    }\n  }\n  return finalValues\n}\n\ntype Props = {\n  title: string\n  subtitle: string\n  configSchema: PluginOptionSchema\n  /** Pre-fill fields when reconfiguring. Sensitive fields are not prepopulated. */\n  initialValues?: PluginOptionValues\n  onSave: (config: PluginOptionValues) => void\n  onCancel: () => void\n}\n\nexport function PluginOptionsDialog({\n  title,\n  subtitle,\n  configSchema,\n  initialValues,\n  onSave,\n  onCancel,\n}: Props): React.ReactNode {\n  const fields = Object.keys(configSchema)\n\n  // Prepopulate from initialValues but skip sensitive fields — we don't\n  // want to echo secrets back into the text buffer.\n  const initialFor = useCallback(\n    (key: string): string => {\n      if (configSchema[key]?.sensitive === true) return ''\n      const v = initialValues?.[key]\n      return v === undefined ? '' : String(v)\n    },\n    [configSchema, initialValues],\n  )\n\n  const [currentFieldIndex, setCurrentFieldIndex] = useState(0)\n  const [values, setValues] = useState<Record<string, string>>({})\n  const [currentInput, setCurrentInput] = useState(() =>\n    fields[0] ? initialFor(fields[0]) : '',\n  )\n\n  const currentField = fields[currentFieldIndex]\n  const fieldSchema = currentField ? configSchema[currentField] : null\n\n  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in input).\n  // isCancelActive={false} on Dialog keeps its own confirm:no out of the way.\n  useKeybinding('confirm:no', onCancel, { context: 'Settings' })\n\n  // Tab to next field\n  const handleNextField = useCallback(() => {\n    if (currentFieldIndex < fields.length - 1 && currentField) {\n      setValues(prev => ({ ...prev, [currentField]: currentInput }))\n      setCurrentFieldIndex(prev => prev + 1)\n      const nextKey = fields[currentFieldIndex + 1]\n      setCurrentInput(nextKey ? initialFor(nextKey) : '')\n    }\n  }, [currentFieldIndex, fields, currentField, currentInput, initialFor])\n\n  // Enter to save current field and move to next, or save all if last\n  const handleConfirm = useCallback(() => {\n    if (!currentField) return\n\n    const newValues = { ...values, [currentField]: currentInput }\n\n    if (currentFieldIndex === fields.length - 1) {\n      onSave(buildFinalValues(fields, newValues, configSchema, initialValues))\n    } else {\n      // Move to next field\n      setValues(newValues)\n      setCurrentFieldIndex(prev => prev + 1)\n      const nextKey = fields[currentFieldIndex + 1]\n      setCurrentInput(nextKey ? initialFor(nextKey) : '')\n    }\n  }, [\n    currentField,\n    values,\n    currentInput,\n    currentFieldIndex,\n    fields,\n    configSchema,\n    onSave,\n    initialFor,\n    initialValues,\n  ])\n\n  useKeybindings(\n    {\n      'confirm:nextField': handleNextField,\n      'confirm:yes': handleConfirm,\n    },\n    { context: 'Confirmation' },\n  )\n\n  // Character input handling (backspace, typing)\n  useInput((char, key) => {\n    // Backspace\n    if (key.backspace || key.delete) {\n      setCurrentInput(prev => prev.slice(0, -1))\n      return\n    }\n\n    // Regular character input\n    if (char && !key.ctrl && !key.meta && !key.tab && !key.return) {\n      setCurrentInput(prev => prev + char)\n    }\n  })\n\n  if (!fieldSchema || !currentField) {\n    return null\n  }\n\n  const isSensitive = fieldSchema.sensitive === true\n  const isRequired = fieldSchema.required === true\n  const displayValue = isSensitive\n    ? '*'.repeat(stringWidth(currentInput))\n    : currentInput\n\n  return (\n    <Dialog\n      title={title}\n      subtitle={subtitle}\n      onCancel={onCancel}\n      isCancelActive={false}\n    >\n      <Box flexDirection=\"column\">\n        <Text bold={true}>\n          {fieldSchema.title || currentField}\n          {isRequired && <Text color=\"error\"> *</Text>}\n        </Text>\n        {fieldSchema.description && (\n          <Text dimColor={true}>{fieldSchema.description}</Text>\n        )}\n\n        <Box marginTop={1}>\n          <Text>{figures.pointerSmall} </Text>\n          <Text>{displayValue}</Text>\n          <Text>█</Text>\n        </Box>\n      </Box>\n\n      <Box flexDirection=\"column\">\n        <Text dimColor={true}>\n          Field {currentFieldIndex + 1} of {fields.length}\n        </Text>\n        {currentFieldIndex < fields.length - 1 && (\n          <Text dimColor={true}>\n            Tab: Next field · Enter: Save and continue\n          </Text>\n        )}\n        {currentFieldIndex === fields.length - 1 && (\n          <Text dimColor={true}>Enter: Save configuration</Text>\n        )}\n      </Box>\n    </Dialog>\n  )\n}\n"],"mappings":";AAAA,OAAOA,OAAO,MAAM,SAAS;AAC7B,OAAOC,KAAK,IAAIC,WAAW,EAAEC,QAAQ,QAAQ,OAAO;AACpD,SAASC,MAAM,QAAQ,0CAA0C;AACjE,SAASC,WAAW,QAAQ,0BAA0B;AACtD;AACA,SAASC,GAAG,EAAEC,IAAI,EAAEC,QAAQ,QAAQ,cAAc;AAClD,SACEC,aAAa,EACbC,cAAc,QACT,oCAAoC;AAC3C,SAASC,WAAW,QAAQ,yBAAyB;AACrD,cACEC,kBAAkB,EAClBC,kBAAkB,QACb,6CAA6C;;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAC9BC,MAAM,EAAE,MAAM,EAAE,EAChBC,SAAS,EAAEC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACjCC,YAAY,EAAEN,kBAAkB,EAChCO,aAAa,EAAEN,kBAAkB,GAAG,SAAS,CAC9C,EAAEA,kBAAkB,CAAC;EACpB,MAAMO,WAAW,EAAEP,kBAAkB,GAAG,CAAC,CAAC;EAC1C,KAAK,MAAMQ,QAAQ,IAAIN,MAAM,EAAE;IAC7B,MAAMO,MAAM,GAAGJ,YAAY,CAACG,QAAQ,CAAC;IACrC,MAAME,KAAK,GAAGP,SAAS,CAACK,QAAQ,CAAC,IAAI,EAAE;IAEvC,IACEC,MAAM,EAAEE,SAAS,KAAK,IAAI,IAC1BD,KAAK,KAAK,EAAE,IACZJ,aAAa,GAAGE,QAAQ,CAAC,KAAKI,SAAS,EACvC;MACA;IACF;IAEA,IAAIH,MAAM,EAAEI,IAAI,KAAK,QAAQ,EAAE;MAC7B;MACA;MACA,IAAIH,KAAK,CAACI,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;MACzB,MAAMC,GAAG,GAAGC,MAAM,CAACN,KAAK,CAAC;MACzBH,WAAW,CAACC,QAAQ,CAAC,GAAGQ,MAAM,CAACC,KAAK,CAACF,GAAG,CAAC,GAAGL,KAAK,GAAGK,GAAG;IACzD,CAAC,MAAM,IAAIN,MAAM,EAAEI,IAAI,KAAK,SAAS,EAAE;MACrCN,WAAW,CAACC,QAAQ,CAAC,GAAGV,WAAW,CAACY,KAAK,CAAC;IAC5C,CAAC,MAAM;MACLH,WAAW,CAACC,QAAQ,CAAC,GAAGE,KAAK;IAC/B;EACF;EACA,OAAOH,WAAW;AACpB;AAEA,KAAKW,KAAK,GAAG;EACXC,KAAK,EAAE,MAAM;EACbC,QAAQ,EAAE,MAAM;EAChBf,YAAY,EAAEN,kBAAkB;EAChC;EACAO,aAAa,CAAC,EAAEN,kBAAkB;EAClCqB,MAAM,EAAE,CAACC,MAAM,EAAEtB,kBAAkB,EAAE,GAAG,IAAI;EAC5CuB,QAAQ,EAAE,GAAG,GAAG,IAAI;AACtB,CAAC;AAED,OAAO,SAAAC,oBAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAA6B;IAAAR,KAAA;IAAAC,QAAA;IAAAf,YAAA;IAAAC,aAAA;IAAAe,MAAA;IAAAE;EAAA,IAAAE,EAO5B;EAAA,IAAAG,EAAA;EAAA,IAAAF,CAAA,QAAArB,YAAA;IACSuB,EAAA,GAAAC,MAAM,CAAAC,IAAK,CAACzB,YAAY,CAAC;IAAAqB,CAAA,MAAArB,YAAA;IAAAqB,CAAA,MAAAE,EAAA;EAAA;IAAAA,EAAA,GAAAF,CAAA;EAAA;EAAxC,MAAAxB,MAAA,GAAe0B,EAAyB;EAAA,IAAAG,EAAA;EAAA,IAAAL,CAAA,QAAArB,YAAA,IAAAqB,CAAA,QAAApB,aAAA;IAKtCyB,EAAA,GAAAC,GAAA;MACE,IAAI3B,YAAY,CAAC2B,GAAG,CAAY,EAAArB,SAAA,KAAK,IAAI;QAAA,OAAS,EAAE;MAAA;MACpD,MAAAsB,CAAA,GAAU3B,aAAa,GAAG0B,GAAG,CAAC;MAAA,OACvBC,CAAC,KAAKrB,SAA0B,GAAhC,EAAgC,GAATsB,MAAM,CAACD,CAAC,CAAC;IAAA,CACxC;IAAAP,CAAA,MAAArB,YAAA;IAAAqB,CAAA,MAAApB,aAAA;IAAAoB,CAAA,MAAAK,EAAA;EAAA;IAAAA,EAAA,GAAAL,CAAA;EAAA;EALH,MAAAS,UAAA,GAAmBJ,EAOlB;EAED,OAAAK,iBAAA,EAAAC,oBAAA,IAAkD/C,QAAQ,CAAC,CAAC,CAAC;EAAA,IAAAgD,EAAA;EAAA,IAAAZ,CAAA,QAAAa,MAAA,CAAAC,GAAA;IACAF,EAAA,IAAC,CAAC;IAAAZ,CAAA,MAAAY,EAAA;EAAA;IAAAA,EAAA,GAAAZ,CAAA;EAAA;EAA/D,OAAAe,MAAA,EAAAC,SAAA,IAA4BpD,QAAQ,CAAyBgD,EAAE,CAAC;EAAA,IAAAK,EAAA;EAAA,IAAAjB,CAAA,QAAAxB,MAAA,OAAAwB,CAAA,QAAAS,UAAA;IACfQ,EAAA,GAAAA,CAAA,KAC/CzC,MAAM,GAAgC,GAA1BiC,UAAU,CAACjC,MAAM,GAAQ,CAAC,GAAtC,EAAsC;IAAAwB,CAAA,MAAAxB,MAAA;IAAAwB,CAAA,MAAAS,UAAA;IAAAT,CAAA,MAAAiB,EAAA;EAAA;IAAAA,EAAA,GAAAjB,CAAA;EAAA;EADxC,OAAAkB,YAAA,EAAAC,eAAA,IAAwCvD,QAAQ,CAACqD,EAEjD,CAAC;EAED,MAAAG,YAAA,GAAqB5C,MAAM,CAACkC,iBAAiB,CAAC;EAC9C,MAAAW,WAAA,GAAoBD,YAAY,GAAGzC,YAAY,CAACyC,YAAY,CAAQ,GAAhD,IAAgD;EAAA,IAAAE,EAAA;EAAA,IAAAtB,CAAA,QAAAa,MAAA,CAAAC,GAAA;IAI9BQ,EAAA;MAAAC,OAAA,EAAW;IAAW,CAAC;IAAAvB,CAAA,MAAAsB,EAAA;EAAA;IAAAA,EAAA,GAAAtB,CAAA;EAAA;EAA7D9B,aAAa,CAAC,YAAY,EAAE2B,QAAQ,EAAEyB,EAAuB,CAAC;EAAA,IAAAE,EAAA;EAAA,IAAAxB,CAAA,SAAAoB,YAAA,IAAApB,CAAA,SAAAU,iBAAA,IAAAV,CAAA,SAAAkB,YAAA,IAAAlB,CAAA,SAAAxB,MAAA,IAAAwB,CAAA,SAAAS,UAAA;IAG1Be,EAAA,GAAAA,CAAA;MAClC,IAAId,iBAAiB,GAAGlC,MAAM,CAAAiD,MAAO,GAAG,CAAiB,IAArDL,YAAqD;QACvDJ,SAAS,CAACU,IAAA,KAAS;UAAA,GAAKA,IAAI;UAAA,CAAGN,YAAY,GAAGF;QAAa,CAAC,CAAC,CAAC;QAC9DP,oBAAoB,CAACgB,KAAgB,CAAC;QACtC,MAAAC,OAAA,GAAgBpD,MAAM,CAACkC,iBAAiB,GAAG,CAAC,CAAC;QAC7CS,eAAe,CAACS,OAAO,GAAGnB,UAAU,CAACmB,OAAY,CAAC,GAAlC,EAAkC,CAAC;MAAA;IACpD,CACF;IAAA5B,CAAA,OAAAoB,YAAA;IAAApB,CAAA,OAAAU,iBAAA;IAAAV,CAAA,OAAAkB,YAAA;IAAAlB,CAAA,OAAAxB,MAAA;IAAAwB,CAAA,OAAAS,UAAA;IAAAT,CAAA,OAAAwB,EAAA;EAAA;IAAAA,EAAA,GAAAxB,CAAA;EAAA;EAPD,MAAA6B,eAAA,GAAwBL,EAO+C;EAAA,IAAAM,EAAA;EAAA,IAAA9B,CAAA,SAAArB,YAAA,IAAAqB,CAAA,SAAAoB,YAAA,IAAApB,CAAA,SAAAU,iBAAA,IAAAV,CAAA,SAAAkB,YAAA,IAAAlB,CAAA,SAAAxB,MAAA,IAAAwB,CAAA,SAAAS,UAAA,IAAAT,CAAA,SAAApB,aAAA,IAAAoB,CAAA,SAAAL,MAAA,IAAAK,CAAA,SAAAe,MAAA;IAGrCe,EAAA,GAAAA,CAAA;MAChC,IAAI,CAACV,YAAY;QAAA;MAAA;MAEjB,MAAAW,SAAA,GAAkB;QAAA,GAAKhB,MAAM;QAAA,CAAGK,YAAY,GAAGF;MAAa,CAAC;MAE7D,IAAIR,iBAAiB,KAAKlC,MAAM,CAAAiD,MAAO,GAAG,CAAC;QACzC9B,MAAM,CAACpB,gBAAgB,CAACC,MAAM,EAAEuD,SAAS,EAAEpD,YAAY,EAAEC,aAAa,CAAC,CAAC;MAAA;QAGxEoC,SAAS,CAACe,SAAS,CAAC;QACpBpB,oBAAoB,CAACqB,MAAgB,CAAC;QACtC,MAAAC,SAAA,GAAgBzD,MAAM,CAACkC,iBAAiB,GAAG,CAAC,CAAC;QAC7CS,eAAe,CAACS,SAAO,GAAGnB,UAAU,CAACmB,SAAY,CAAC,GAAlC,EAAkC,CAAC;MAAA;IACpD,CACF;IAAA5B,CAAA,OAAArB,YAAA;IAAAqB,CAAA,OAAAoB,YAAA;IAAApB,CAAA,OAAAU,iBAAA;IAAAV,CAAA,OAAAkB,YAAA;IAAAlB,CAAA,OAAAxB,MAAA;IAAAwB,CAAA,OAAAS,UAAA;IAAAT,CAAA,OAAApB,aAAA;IAAAoB,CAAA,OAAAL,MAAA;IAAAK,CAAA,OAAAe,MAAA;IAAAf,CAAA,OAAA8B,EAAA;EAAA;IAAAA,EAAA,GAAA9B,CAAA;EAAA;EAdD,MAAAkC,aAAA,GAAsBJ,EAwBpB;EAAA,IAAAK,EAAA;EAAA,IAAAnC,CAAA,SAAAkC,aAAA,IAAAlC,CAAA,SAAA6B,eAAA;IAGAM,EAAA;MAAA,qBACuBN,eAAe;MAAA,eACrBK;IACjB,CAAC;IAAAlC,CAAA,OAAAkC,aAAA;IAAAlC,CAAA,OAAA6B,eAAA;IAAA7B,CAAA,OAAAmC,EAAA;EAAA;IAAAA,EAAA,GAAAnC,CAAA;EAAA;EAAA,IAAAoC,EAAA;EAAA,IAAApC,CAAA,SAAAa,MAAA,CAAAC,GAAA;IACDsB,EAAA;MAAAb,OAAA,EAAW;IAAe,CAAC;IAAAvB,CAAA,OAAAoC,EAAA;EAAA;IAAAA,EAAA,GAAApC,CAAA;EAAA;EAL7B7B,cAAc,CACZgE,EAGC,EACDC,EACF,CAAC;EAAA,IAAAC,GAAA;EAAA,IAAArC,CAAA,SAAAa,MAAA,CAAAC,GAAA;IAGQuB,GAAA,GAAAA,CAAAC,IAAA,EAAAC,KAAA;MAEP,IAAIjC,KAAG,CAAAkC,SAAwB,IAAVlC,KAAG,CAAAmC,MAAO;QAC7BtB,eAAe,CAACuB,MAAyB,CAAC;QAAA;MAAA;MAK5C,IAAIJ,IAAiB,IAAjB,CAAShC,KAAG,CAAAqC,IAAkB,IAA9B,CAAsBrC,KAAG,CAAAsC,IAAiB,IAA1C,CAAmCtC,KAAG,CAAAuC,GAAmB,IAAzD,CAA+CvC,KAAG,CAAAwC,MAAO;QAC3D3B,eAAe,CAAC4B,MAAA,IAAQrB,MAAI,GAAGY,IAAI,CAAC;MAAA;IACrC,CACF;IAAAtC,CAAA,OAAAqC,GAAA;EAAA;IAAAA,GAAA,GAAArC,CAAA;EAAA;EAXD/B,QAAQ,CAACoE,GAWR,CAAC;EAEF,IAAI,CAAChB,WAA4B,IAA7B,CAAiBD,YAAY;IAAA,OACxB,IAAI;EAAA;EAGb,MAAA4B,WAAA,GAAoB3B,WAAW,CAAApC,SAAU,KAAK,IAAI;EAClD,MAAAgE,UAAA,GAAmB5B,WAAW,CAAA6B,QAAS,KAAK,IAAI;EAAA,IAAAC,GAAA;EAAA,IAAAnD,CAAA,SAAAkB,YAAA,IAAAlB,CAAA,SAAAgD,WAAA;IAC3BG,GAAA,GAAAH,WAAW,GAC5B,GAAG,CAAAI,MAAO,CAACtF,WAAW,CAACoD,YAAY,CACxB,CAAC,GAFKA,YAEL;IAAAlB,CAAA,OAAAkB,YAAA;IAAAlB,CAAA,OAAAgD,WAAA;IAAAhD,CAAA,OAAAmD,GAAA;EAAA;IAAAA,GAAA,GAAAnD,CAAA;EAAA;EAFhB,MAAAqD,YAAA,GAAqBF,GAEL;EAWP,MAAAG,GAAA,GAAAjC,WAAW,CAAA5B,KAAsB,IAAjC2B,YAAiC;EAAA,IAAAmC,GAAA;EAAA,IAAAvD,CAAA,SAAAiD,UAAA;IACjCM,GAAA,GAAAN,UAA2C,IAA7B,CAAC,IAAI,CAAO,KAAO,CAAP,OAAO,CAAC,EAAE,EAArB,IAAI,CAAwB;IAAAjD,CAAA,OAAAiD,UAAA;IAAAjD,CAAA,OAAAuD,GAAA;EAAA;IAAAA,GAAA,GAAAvD,CAAA;EAAA;EAAA,IAAAwD,GAAA;EAAA,IAAAxD,CAAA,SAAAsD,GAAA,IAAAtD,CAAA,SAAAuD,GAAA;IAF9CC,GAAA,IAAC,IAAI,CAAO,IAAI,CAAJ,KAAG,CAAC,CACb,CAAAF,GAAgC,CAChC,CAAAC,GAA0C,CAC7C,EAHC,IAAI,CAGE;IAAAvD,CAAA,OAAAsD,GAAA;IAAAtD,CAAA,OAAAuD,GAAA;IAAAvD,CAAA,OAAAwD,GAAA;EAAA;IAAAA,GAAA,GAAAxD,CAAA;EAAA;EAAA,IAAAyD,GAAA;EAAA,IAAAzD,CAAA,SAAAqB,WAAA,CAAAqC,WAAA;IACND,GAAA,GAAApC,WAAW,CAAAqC,WAEX,IADC,CAAC,IAAI,CAAW,QAAI,CAAJ,KAAG,CAAC,CAAG,CAAArC,WAAW,CAAAqC,WAAW,CAAE,EAA9C,IAAI,CACN;IAAA1D,CAAA,OAAAqB,WAAA,CAAAqC,WAAA;IAAA1D,CAAA,OAAAyD,GAAA;EAAA;IAAAA,GAAA,GAAAzD,CAAA;EAAA;EAAA,IAAA2D,GAAA;EAAA,IAAA3D,CAAA,SAAAa,MAAA,CAAAC,GAAA;IAGC6C,GAAA,IAAC,IAAI,CAAE,CAAAlG,OAAO,CAAAmG,YAAY,CAAE,CAAC,EAA5B,IAAI,CAA+B;IAAA5D,CAAA,OAAA2D,GAAA;EAAA;IAAAA,GAAA,GAAA3D,CAAA;EAAA;EAAA,IAAA6D,GAAA;EAAA,IAAA7D,CAAA,SAAAqD,YAAA;IACpCQ,GAAA,IAAC,IAAI,CAAER,aAAW,CAAE,EAAnB,IAAI,CAAsB;IAAArD,CAAA,OAAAqD,YAAA;IAAArD,CAAA,OAAA6D,GAAA;EAAA;IAAAA,GAAA,GAAA7D,CAAA;EAAA;EAAA,IAAA8D,GAAA;EAAA,IAAA9D,CAAA,SAAAa,MAAA,CAAAC,GAAA;IAC3BgD,GAAA,IAAC,IAAI,CAAC,CAAC,EAAN,IAAI,CAAS;IAAA9D,CAAA,OAAA8D,GAAA;EAAA;IAAAA,GAAA,GAAA9D,CAAA;EAAA;EAAA,IAAA+D,GAAA;EAAA,IAAA/D,CAAA,SAAA6D,GAAA;IAHhBE,GAAA,IAAC,GAAG,CAAY,SAAC,CAAD,GAAC,CACf,CAAAJ,GAAmC,CACnC,CAAAE,GAA0B,CAC1B,CAAAC,GAAa,CACf,EAJC,GAAG,CAIE;IAAA9D,CAAA,OAAA6D,GAAA;IAAA7D,CAAA,OAAA+D,GAAA;EAAA;IAAAA,GAAA,GAAA/D,CAAA;EAAA;EAAA,IAAAgE,GAAA;EAAA,IAAAhE,CAAA,SAAAwD,GAAA,IAAAxD,CAAA,SAAAyD,GAAA,IAAAzD,CAAA,SAAA+D,GAAA;IAbRC,GAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAAR,GAGM,CACL,CAAAC,GAED,CAEA,CAAAM,GAIK,CACP,EAdC,GAAG,CAcE;IAAA/D,CAAA,OAAAwD,GAAA;IAAAxD,CAAA,OAAAyD,GAAA;IAAAzD,CAAA,OAAA+D,GAAA;IAAA/D,CAAA,OAAAgE,GAAA;EAAA;IAAAA,GAAA,GAAAhE,CAAA;EAAA;EAIK,MAAAiE,GAAA,GAAAvD,iBAAiB,GAAG,CAAC;EAAA,IAAAwD,GAAA;EAAA,IAAAlE,CAAA,SAAAxB,MAAA,CAAAiD,MAAA,IAAAzB,CAAA,SAAAiE,GAAA;IAD9BC,GAAA,IAAC,IAAI,CAAW,QAAI,CAAJ,KAAG,CAAC,CAAE,MACb,CAAAD,GAAoB,CAAE,IAAK,CAAAzF,MAAM,CAAAiD,MAAM,CAChD,EAFC,IAAI,CAEE;IAAAzB,CAAA,OAAAxB,MAAA,CAAAiD,MAAA;IAAAzB,CAAA,OAAAiE,GAAA;IAAAjE,CAAA,OAAAkE,GAAA;EAAA;IAAAA,GAAA,GAAAlE,CAAA;EAAA;EAAA,IAAAmE,GAAA;EAAA,IAAAnE,CAAA,SAAAU,iBAAA,IAAAV,CAAA,SAAAxB,MAAA,CAAAiD,MAAA;IACN0C,GAAA,GAAAzD,iBAAiB,GAAGlC,MAAM,CAAAiD,MAAO,GAAG,CAIpC,IAHC,CAAC,IAAI,CAAW,QAAI,CAAJ,KAAG,CAAC,CAAE,0CAEtB,EAFC,IAAI,CAGN;IAAAzB,CAAA,OAAAU,iBAAA;IAAAV,CAAA,OAAAxB,MAAA,CAAAiD,MAAA;IAAAzB,CAAA,OAAAmE,GAAA;EAAA;IAAAA,GAAA,GAAAnE,CAAA;EAAA;EAAA,IAAAoE,GAAA;EAAA,IAAApE,CAAA,SAAAU,iBAAA,IAAAV,CAAA,SAAAxB,MAAA,CAAAiD,MAAA;IACA2C,GAAA,GAAA1D,iBAAiB,KAAKlC,MAAM,CAAAiD,MAAO,GAAG,CAEtC,IADC,CAAC,IAAI,CAAW,QAAI,CAAJ,KAAG,CAAC,CAAE,yBAAyB,EAA9C,IAAI,CACN;IAAAzB,CAAA,OAAAU,iBAAA;IAAAV,CAAA,OAAAxB,MAAA,CAAAiD,MAAA;IAAAzB,CAAA,OAAAoE,GAAA;EAAA;IAAAA,GAAA,GAAApE,CAAA;EAAA;EAAA,IAAAqE,GAAA;EAAA,IAAArE,CAAA,SAAAkE,GAAA,IAAAlE,CAAA,SAAAmE,GAAA,IAAAnE,CAAA,SAAAoE,GAAA;IAXHC,GAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAAH,GAEM,CACL,CAAAC,GAID,CACC,CAAAC,GAED,CACF,EAZC,GAAG,CAYE;IAAApE,CAAA,OAAAkE,GAAA;IAAAlE,CAAA,OAAAmE,GAAA;IAAAnE,CAAA,OAAAoE,GAAA;IAAApE,CAAA,OAAAqE,GAAA;EAAA;IAAAA,GAAA,GAAArE,CAAA;EAAA;EAAA,IAAAsE,GAAA;EAAA,IAAAtE,CAAA,SAAAH,QAAA,IAAAG,CAAA,SAAAN,QAAA,IAAAM,CAAA,SAAAgE,GAAA,IAAAhE,CAAA,SAAAqE,GAAA,IAAArE,CAAA,SAAAP,KAAA;IAlCR6E,GAAA,IAAC,MAAM,CACE7E,KAAK,CAALA,MAAI,CAAC,CACFC,QAAQ,CAARA,SAAO,CAAC,CACRG,QAAQ,CAARA,SAAO,CAAC,CACF,cAAK,CAAL,MAAI,CAAC,CAErB,CAAAmE,GAcK,CAEL,CAAAK,GAYK,CACP,EAnCC,MAAM,CAmCE;IAAArE,CAAA,OAAAH,QAAA;IAAAG,CAAA,OAAAN,QAAA;IAAAM,CAAA,OAAAgE,GAAA;IAAAhE,CAAA,OAAAqE,GAAA;IAAArE,CAAA,OAAAP,KAAA;IAAAO,CAAA,OAAAsE,GAAA;EAAA;IAAAA,GAAA,GAAAtE,CAAA;EAAA;EAAA,OAnCTsE,GAmCS;AAAA;AA3IN,SAAA5B,OAAA6B,MAAA;EAAA,OAmFuB7C,MAAI,CAAA8C,KAAM,CAAC,CAAC,EAAE,EAAE,CAAC;AAAA;AAnFxC,SAAAxC,OAAAyC,MAAA;EAAA,OAuD4B/C,MAAI,GAAG,CAAC;AAAA;AAvDpC,SAAAC,MAAA+C,MAAA;EAAA,OAsC4BhD,MAAI,GAAG,CAAC;AAAA","ignoreList":[]}

src/commands/plugin/PluginOptionsFlow.tsx

@@ -0,0 +1,135 @@
+/**
+ * Post-install/post-enable config prompt.
+ *
+ * Given a LoadedPlugin, checks both the top-level manifest.userConfig and the
+ * channel-specific userConfig. Walks PluginOptionsDialog through each
+ * unconfigured item, saving via the appropriate storage function. Calls
+ * onDone('skipped') immediately if nothing needs filling.
+ */
+
+import * as React from 'react';
+import type { LoadedPlugin } from '../../types/plugin.js';
+import { errorMessage } from '../../utils/errors.js';
+import { loadMcpServerUserConfig, saveMcpServerUserConfig } from '../../utils/plugins/mcpbHandler.js';
+import { getUnconfiguredChannels, type UnconfiguredChannel } from '../../utils/plugins/mcpPluginIntegration.js';
+import { loadAllPlugins } from '../../utils/plugins/pluginLoader.js';
+import { getUnconfiguredOptions, loadPluginOptions, type PluginOptionSchema, type PluginOptionValues, savePluginOptions } from '../../utils/plugins/pluginOptionsStorage.js';
+import { PluginOptionsDialog } from './PluginOptionsDialog.js';
+
+/**
+ * Post-install lookup: return the LoadedPlugin for the just-installed
+ * pluginId so the caller can divert to PluginOptionsFlow. Returns undefined
+ * if the plugin somehow didn't make it into the fresh load — callers treat
+ * undefined as "carry on closing."
+ *
+ * Install should have cleared caches already; loadAllPlugins reads fresh.
+ */
+export async function findPluginOptionsTarget(pluginId: string): Promise<LoadedPlugin | undefined> {
+  const {
+    enabled,
+    disabled
+  } = await loadAllPlugins();
+  return [...enabled, ...disabled].find(p => p.repository === pluginId || p.source === pluginId);
+}
+
+/**
+ * A single dialog step in the walk. Top-level options and channels both
+ * collapse to this shape — the only difference is which save function runs.
+ */
+type ConfigStep = {
+  key: string;
+  title: string;
+  subtitle: string;
+  schema: PluginOptionSchema;
+  /** Returns any already-saved values so PluginOptionsDialog can pre-fill and
+   *  skip unchanged sensitive fields on reconfigure. */
+  load: () => PluginOptionValues | undefined;
+  save: (values: PluginOptionValues) => void;
+};
+type Props = {
+  plugin: LoadedPlugin;
+  /** `name@marketplace` — the savePluginOptions / saveMcpServerUserConfig key. */
+  pluginId: string;
+  /**
+   * `configured` = user filled all fields. `skipped` = nothing needed
+   * configuring, or user hit cancel. `error` = save threw.
+   */
+  onDone: (outcome: 'configured' | 'skipped' | 'error', detail?: string) => void;
+};
+export function PluginOptionsFlow({
+  plugin,
+  pluginId,
+  onDone
+}: Props): React.ReactNode {
+  // Build the step list once at mount. Re-calling after a save would drop the
+  // item we just configured.
+  const [steps] = React.useState<ConfigStep[]>(() => {
+    const result: ConfigStep[] = [];
+
+    // Top-level manifest.userConfig
+    const unconfigured = getUnconfiguredOptions(plugin);
+    if (Object.keys(unconfigured).length > 0) {
+      result.push({
+        key: 'top-level',
+        title: `Configure ${plugin.name}`,
+        subtitle: 'Plugin options',
+        schema: unconfigured,
+        load: () => loadPluginOptions(pluginId),
+        save: values => savePluginOptions(pluginId, values, plugin.manifest.userConfig!)
+      });
+    }
+
+    // Per-channel userConfig (assistant-mode channels)
+    const channels: UnconfiguredChannel[] = getUnconfiguredChannels(plugin);
+    for (const channel of channels) {
+      result.push({
+        key: `channel:${channel.server}`,
+        title: `Configure ${channel.displayName}`,
+        subtitle: `Plugin: ${plugin.name}`,
+        schema: channel.configSchema,
+        load: () => loadMcpServerUserConfig(pluginId, channel.server) ?? undefined,
+        save: values_0 => saveMcpServerUserConfig(pluginId, channel.server, values_0, channel.configSchema)
+      });
+    }
+    return result;
+  });
+  const [index, setIndex] = React.useState(0);
+
+  // Latest-ref: lets the effect close over the current onDone without
+  // re-running when the parent re-renders.
+  const onDoneRef = React.useRef(onDone);
+  onDoneRef.current = onDone;
+
+  // Nothing to configure → tell the caller and render nothing. Effect,
+  // not inline call: calling setState in the parent during our render
+  // is a React rules-of-hooks violation.
+  React.useEffect(() => {
+    if (steps.length === 0) {
+      onDoneRef.current('skipped');
+    }
+  }, [steps.length]);
+  if (steps.length === 0) {
+    return null;
+  }
+  const current = steps[index]!;
+  function handleSave(values_1: PluginOptionValues): void {
+    try {
+      current.save(values_1);
+    } catch (err) {
+      onDone('error', errorMessage(err));
+      return;
+    }
+    const next = index + 1;
+    if (next < steps.length) {
+      setIndex(next);
+    } else {
+      onDone('configured');
+    }
+  }
+
+  // key forces a remount when advancing to the next step — React would
+  // otherwise reuse the instance and carry PluginOptionsDialog's
+  // internal useState (field index, typed values) over.
+  return <PluginOptionsDialog key={current.key} title={current.title} subtitle={current.subtitle} configSchema={current.schema} initialValues={current.load()} onSave={handleSave} onCancel={() => onDone('skipped')} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","LoadedPlugin","errorMessage","loadMcpServerUserConfig","saveMcpServerUserConfig","getUnconfiguredChannels","UnconfiguredChannel","loadAllPlugins","getUnconfiguredOptions","loadPluginOptions","PluginOptionSchema","PluginOptionValues","savePluginOptions","PluginOptionsDialog","findPluginOptionsTarget","pluginId","Promise","enabled","disabled","find","p","repository","source","ConfigStep","key","title","subtitle","schema","load","save","values","Props","plugin","onDone","outcome","detail","PluginOptionsFlow","ReactNode","steps","useState","result","unconfigured","Object","keys","length","push","name","manifest","userConfig","channels","channel","server","displayName","configSchema","undefined","index","setIndex","onDoneRef","useRef","current","useEffect","handleSave","err","next"],"sources":["PluginOptionsFlow.tsx"],"sourcesContent":["/**\n * Post-install/post-enable config prompt.\n *\n * Given a LoadedPlugin, checks both the top-level manifest.userConfig and the\n * channel-specific userConfig. Walks PluginOptionsDialog through each\n * unconfigured item, saving via the appropriate storage function. Calls\n * onDone('skipped') immediately if nothing needs filling.\n */\n\nimport * as React from 'react'\nimport type { LoadedPlugin } from '../../types/plugin.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport {\n  loadMcpServerUserConfig,\n  saveMcpServerUserConfig,\n} from '../../utils/plugins/mcpbHandler.js'\nimport {\n  getUnconfiguredChannels,\n  type UnconfiguredChannel,\n} from '../../utils/plugins/mcpPluginIntegration.js'\nimport { loadAllPlugins } from '../../utils/plugins/pluginLoader.js'\nimport {\n  getUnconfiguredOptions,\n  loadPluginOptions,\n  type PluginOptionSchema,\n  type PluginOptionValues,\n  savePluginOptions,\n} from '../../utils/plugins/pluginOptionsStorage.js'\nimport { PluginOptionsDialog } from './PluginOptionsDialog.js'\n\n/**\n * Post-install lookup: return the LoadedPlugin for the just-installed\n * pluginId so the caller can divert to PluginOptionsFlow. Returns undefined\n * if the plugin somehow didn't make it into the fresh load — callers treat\n * undefined as \"carry on closing.\"\n *\n * Install should have cleared caches already; loadAllPlugins reads fresh.\n */\nexport async function findPluginOptionsTarget(\n  pluginId: string,\n): Promise<LoadedPlugin | undefined> {\n  const { enabled, disabled } = await loadAllPlugins()\n  return [...enabled, ...disabled].find(\n    p => p.repository === pluginId || p.source === pluginId,\n  )\n}\n\n/**\n * A single dialog step in the walk. Top-level options and channels both\n * collapse to this shape — the only difference is which save function runs.\n */\ntype ConfigStep = {\n  key: string\n  title: string\n  subtitle: string\n  schema: PluginOptionSchema\n  /** Returns any already-saved values so PluginOptionsDialog can pre-fill and\n   *  skip unchanged sensitive fields on reconfigure. */\n  load: () => PluginOptionValues | undefined\n  save: (values: PluginOptionValues) => void\n}\n\ntype Props = {\n  plugin: LoadedPlugin\n  /** `name@marketplace` — the savePluginOptions / saveMcpServerUserConfig key. */\n  pluginId: string\n  /**\n   * `configured` = user filled all fields. `skipped` = nothing needed\n   * configuring, or user hit cancel. `error` = save threw.\n   */\n  onDone: (outcome: 'configured' | 'skipped' | 'error', detail?: string) => void\n}\n\nexport function PluginOptionsFlow({\n  plugin,\n  pluginId,\n  onDone,\n}: Props): React.ReactNode {\n  // Build the step list once at mount. Re-calling after a save would drop the\n  // item we just configured.\n  const [steps] = React.useState<ConfigStep[]>(() => {\n    const result: ConfigStep[] = []\n\n    // Top-level manifest.userConfig\n    const unconfigured = getUnconfiguredOptions(plugin)\n    if (Object.keys(unconfigured).length > 0) {\n      result.push({\n        key: 'top-level',\n        title: `Configure ${plugin.name}`,\n        subtitle: 'Plugin options',\n        schema: unconfigured,\n        load: () => loadPluginOptions(pluginId),\n        save: values =>\n          savePluginOptions(pluginId, values, plugin.manifest.userConfig!),\n      })\n    }\n\n    // Per-channel userConfig (assistant-mode channels)\n    const channels: UnconfiguredChannel[] = getUnconfiguredChannels(plugin)\n    for (const channel of channels) {\n      result.push({\n        key: `channel:${channel.server}`,\n        title: `Configure ${channel.displayName}`,\n        subtitle: `Plugin: ${plugin.name}`,\n        schema: channel.configSchema,\n        load: () =>\n          loadMcpServerUserConfig(pluginId, channel.server) ?? undefined,\n        save: values =>\n          saveMcpServerUserConfig(\n            pluginId,\n            channel.server,\n            values,\n            channel.configSchema,\n          ),\n      })\n    }\n\n    return result\n  })\n\n  const [index, setIndex] = React.useState(0)\n\n  // Latest-ref: lets the effect close over the current onDone without\n  // re-running when the parent re-renders.\n  const onDoneRef = React.useRef(onDone)\n  onDoneRef.current = onDone\n\n  // Nothing to configure → tell the caller and render nothing. Effect,\n  // not inline call: calling setState in the parent during our render\n  // is a React rules-of-hooks violation.\n  React.useEffect(() => {\n    if (steps.length === 0) {\n      onDoneRef.current('skipped')\n    }\n  }, [steps.length])\n\n  if (steps.length === 0) {\n    return null\n  }\n\n  const current = steps[index]!\n\n  function handleSave(values: PluginOptionValues): void {\n    try {\n      current.save(values)\n    } catch (err) {\n      onDone('error', errorMessage(err))\n      return\n    }\n    const next = index + 1\n    if (next < steps.length) {\n      setIndex(next)\n    } else {\n      onDone('configured')\n    }\n  }\n\n  // key forces a remount when advancing to the next step — React would\n  // otherwise reuse the instance and carry PluginOptionsDialog's\n  // internal useState (field index, typed values) over.\n  return (\n    <PluginOptionsDialog\n      key={current.key}\n      title={current.title}\n      subtitle={current.subtitle}\n      configSchema={current.schema}\n      initialValues={current.load()}\n      onSave={handleSave}\n      onCancel={() => onDone('skipped')}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/commands/plugin/PluginTrustWarning.tsx

@@ -0,0 +1,32 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import * as React from 'react';
+import { Box, Text } from '../../ink.js';
+import { getPluginTrustMessage } from '../../utils/plugins/marketplaceHelpers.js';
+export function PluginTrustWarning() {
+  const $ = _c(3);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = getPluginTrustMessage();
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const customMessage = t0;
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <Text color="claude">{figures.warning} </Text>;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Box marginBottom={1}>{t1}<Text dimColor={true} italic={true}>Make sure you trust a plugin before installing, updating, or using it. Anthropic does not control what MCP servers, files, or other software are included in plugins and cannot verify that they will work as intended or that they won't change. See each plugin's homepage for more information.{customMessage ? ` ${customMessage}` : ""}</Text></Box>;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/commands/plugin/UnifiedInstalledCell.tsx

@@ -0,0 +1,565 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import * as React from 'react';
+import { Box, color, Text, useTheme } from '../../ink.js';
+import { plural } from '../../utils/stringUtils.js';
+import type { UnifiedInstalledItem } from './unifiedTypes.js';
+type Props = {
+  item: UnifiedInstalledItem;
+  isSelected: boolean;
+};
+export function UnifiedInstalledCell(t0) {
+  const $ = _c(142);
+  const {
+    item,
+    isSelected
+  } = t0;
+  const [theme] = useTheme();
+  if (item.type === "plugin") {
+    let statusIcon;
+    let statusText;
+    if (item.pendingToggle) {
+      let t1;
+      if ($[0] !== theme) {
+        t1 = color("suggestion", theme)(figures.arrowRight);
+        $[0] = theme;
+        $[1] = t1;
+      } else {
+        t1 = $[1];
+      }
+      statusIcon = t1;
+      statusText = item.pendingToggle === "will-enable" ? "will enable" : "will disable";
+    } else {
+      if (item.errorCount > 0) {
+        let t1;
+        if ($[2] !== theme) {
+          t1 = color("error", theme)(figures.cross);
+          $[2] = theme;
+          $[3] = t1;
+        } else {
+          t1 = $[3];
+        }
+        statusIcon = t1;
+        const t2 = item.errorCount;
+        let t3;
+        if ($[4] !== item.errorCount) {
+          t3 = plural(item.errorCount, "error");
+          $[4] = item.errorCount;
+          $[5] = t3;
+        } else {
+          t3 = $[5];
+        }
+        statusText = `${t2} ${t3}`;
+      } else {
+        if (!item.isEnabled) {
+          let t1;
+          if ($[6] !== theme) {
+            t1 = color("inactive", theme)(figures.radioOff);
+            $[6] = theme;
+            $[7] = t1;
+          } else {
+            t1 = $[7];
+          }
+          statusIcon = t1;
+          statusText = "disabled";
+        } else {
+          let t1;
+          if ($[8] !== theme) {
+            t1 = color("success", theme)(figures.tick);
+            $[8] = theme;
+            $[9] = t1;
+          } else {
+            t1 = $[9];
+          }
+          statusIcon = t1;
+          statusText = "enabled";
+        }
+      }
+    }
+    const t1 = isSelected ? "suggestion" : undefined;
+    const t2 = isSelected ? `${figures.pointer} ` : "  ";
+    let t3;
+    if ($[10] !== t1 || $[11] !== t2) {
+      t3 = <Text color={t1}>{t2}</Text>;
+      $[10] = t1;
+      $[11] = t2;
+      $[12] = t3;
+    } else {
+      t3 = $[12];
+    }
+    const t4 = isSelected ? "suggestion" : undefined;
+    let t5;
+    if ($[13] !== item.name || $[14] !== t4) {
+      t5 = <Text color={t4}>{item.name}</Text>;
+      $[13] = item.name;
+      $[14] = t4;
+      $[15] = t5;
+    } else {
+      t5 = $[15];
+    }
+    const t6 = !isSelected;
+    let t7;
+    if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+      t7 = <Text backgroundColor="userMessageBackground">Plugin</Text>;
+      $[16] = t7;
+    } else {
+      t7 = $[16];
+    }
+    let t8;
+    if ($[17] !== t6) {
+      t8 = <Text dimColor={t6}>{" "}{t7}</Text>;
+      $[17] = t6;
+      $[18] = t8;
+    } else {
+      t8 = $[18];
+    }
+    let t9;
+    if ($[19] !== item.marketplace) {
+      t9 = <Text dimColor={true}> · {item.marketplace}</Text>;
+      $[19] = item.marketplace;
+      $[20] = t9;
+    } else {
+      t9 = $[20];
+    }
+    const t10 = !isSelected;
+    let t11;
+    if ($[21] !== statusIcon || $[22] !== t10) {
+      t11 = <Text dimColor={t10}> · {statusIcon} </Text>;
+      $[21] = statusIcon;
+      $[22] = t10;
+      $[23] = t11;
+    } else {
+      t11 = $[23];
+    }
+    const t12 = !isSelected;
+    let t13;
+    if ($[24] !== statusText || $[25] !== t12) {
+      t13 = <Text dimColor={t12}>{statusText}</Text>;
+      $[24] = statusText;
+      $[25] = t12;
+      $[26] = t13;
+    } else {
+      t13 = $[26];
+    }
+    let t14;
+    if ($[27] !== t11 || $[28] !== t13 || $[29] !== t3 || $[30] !== t5 || $[31] !== t8 || $[32] !== t9) {
+      t14 = <Box>{t3}{t5}{t8}{t9}{t11}{t13}</Box>;
+      $[27] = t11;
+      $[28] = t13;
+      $[29] = t3;
+      $[30] = t5;
+      $[31] = t8;
+      $[32] = t9;
+      $[33] = t14;
+    } else {
+      t14 = $[33];
+    }
+    return t14;
+  }
+  if (item.type === "flagged-plugin") {
+    let t1;
+    if ($[34] !== theme) {
+      t1 = color("warning", theme)(figures.warning);
+      $[34] = theme;
+      $[35] = t1;
+    } else {
+      t1 = $[35];
+    }
+    const statusIcon_0 = t1;
+    const t2 = isSelected ? "suggestion" : undefined;
+    const t3 = isSelected ? `${figures.pointer} ` : "  ";
+    let t4;
+    if ($[36] !== t2 || $[37] !== t3) {
+      t4 = <Text color={t2}>{t3}</Text>;
+      $[36] = t2;
+      $[37] = t3;
+      $[38] = t4;
+    } else {
+      t4 = $[38];
+    }
+    const t5 = isSelected ? "suggestion" : undefined;
+    let t6;
+    if ($[39] !== item.name || $[40] !== t5) {
+      t6 = <Text color={t5}>{item.name}</Text>;
+      $[39] = item.name;
+      $[40] = t5;
+      $[41] = t6;
+    } else {
+      t6 = $[41];
+    }
+    const t7 = !isSelected;
+    let t8;
+    if ($[42] === Symbol.for("react.memo_cache_sentinel")) {
+      t8 = <Text backgroundColor="userMessageBackground">Plugin</Text>;
+      $[42] = t8;
+    } else {
+      t8 = $[42];
+    }
+    let t9;
+    if ($[43] !== t7) {
+      t9 = <Text dimColor={t7}>{" "}{t8}</Text>;
+      $[43] = t7;
+      $[44] = t9;
+    } else {
+      t9 = $[44];
+    }
+    let t10;
+    if ($[45] !== item.marketplace) {
+      t10 = <Text dimColor={true}> · {item.marketplace}</Text>;
+      $[45] = item.marketplace;
+      $[46] = t10;
+    } else {
+      t10 = $[46];
+    }
+    const t11 = !isSelected;
+    let t12;
+    if ($[47] !== statusIcon_0 || $[48] !== t11) {
+      t12 = <Text dimColor={t11}> · {statusIcon_0} </Text>;
+      $[47] = statusIcon_0;
+      $[48] = t11;
+      $[49] = t12;
+    } else {
+      t12 = $[49];
+    }
+    const t13 = !isSelected;
+    let t14;
+    if ($[50] !== t13) {
+      t14 = <Text dimColor={t13}>removed</Text>;
+      $[50] = t13;
+      $[51] = t14;
+    } else {
+      t14 = $[51];
+    }
+    let t15;
+    if ($[52] !== t10 || $[53] !== t12 || $[54] !== t14 || $[55] !== t4 || $[56] !== t6 || $[57] !== t9) {
+      t15 = <Box>{t4}{t6}{t9}{t10}{t12}{t14}</Box>;
+      $[52] = t10;
+      $[53] = t12;
+      $[54] = t14;
+      $[55] = t4;
+      $[56] = t6;
+      $[57] = t9;
+      $[58] = t15;
+    } else {
+      t15 = $[58];
+    }
+    return t15;
+  }
+  if (item.type === "failed-plugin") {
+    let t1;
+    if ($[59] !== theme) {
+      t1 = color("error", theme)(figures.cross);
+      $[59] = theme;
+      $[60] = t1;
+    } else {
+      t1 = $[60];
+    }
+    const statusIcon_1 = t1;
+    const t2 = item.errorCount;
+    let t3;
+    if ($[61] !== item.errorCount) {
+      t3 = plural(item.errorCount, "error");
+      $[61] = item.errorCount;
+      $[62] = t3;
+    } else {
+      t3 = $[62];
+    }
+    const statusText_0 = `failed to load · ${t2} ${t3}`;
+    const t4 = isSelected ? "suggestion" : undefined;
+    const t5 = isSelected ? `${figures.pointer} ` : "  ";
+    let t6;
+    if ($[63] !== t4 || $[64] !== t5) {
+      t6 = <Text color={t4}>{t5}</Text>;
+      $[63] = t4;
+      $[64] = t5;
+      $[65] = t6;
+    } else {
+      t6 = $[65];
+    }
+    const t7 = isSelected ? "suggestion" : undefined;
+    let t8;
+    if ($[66] !== item.name || $[67] !== t7) {
+      t8 = <Text color={t7}>{item.name}</Text>;
+      $[66] = item.name;
+      $[67] = t7;
+      $[68] = t8;
+    } else {
+      t8 = $[68];
+    }
+    const t9 = !isSelected;
+    let t10;
+    if ($[69] === Symbol.for("react.memo_cache_sentinel")) {
+      t10 = <Text backgroundColor="userMessageBackground">Plugin</Text>;
+      $[69] = t10;
+    } else {
+      t10 = $[69];
+    }
+    let t11;
+    if ($[70] !== t9) {
+      t11 = <Text dimColor={t9}>{" "}{t10}</Text>;
+      $[70] = t9;
+      $[71] = t11;
+    } else {
+      t11 = $[71];
+    }
+    let t12;
+    if ($[72] !== item.marketplace) {
+      t12 = <Text dimColor={true}> · {item.marketplace}</Text>;
+      $[72] = item.marketplace;
+      $[73] = t12;
+    } else {
+      t12 = $[73];
+    }
+    const t13 = !isSelected;
+    let t14;
+    if ($[74] !== statusIcon_1 || $[75] !== t13) {
+      t14 = <Text dimColor={t13}> · {statusIcon_1} </Text>;
+      $[74] = statusIcon_1;
+      $[75] = t13;
+      $[76] = t14;
+    } else {
+      t14 = $[76];
+    }
+    const t15 = !isSelected;
+    let t16;
+    if ($[77] !== statusText_0 || $[78] !== t15) {
+      t16 = <Text dimColor={t15}>{statusText_0}</Text>;
+      $[77] = statusText_0;
+      $[78] = t15;
+      $[79] = t16;
+    } else {
+      t16 = $[79];
+    }
+    let t17;
+    if ($[80] !== t11 || $[81] !== t12 || $[82] !== t14 || $[83] !== t16 || $[84] !== t6 || $[85] !== t8) {
+      t17 = <Box>{t6}{t8}{t11}{t12}{t14}{t16}</Box>;
+      $[80] = t11;
+      $[81] = t12;
+      $[82] = t14;
+      $[83] = t16;
+      $[84] = t6;
+      $[85] = t8;
+      $[86] = t17;
+    } else {
+      t17 = $[86];
+    }
+    return t17;
+  }
+  let statusIcon_2;
+  let statusText_1;
+  if (item.status === "connected") {
+    let t1;
+    if ($[87] !== theme) {
+      t1 = color("success", theme)(figures.tick);
+      $[87] = theme;
+      $[88] = t1;
+    } else {
+      t1 = $[88];
+    }
+    statusIcon_2 = t1;
+    statusText_1 = "connected";
+  } else {
+    if (item.status === "disabled") {
+      let t1;
+      if ($[89] !== theme) {
+        t1 = color("inactive", theme)(figures.radioOff);
+        $[89] = theme;
+        $[90] = t1;
+      } else {
+        t1 = $[90];
+      }
+      statusIcon_2 = t1;
+      statusText_1 = "disabled";
+    } else {
+      if (item.status === "pending") {
+        let t1;
+        if ($[91] !== theme) {
+          t1 = color("inactive", theme)(figures.radioOff);
+          $[91] = theme;
+          $[92] = t1;
+        } else {
+          t1 = $[92];
+        }
+        statusIcon_2 = t1;
+        statusText_1 = "connecting\u2026";
+      } else {
+        if (item.status === "needs-auth") {
+          let t1;
+          if ($[93] !== theme) {
+            t1 = color("warning", theme)(figures.triangleUpOutline);
+            $[93] = theme;
+            $[94] = t1;
+          } else {
+            t1 = $[94];
+          }
+          statusIcon_2 = t1;
+          statusText_1 = "Enter to auth";
+        } else {
+          let t1;
+          if ($[95] !== theme) {
+            t1 = color("error", theme)(figures.cross);
+            $[95] = theme;
+            $[96] = t1;
+          } else {
+            t1 = $[96];
+          }
+          statusIcon_2 = t1;
+          statusText_1 = "failed";
+        }
+      }
+    }
+  }
+  if (item.indented) {
+    const t1 = isSelected ? "suggestion" : undefined;
+    const t2 = isSelected ? `${figures.pointer} ` : "  ";
+    let t3;
+    if ($[97] !== t1 || $[98] !== t2) {
+      t3 = <Text color={t1}>{t2}</Text>;
+      $[97] = t1;
+      $[98] = t2;
+      $[99] = t3;
+    } else {
+      t3 = $[99];
+    }
+    const t4 = !isSelected;
+    let t5;
+    if ($[100] !== t4) {
+      t5 = <Text dimColor={t4}>└ </Text>;
+      $[100] = t4;
+      $[101] = t5;
+    } else {
+      t5 = $[101];
+    }
+    const t6 = isSelected ? "suggestion" : undefined;
+    let t7;
+    if ($[102] !== item.name || $[103] !== t6) {
+      t7 = <Text color={t6}>{item.name}</Text>;
+      $[102] = item.name;
+      $[103] = t6;
+      $[104] = t7;
+    } else {
+      t7 = $[104];
+    }
+    const t8 = !isSelected;
+    let t9;
+    if ($[105] === Symbol.for("react.memo_cache_sentinel")) {
+      t9 = <Text backgroundColor="userMessageBackground">MCP</Text>;
+      $[105] = t9;
+    } else {
+      t9 = $[105];
+    }
+    let t10;
+    if ($[106] !== t8) {
+      t10 = <Text dimColor={t8}>{" "}{t9}</Text>;
+      $[106] = t8;
+      $[107] = t10;
+    } else {
+      t10 = $[107];
+    }
+    const t11 = !isSelected;
+    let t12;
+    if ($[108] !== statusIcon_2 || $[109] !== t11) {
+      t12 = <Text dimColor={t11}> · {statusIcon_2} </Text>;
+      $[108] = statusIcon_2;
+      $[109] = t11;
+      $[110] = t12;
+    } else {
+      t12 = $[110];
+    }
+    const t13 = !isSelected;
+    let t14;
+    if ($[111] !== statusText_1 || $[112] !== t13) {
+      t14 = <Text dimColor={t13}>{statusText_1}</Text>;
+      $[111] = statusText_1;
+      $[112] = t13;
+      $[113] = t14;
+    } else {
+      t14 = $[113];
+    }
+    let t15;
+    if ($[114] !== t10 || $[115] !== t12 || $[116] !== t14 || $[117] !== t3 || $[118] !== t5 || $[119] !== t7) {
+      t15 = <Box>{t3}{t5}{t7}{t10}{t12}{t14}</Box>;
+      $[114] = t10;
+      $[115] = t12;
+      $[116] = t14;
+      $[117] = t3;
+      $[118] = t5;
+      $[119] = t7;
+      $[120] = t15;
+    } else {
+      t15 = $[120];
+    }
+    return t15;
+  }
+  const t1 = isSelected ? "suggestion" : undefined;
+  const t2 = isSelected ? `${figures.pointer} ` : "  ";
+  let t3;
+  if ($[121] !== t1 || $[122] !== t2) {
+    t3 = <Text color={t1}>{t2}</Text>;
+    $[121] = t1;
+    $[122] = t2;
+    $[123] = t3;
+  } else {
+    t3 = $[123];
+  }
+  const t4 = isSelected ? "suggestion" : undefined;
+  let t5;
+  if ($[124] !== item.name || $[125] !== t4) {
+    t5 = <Text color={t4}>{item.name}</Text>;
+    $[124] = item.name;
+    $[125] = t4;
+    $[126] = t5;
+  } else {
+    t5 = $[126];
+  }
+  const t6 = !isSelected;
+  let t7;
+  if ($[127] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = <Text backgroundColor="userMessageBackground">MCP</Text>;
+    $[127] = t7;
+  } else {
+    t7 = $[127];
+  }
+  let t8;
+  if ($[128] !== t6) {
+    t8 = <Text dimColor={t6}>{" "}{t7}</Text>;
+    $[128] = t6;
+    $[129] = t8;
+  } else {
+    t8 = $[129];
+  }
+  const t9 = !isSelected;
+  let t10;
+  if ($[130] !== statusIcon_2 || $[131] !== t9) {
+    t10 = <Text dimColor={t9}> · {statusIcon_2} </Text>;
+    $[130] = statusIcon_2;
+    $[131] = t9;
+    $[132] = t10;
+  } else {
+    t10 = $[132];
+  }
+  const t11 = !isSelected;
+  let t12;
+  if ($[133] !== statusText_1 || $[134] !== t11) {
+    t12 = <Text dimColor={t11}>{statusText_1}</Text>;
+    $[133] = statusText_1;
+    $[134] = t11;
+    $[135] = t12;
+  } else {
+    t12 = $[135];
+  }
+  let t13;
+  if ($[136] !== t10 || $[137] !== t12 || $[138] !== t3 || $[139] !== t5 || $[140] !== t8) {
+    t13 = <Box>{t3}{t5}{t8}{t10}{t12}</Box>;
+    $[136] = t10;
+    $[137] = t12;
+    $[138] = t3;
+    $[139] = t5;
+    $[140] = t8;
+    $[141] = t13;
+  } else {
+    t13 = $[141];
+  }
+  return t13;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","Box","color","Text","useTheme","plural","UnifiedInstalledItem","Props","item","isSelected","UnifiedInstalledCell","t0","$","_c","theme","type","statusIcon","statusText","pendingToggle","t1","arrowRight","errorCount","cross","t2","t3","isEnabled","radioOff","tick","undefined","pointer","t4","t5","name","t6","t7","Symbol","for","t8","t9","marketplace","t10","t11","t12","t13","t14","warning","statusIcon_0","t15","statusIcon_1","statusText_0","t16","t17","status","triangleUpOutline","indented","statusIcon_2","statusText_1"],"sources":["UnifiedInstalledCell.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { Box, color, Text, useTheme } from '../../ink.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport type { UnifiedInstalledItem } from './unifiedTypes.js'\n\ntype Props = {\n  item: UnifiedInstalledItem\n  isSelected: boolean\n}\n\nexport function UnifiedInstalledCell({\n  item,\n  isSelected,\n}: Props): React.ReactNode {\n  const [theme] = useTheme()\n\n  if (item.type === 'plugin') {\n    // Status icon and text\n    let statusIcon: string\n    let statusText: string\n\n    // Show pending toggle status if set, otherwise show current status\n    if (item.pendingToggle) {\n      statusIcon = color('suggestion', theme)(figures.arrowRight)\n      statusText =\n        item.pendingToggle === 'will-enable' ? 'will enable' : 'will disable'\n    } else if (item.errorCount > 0) {\n      statusIcon = color('error', theme)(figures.cross)\n      statusText = `${item.errorCount} ${plural(item.errorCount, 'error')}`\n    } else if (!item.isEnabled) {\n      statusIcon = color('inactive', theme)(figures.radioOff)\n      statusText = 'disabled'\n    } else {\n      statusIcon = color('success', theme)(figures.tick)\n      statusText = 'enabled'\n    }\n\n    return (\n      <Box>\n        <Text color={isSelected ? 'suggestion' : undefined}>\n          {isSelected ? `${figures.pointer} ` : '  '}\n        </Text>\n        <Text color={isSelected ? 'suggestion' : undefined}>{item.name}</Text>\n        <Text dimColor={!isSelected}>\n          {' '}\n          <Text backgroundColor=\"userMessageBackground\">Plugin</Text>\n        </Text>\n        <Text dimColor> · {item.marketplace}</Text>\n        <Text dimColor={!isSelected}> · {statusIcon} </Text>\n        <Text dimColor={!isSelected}>{statusText}</Text>\n      </Box>\n    )\n  }\n\n  if (item.type === 'flagged-plugin') {\n    const statusIcon = color('warning', theme)(figures.warning)\n\n    return (\n      <Box>\n        <Text color={isSelected ? 'suggestion' : undefined}>\n          {isSelected ? `${figures.pointer} ` : '  '}\n        </Text>\n        <Text color={isSelected ? 'suggestion' : undefined}>{item.name}</Text>\n        <Text dimColor={!isSelected}>\n          {' '}\n          <Text backgroundColor=\"userMessageBackground\">Plugin</Text>\n        </Text>\n        <Text dimColor> · {item.marketplace}</Text>\n        <Text dimColor={!isSelected}> · {statusIcon} </Text>\n        <Text dimColor={!isSelected}>removed</Text>\n      </Box>\n    )\n  }\n\n  if (item.type === 'failed-plugin') {\n    const statusIcon = color('error', theme)(figures.cross)\n    const statusText = `failed to load · ${item.errorCount} ${plural(item.errorCount, 'error')}`\n\n    return (\n      <Box>\n        <Text color={isSelected ? 'suggestion' : undefined}>\n          {isSelected ? `${figures.pointer} ` : '  '}\n        </Text>\n        <Text color={isSelected ? 'suggestion' : undefined}>{item.name}</Text>\n        <Text dimColor={!isSelected}>\n          {' '}\n          <Text backgroundColor=\"userMessageBackground\">Plugin</Text>\n        </Text>\n        <Text dimColor> · {item.marketplace}</Text>\n        <Text dimColor={!isSelected}> · {statusIcon} </Text>\n        <Text dimColor={!isSelected}>{statusText}</Text>\n      </Box>\n    )\n  }\n\n  // MCP server\n  let statusIcon: string\n  let statusText: string\n\n  if (item.status === 'connected') {\n    statusIcon = color('success', theme)(figures.tick)\n    statusText = 'connected'\n  } else if (item.status === 'disabled') {\n    statusIcon = color('inactive', theme)(figures.radioOff)\n    statusText = 'disabled'\n  } else if (item.status === 'pending') {\n    statusIcon = color('inactive', theme)(figures.radioOff)\n    statusText = 'connecting…'\n  } else if (item.status === 'needs-auth') {\n    statusIcon = color('warning', theme)(figures.triangleUpOutline)\n    statusText = 'Enter to auth'\n  } else {\n    statusIcon = color('error', theme)(figures.cross)\n    statusText = 'failed'\n  }\n\n  // Indented MCPs (child of a plugin)\n  if (item.indented) {\n    return (\n      <Box>\n        <Text color={isSelected ? 'suggestion' : undefined}>\n          {isSelected ? `${figures.pointer} ` : '  '}\n        </Text>\n        <Text dimColor={!isSelected}>└ </Text>\n        <Text color={isSelected ? 'suggestion' : undefined}>{item.name}</Text>\n        <Text dimColor={!isSelected}>\n          {' '}\n          <Text backgroundColor=\"userMessageBackground\">MCP</Text>\n        </Text>\n        <Text dimColor={!isSelected}> · {statusIcon} </Text>\n        <Text dimColor={!isSelected}>{statusText}</Text>\n      </Box>\n    )\n  }\n\n  return (\n    <Box>\n      <Text color={isSelected ? 'suggestion' : undefined}>\n        {isSelected ? `${figures.pointer} ` : '  '}\n      </Text>\n      <Text color={isSelected ? 'suggestion' : undefined}>{item.name}</Text>\n      <Text dimColor={!isSelected}>\n        {' '}\n        <Text backgroundColor=\"userMessageBackground\">MCP</Text>\n      </Text>\n      <Text dimColor={!isSelected}> · {statusIcon} </Text>\n      <Text dimColor={!isSelected}>{statusText}</Text>\n    </Box>\n  )\n}\n"],"mappings":";AAAA,OAAOA,OAAO,MAAM,SAAS;AAC7B,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,SAASC,GAAG,EAAEC,KAAK,EAAEC,IAAI,EAAEC,QAAQ,QAAQ,cAAc;AACzD,SAASC,MAAM,QAAQ,4BAA4B;AACnD,cAAcC,oBAAoB,QAAQ,mBAAmB;AAE7D,KAAKC,KAAK,GAAG;EACXC,IAAI,EAAEF,oBAAoB;EAC1BG,UAAU,EAAE,OAAO;AACrB,CAAC;AAED,OAAO,SAAAC,qBAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAA8B;IAAAL,IAAA;IAAAC;EAAA,IAAAE,EAG7B;EACN,OAAAG,KAAA,IAAgBV,QAAQ,CAAC,CAAC;EAE1B,IAAII,IAAI,CAAAO,IAAK,KAAK,QAAQ;IAEpBC,GAAA,CAAAA,UAAA;IACAC,GAAA,CAAAA,UAAA;IAGJ,IAAIT,IAAI,CAAAU,aAAc;MAAA,IAAAC,EAAA;MAAA,IAAAP,CAAA,QAAAE,KAAA;QACPK,EAAA,GAAAjB,KAAK,CAAC,YAAY,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAAqB,UAAW,CAAC;QAAAR,CAAA,MAAAE,KAAA;QAAAF,CAAA,MAAAO,EAAA;MAAA;QAAAA,EAAA,GAAAP,CAAA;MAAA;MAA3DI,UAAA,CAAAA,CAAA,CAAaA,EAA8C;MAC3DC,UAAA,CAAAA,CAAA,CACET,IAAI,CAAAU,aAAc,KAAK,aAA8C,GAArE,aAAqE,GAArE,cAAqE;IAD7D;MAEL,IAAIV,IAAI,CAAAa,UAAW,GAAG,CAAC;QAAA,IAAAF,EAAA;QAAA,IAAAP,CAAA,QAAAE,KAAA;UACfK,EAAA,GAAAjB,KAAK,CAAC,OAAO,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAAuB,KAAM,CAAC;UAAAV,CAAA,MAAAE,KAAA;UAAAF,CAAA,MAAAO,EAAA;QAAA;UAAAA,EAAA,GAAAP,CAAA;QAAA;QAAjDI,UAAA,CAAAA,CAAA,CAAaA,EAAoC;QACjC,MAAAO,EAAA,GAAAf,IAAI,CAAAa,UAAW;QAAA,IAAAG,EAAA;QAAA,IAAAZ,CAAA,QAAAJ,IAAA,CAAAa,UAAA;UAAIG,EAAA,GAAAnB,MAAM,CAACG,IAAI,CAAAa,UAAW,EAAE,OAAO,CAAC;UAAAT,CAAA,MAAAJ,IAAA,CAAAa,UAAA;UAAAT,CAAA,MAAAY,EAAA;QAAA;UAAAA,EAAA,GAAAZ,CAAA;QAAA;QAAnEK,UAAA,CAAAA,CAAA,CAAaA,GAAGA,EAAeA,IAAIA,EAAgCA,EAAE;MAA3D;QACL,IAAI,CAACT,IAAI,CAAAiB,SAAU;UAAA,IAAAN,EAAA;UAAA,IAAAP,CAAA,QAAAE,KAAA;YACXK,EAAA,GAAAjB,KAAK,CAAC,UAAU,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAA2B,QAAS,CAAC;YAAAd,CAAA,MAAAE,KAAA;YAAAF,CAAA,MAAAO,EAAA;UAAA;YAAAA,EAAA,GAAAP,CAAA;UAAA;UAAvDI,UAAA,CAAAA,CAAA,CAAaA,EAA0C;UACvDC,UAAA,CAAAA,CAAA,CAAaA,UAAU;QAAb;UAAA,IAAAE,EAAA;UAAA,IAAAP,CAAA,QAAAE,KAAA;YAEGK,EAAA,GAAAjB,KAAK,CAAC,SAAS,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAA4B,IAAK,CAAC;YAAAf,CAAA,MAAAE,KAAA;YAAAF,CAAA,MAAAO,EAAA;UAAA;YAAAA,EAAA,GAAAP,CAAA;UAAA;UAAlDI,UAAA,CAAAA,CAAA,CAAaA,EAAqC;UAClDC,UAAA,CAAAA,CAAA,CAAaA,SAAS;QAAZ;MACX;IAAA;IAIgB,MAAAE,EAAA,GAAAV,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;IAC/C,MAAAL,EAAA,GAAAd,UAAU,GAAV,GAAgBV,OAAO,CAAA8B,OAAQ,GAAU,GAAzC,IAAyC;IAAA,IAAAL,EAAA;IAAA,IAAAZ,CAAA,SAAAO,EAAA,IAAAP,CAAA,SAAAW,EAAA;MAD5CC,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAL,EAAoC,CAAC,CAC/C,CAAAI,EAAwC,CAC3C,EAFC,IAAI,CAEE;MAAAX,CAAA,OAAAO,EAAA;MAAAP,CAAA,OAAAW,EAAA;MAAAX,CAAA,OAAAY,EAAA;IAAA;MAAAA,EAAA,GAAAZ,CAAA;IAAA;IACM,MAAAkB,EAAA,GAAArB,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;IAAA,IAAAG,EAAA;IAAA,IAAAnB,CAAA,SAAAJ,IAAA,CAAAwB,IAAA,IAAApB,CAAA,SAAAkB,EAAA;MAAlDC,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAD,EAAoC,CAAC,CAAG,CAAAtB,IAAI,CAAAwB,IAAI,CAAE,EAA9D,IAAI,CAAiE;MAAApB,CAAA,OAAAJ,IAAA,CAAAwB,IAAA;MAAApB,CAAA,OAAAkB,EAAA;MAAAlB,CAAA,OAAAmB,EAAA;IAAA;MAAAA,EAAA,GAAAnB,CAAA;IAAA;IACtD,MAAAqB,EAAA,IAACxB,UAAU;IAAA,IAAAyB,EAAA;IAAA,IAAAtB,CAAA,SAAAuB,MAAA,CAAAC,GAAA;MAEzBF,EAAA,IAAC,IAAI,CAAiB,eAAuB,CAAvB,uBAAuB,CAAC,MAAM,EAAnD,IAAI,CAAsD;MAAAtB,CAAA,OAAAsB,EAAA;IAAA;MAAAA,EAAA,GAAAtB,CAAA;IAAA;IAAA,IAAAyB,EAAA;IAAA,IAAAzB,CAAA,SAAAqB,EAAA;MAF7DI,EAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAJ,EAAU,CAAC,CACxB,IAAE,CACH,CAAAC,EAA0D,CAC5D,EAHC,IAAI,CAGE;MAAAtB,CAAA,OAAAqB,EAAA;MAAArB,CAAA,OAAAyB,EAAA;IAAA;MAAAA,EAAA,GAAAzB,CAAA;IAAA;IAAA,IAAA0B,EAAA;IAAA,IAAA1B,CAAA,SAAAJ,IAAA,CAAA+B,WAAA;MACPD,EAAA,IAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,GAAI,CAAA9B,IAAI,CAAA+B,WAAW,CAAE,EAAnC,IAAI,CAAsC;MAAA3B,CAAA,OAAAJ,IAAA,CAAA+B,WAAA;MAAA3B,CAAA,OAAA0B,EAAA;IAAA;MAAAA,EAAA,GAAA1B,CAAA;IAAA;IAC3B,MAAA4B,GAAA,IAAC/B,UAAU;IAAA,IAAAgC,GAAA;IAAA,IAAA7B,CAAA,SAAAI,UAAA,IAAAJ,CAAA,SAAA4B,GAAA;MAA3BC,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,GAAU,CAAC,CAAE,GAAIxB,WAAS,CAAE,CAAC,EAA5C,IAAI,CAA+C;MAAAJ,CAAA,OAAAI,UAAA;MAAAJ,CAAA,OAAA4B,GAAA;MAAA5B,CAAA,OAAA6B,GAAA;IAAA;MAAAA,GAAA,GAAA7B,CAAA;IAAA;IACpC,MAAA8B,GAAA,IAACjC,UAAU;IAAA,IAAAkC,GAAA;IAAA,IAAA/B,CAAA,SAAAK,UAAA,IAAAL,CAAA,SAAA8B,GAAA;MAA3BC,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,GAAU,CAAC,CAAGzB,WAAS,CAAE,EAAxC,IAAI,CAA2C;MAAAL,CAAA,OAAAK,UAAA;MAAAL,CAAA,OAAA8B,GAAA;MAAA9B,CAAA,OAAA+B,GAAA;IAAA;MAAAA,GAAA,GAAA/B,CAAA;IAAA;IAAA,IAAAgC,GAAA;IAAA,IAAAhC,CAAA,SAAA6B,GAAA,IAAA7B,CAAA,SAAA+B,GAAA,IAAA/B,CAAA,SAAAY,EAAA,IAAAZ,CAAA,SAAAmB,EAAA,IAAAnB,CAAA,SAAAyB,EAAA,IAAAzB,CAAA,SAAA0B,EAAA;MAXlDM,GAAA,IAAC,GAAG,CACF,CAAApB,EAEM,CACN,CAAAO,EAAqE,CACrE,CAAAM,EAGM,CACN,CAAAC,EAA0C,CAC1C,CAAAG,GAAmD,CACnD,CAAAE,GAA+C,CACjD,EAZC,GAAG,CAYE;MAAA/B,CAAA,OAAA6B,GAAA;MAAA7B,CAAA,OAAA+B,GAAA;MAAA/B,CAAA,OAAAY,EAAA;MAAAZ,CAAA,OAAAmB,EAAA;MAAAnB,CAAA,OAAAyB,EAAA;MAAAzB,CAAA,OAAA0B,EAAA;MAAA1B,CAAA,OAAAgC,GAAA;IAAA;MAAAA,GAAA,GAAAhC,CAAA;IAAA;IAAA,OAZNgC,GAYM;EAAA;EAIV,IAAIpC,IAAI,CAAAO,IAAK,KAAK,gBAAgB;IAAA,IAAAI,EAAA;IAAA,IAAAP,CAAA,SAAAE,KAAA;MACbK,EAAA,GAAAjB,KAAK,CAAC,SAAS,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAA8C,OAAQ,CAAC;MAAAjC,CAAA,OAAAE,KAAA;MAAAF,CAAA,OAAAO,EAAA;IAAA;MAAAA,EAAA,GAAAP,CAAA;IAAA;IAA3D,MAAAkC,YAAA,GAAmB3B,EAAwC;IAI1C,MAAAI,EAAA,GAAAd,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;IAC/C,MAAAJ,EAAA,GAAAf,UAAU,GAAV,GAAgBV,OAAO,CAAA8B,OAAQ,GAAU,GAAzC,IAAyC;IAAA,IAAAC,EAAA;IAAA,IAAAlB,CAAA,SAAAW,EAAA,IAAAX,CAAA,SAAAY,EAAA;MAD5CM,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAP,EAAoC,CAAC,CAC/C,CAAAC,EAAwC,CAC3C,EAFC,IAAI,CAEE;MAAAZ,CAAA,OAAAW,EAAA;MAAAX,CAAA,OAAAY,EAAA;MAAAZ,CAAA,OAAAkB,EAAA;IAAA;MAAAA,EAAA,GAAAlB,CAAA;IAAA;IACM,MAAAmB,EAAA,GAAAtB,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;IAAA,IAAAK,EAAA;IAAA,IAAArB,CAAA,SAAAJ,IAAA,CAAAwB,IAAA,IAAApB,CAAA,SAAAmB,EAAA;MAAlDE,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAF,EAAoC,CAAC,CAAG,CAAAvB,IAAI,CAAAwB,IAAI,CAAE,EAA9D,IAAI,CAAiE;MAAApB,CAAA,OAAAJ,IAAA,CAAAwB,IAAA;MAAApB,CAAA,OAAAmB,EAAA;MAAAnB,CAAA,OAAAqB,EAAA;IAAA;MAAAA,EAAA,GAAArB,CAAA;IAAA;IACtD,MAAAsB,EAAA,IAACzB,UAAU;IAAA,IAAA4B,EAAA;IAAA,IAAAzB,CAAA,SAAAuB,MAAA,CAAAC,GAAA;MAEzBC,EAAA,IAAC,IAAI,CAAiB,eAAuB,CAAvB,uBAAuB,CAAC,MAAM,EAAnD,IAAI,CAAsD;MAAAzB,CAAA,OAAAyB,EAAA;IAAA;MAAAA,EAAA,GAAAzB,CAAA;IAAA;IAAA,IAAA0B,EAAA;IAAA,IAAA1B,CAAA,SAAAsB,EAAA;MAF7DI,EAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAJ,EAAU,CAAC,CACxB,IAAE,CACH,CAAAG,EAA0D,CAC5D,EAHC,IAAI,CAGE;MAAAzB,CAAA,OAAAsB,EAAA;MAAAtB,CAAA,OAAA0B,EAAA;IAAA;MAAAA,EAAA,GAAA1B,CAAA;IAAA;IAAA,IAAA4B,GAAA;IAAA,IAAA5B,CAAA,SAAAJ,IAAA,CAAA+B,WAAA;MACPC,GAAA,IAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,GAAI,CAAAhC,IAAI,CAAA+B,WAAW,CAAE,EAAnC,IAAI,CAAsC;MAAA3B,CAAA,OAAAJ,IAAA,CAAA+B,WAAA;MAAA3B,CAAA,OAAA4B,GAAA;IAAA;MAAAA,GAAA,GAAA5B,CAAA;IAAA;IAC3B,MAAA6B,GAAA,IAAChC,UAAU;IAAA,IAAAiC,GAAA;IAAA,IAAA9B,CAAA,SAAAkC,YAAA,IAAAlC,CAAA,SAAA6B,GAAA;MAA3BC,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,GAAU,CAAC,CAAE,GAAIzB,aAAS,CAAE,CAAC,EAA5C,IAAI,CAA+C;MAAAJ,CAAA,OAAAkC,YAAA;MAAAlC,CAAA,OAAA6B,GAAA;MAAA7B,CAAA,OAAA8B,GAAA;IAAA;MAAAA,GAAA,GAAA9B,CAAA;IAAA;IACpC,MAAA+B,GAAA,IAAClC,UAAU;IAAA,IAAAmC,GAAA;IAAA,IAAAhC,CAAA,SAAA+B,GAAA;MAA3BC,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,GAAU,CAAC,CAAE,OAAO,EAAnC,IAAI,CAAsC;MAAA/B,CAAA,OAAA+B,GAAA;MAAA/B,CAAA,OAAAgC,GAAA;IAAA;MAAAA,GAAA,GAAAhC,CAAA;IAAA;IAAA,IAAAmC,GAAA;IAAA,IAAAnC,CAAA,SAAA4B,GAAA,IAAA5B,CAAA,SAAA8B,GAAA,IAAA9B,CAAA,SAAAgC,GAAA,IAAAhC,CAAA,SAAAkB,EAAA,IAAAlB,CAAA,SAAAqB,EAAA,IAAArB,CAAA,SAAA0B,EAAA;MAX7CS,GAAA,IAAC,GAAG,CACF,CAAAjB,EAEM,CACN,CAAAG,EAAqE,CACrE,CAAAK,EAGM,CACN,CAAAE,GAA0C,CAC1C,CAAAE,GAAmD,CACnD,CAAAE,GAA0C,CAC5C,EAZC,GAAG,CAYE;MAAAhC,CAAA,OAAA4B,GAAA;MAAA5B,CAAA,OAAA8B,GAAA;MAAA9B,CAAA,OAAAgC,GAAA;MAAAhC,CAAA,OAAAkB,EAAA;MAAAlB,CAAA,OAAAqB,EAAA;MAAArB,CAAA,OAAA0B,EAAA;MAAA1B,CAAA,OAAAmC,GAAA;IAAA;MAAAA,GAAA,GAAAnC,CAAA;IAAA;IAAA,OAZNmC,GAYM;EAAA;EAIV,IAAIvC,IAAI,CAAAO,IAAK,KAAK,eAAe;IAAA,IAAAI,EAAA;IAAA,IAAAP,CAAA,SAAAE,KAAA;MACZK,EAAA,GAAAjB,KAAK,CAAC,OAAO,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAAuB,KAAM,CAAC;MAAAV,CAAA,OAAAE,KAAA;MAAAF,CAAA,OAAAO,EAAA;IAAA;MAAAA,EAAA,GAAAP,CAAA;IAAA;IAAvD,MAAAoC,YAAA,GAAmB7B,EAAoC;IAChB,MAAAI,EAAA,GAAAf,IAAI,CAAAa,UAAW;IAAA,IAAAG,EAAA;IAAA,IAAAZ,CAAA,SAAAJ,IAAA,CAAAa,UAAA;MAAIG,EAAA,GAAAnB,MAAM,CAACG,IAAI,CAAAa,UAAW,EAAE,OAAO,CAAC;MAAAT,CAAA,OAAAJ,IAAA,CAAAa,UAAA;MAAAT,CAAA,OAAAY,EAAA;IAAA;MAAAA,EAAA,GAAAZ,CAAA;IAAA;IAA1F,MAAAqC,YAAA,GAAmB,oBAAoB1B,EAAe,IAAIC,EAAgC,EAAE;IAI3E,MAAAM,EAAA,GAAArB,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;IAC/C,MAAAG,EAAA,GAAAtB,UAAU,GAAV,GAAgBV,OAAO,CAAA8B,OAAQ,GAAU,GAAzC,IAAyC;IAAA,IAAAI,EAAA;IAAA,IAAArB,CAAA,SAAAkB,EAAA,IAAAlB,CAAA,SAAAmB,EAAA;MAD5CE,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAH,EAAoC,CAAC,CAC/C,CAAAC,EAAwC,CAC3C,EAFC,IAAI,CAEE;MAAAnB,CAAA,OAAAkB,EAAA;MAAAlB,CAAA,OAAAmB,EAAA;MAAAnB,CAAA,OAAAqB,EAAA;IAAA;MAAAA,EAAA,GAAArB,CAAA;IAAA;IACM,MAAAsB,EAAA,GAAAzB,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;IAAA,IAAAS,EAAA;IAAA,IAAAzB,CAAA,SAAAJ,IAAA,CAAAwB,IAAA,IAAApB,CAAA,SAAAsB,EAAA;MAAlDG,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAH,EAAoC,CAAC,CAAG,CAAA1B,IAAI,CAAAwB,IAAI,CAAE,EAA9D,IAAI,CAAiE;MAAApB,CAAA,OAAAJ,IAAA,CAAAwB,IAAA;MAAApB,CAAA,OAAAsB,EAAA;MAAAtB,CAAA,OAAAyB,EAAA;IAAA;MAAAA,EAAA,GAAAzB,CAAA;IAAA;IACtD,MAAA0B,EAAA,IAAC7B,UAAU;IAAA,IAAA+B,GAAA;IAAA,IAAA5B,CAAA,SAAAuB,MAAA,CAAAC,GAAA;MAEzBI,GAAA,IAAC,IAAI,CAAiB,eAAuB,CAAvB,uBAAuB,CAAC,MAAM,EAAnD,IAAI,CAAsD;MAAA5B,CAAA,OAAA4B,GAAA;IAAA;MAAAA,GAAA,GAAA5B,CAAA;IAAA;IAAA,IAAA6B,GAAA;IAAA,IAAA7B,CAAA,SAAA0B,EAAA;MAF7DG,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAH,EAAU,CAAC,CACxB,IAAE,CACH,CAAAE,GAA0D,CAC5D,EAHC,IAAI,CAGE;MAAA5B,CAAA,OAAA0B,EAAA;MAAA1B,CAAA,OAAA6B,GAAA;IAAA;MAAAA,GAAA,GAAA7B,CAAA;IAAA;IAAA,IAAA8B,GAAA;IAAA,IAAA9B,CAAA,SAAAJ,IAAA,CAAA+B,WAAA;MACPG,GAAA,IAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,GAAI,CAAAlC,IAAI,CAAA+B,WAAW,CAAE,EAAnC,IAAI,CAAsC;MAAA3B,CAAA,OAAAJ,IAAA,CAAA+B,WAAA;MAAA3B,CAAA,OAAA8B,GAAA;IAAA;MAAAA,GAAA,GAAA9B,CAAA;IAAA;IAC3B,MAAA+B,GAAA,IAAClC,UAAU;IAAA,IAAAmC,GAAA;IAAA,IAAAhC,CAAA,SAAAoC,YAAA,IAAApC,CAAA,SAAA+B,GAAA;MAA3BC,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,GAAU,CAAC,CAAE,GAAI3B,aAAS,CAAE,CAAC,EAA5C,IAAI,CAA+C;MAAAJ,CAAA,OAAAoC,YAAA;MAAApC,CAAA,OAAA+B,GAAA;MAAA/B,CAAA,OAAAgC,GAAA;IAAA;MAAAA,GAAA,GAAAhC,CAAA;IAAA;IACpC,MAAAmC,GAAA,IAACtC,UAAU;IAAA,IAAAyC,GAAA;IAAA,IAAAtC,CAAA,SAAAqC,YAAA,IAAArC,CAAA,SAAAmC,GAAA;MAA3BG,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAH,GAAU,CAAC,CAAG9B,aAAS,CAAE,EAAxC,IAAI,CAA2C;MAAAL,CAAA,OAAAqC,YAAA;MAAArC,CAAA,OAAAmC,GAAA;MAAAnC,CAAA,OAAAsC,GAAA;IAAA;MAAAA,GAAA,GAAAtC,CAAA;IAAA;IAAA,IAAAuC,GAAA;IAAA,IAAAvC,CAAA,SAAA6B,GAAA,IAAA7B,CAAA,SAAA8B,GAAA,IAAA9B,CAAA,SAAAgC,GAAA,IAAAhC,CAAA,SAAAsC,GAAA,IAAAtC,CAAA,SAAAqB,EAAA,IAAArB,CAAA,SAAAyB,EAAA;MAXlDc,GAAA,IAAC,GAAG,CACF,CAAAlB,EAEM,CACN,CAAAI,EAAqE,CACrE,CAAAI,GAGM,CACN,CAAAC,GAA0C,CAC1C,CAAAE,GAAmD,CACnD,CAAAM,GAA+C,CACjD,EAZC,GAAG,CAYE;MAAAtC,CAAA,OAAA6B,GAAA;MAAA7B,CAAA,OAAA8B,GAAA;MAAA9B,CAAA,OAAAgC,GAAA;MAAAhC,CAAA,OAAAsC,GAAA;MAAAtC,CAAA,OAAAqB,EAAA;MAAArB,CAAA,OAAAyB,EAAA;MAAAzB,CAAA,OAAAuC,GAAA;IAAA;MAAAA,GAAA,GAAAvC,CAAA;IAAA;IAAA,OAZNuC,GAYM;EAAA;EAKNnC,GAAA,CAAAA,YAAA;EACAC,GAAA,CAAAA,YAAA;EAEJ,IAAIT,IAAI,CAAA4C,MAAO,KAAK,WAAW;IAAA,IAAAjC,EAAA;IAAA,IAAAP,CAAA,SAAAE,KAAA;MAChBK,EAAA,GAAAjB,KAAK,CAAC,SAAS,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAA4B,IAAK,CAAC;MAAAf,CAAA,OAAAE,KAAA;MAAAF,CAAA,OAAAO,EAAA;IAAA;MAAAA,EAAA,GAAAP,CAAA;IAAA;IAAlDI,YAAA,CAAAA,CAAA,CAAaA,EAAqC;IAClDC,YAAA,CAAAA,CAAA,CAAaA,WAAW;EAAd;IACL,IAAIT,IAAI,CAAA4C,MAAO,KAAK,UAAU;MAAA,IAAAjC,EAAA;MAAA,IAAAP,CAAA,SAAAE,KAAA;QACtBK,EAAA,GAAAjB,KAAK,CAAC,UAAU,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAA2B,QAAS,CAAC;QAAAd,CAAA,OAAAE,KAAA;QAAAF,CAAA,OAAAO,EAAA;MAAA;QAAAA,EAAA,GAAAP,CAAA;MAAA;MAAvDI,YAAA,CAAAA,CAAA,CAAaA,EAA0C;MACvDC,YAAA,CAAAA,CAAA,CAAaA,UAAU;IAAb;MACL,IAAIT,IAAI,CAAA4C,MAAO,KAAK,SAAS;QAAA,IAAAjC,EAAA;QAAA,IAAAP,CAAA,SAAAE,KAAA;UACrBK,EAAA,GAAAjB,KAAK,CAAC,UAAU,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAA2B,QAAS,CAAC;UAAAd,CAAA,OAAAE,KAAA;UAAAF,CAAA,OAAAO,EAAA;QAAA;UAAAA,EAAA,GAAAP,CAAA;QAAA;QAAvDI,YAAA,CAAAA,CAAA,CAAaA,EAA0C;QACvDC,YAAA,CAAAA,CAAA,CAAaA,kBAAa;MAAhB;QACL,IAAIT,IAAI,CAAA4C,MAAO,KAAK,YAAY;UAAA,IAAAjC,EAAA;UAAA,IAAAP,CAAA,SAAAE,KAAA;YACxBK,EAAA,GAAAjB,KAAK,CAAC,SAAS,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAAsD,iBAAkB,CAAC;YAAAzC,CAAA,OAAAE,KAAA;YAAAF,CAAA,OAAAO,EAAA;UAAA;YAAAA,EAAA,GAAAP,CAAA;UAAA;UAA/DI,YAAA,CAAAA,CAAA,CAAaA,EAAkD;UAC/DC,YAAA,CAAAA,CAAA,CAAaA,eAAe;QAAlB;UAAA,IAAAE,EAAA;UAAA,IAAAP,CAAA,SAAAE,KAAA;YAEGK,EAAA,GAAAjB,KAAK,CAAC,OAAO,EAAEY,KAAK,CAAC,CAACf,OAAO,CAAAuB,KAAM,CAAC;YAAAV,CAAA,OAAAE,KAAA;YAAAF,CAAA,OAAAO,EAAA;UAAA;YAAAA,EAAA,GAAAP,CAAA;UAAA;UAAjDI,YAAA,CAAAA,CAAA,CAAaA,EAAoC;UACjDC,YAAA,CAAAA,CAAA,CAAaA,QAAQ;QAAX;MACX;IAAA;EAAA;EAGD,IAAIT,IAAI,CAAA8C,QAAS;IAGE,MAAAnC,EAAA,GAAAV,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;IAC/C,MAAAL,EAAA,GAAAd,UAAU,GAAV,GAAgBV,OAAO,CAAA8B,OAAQ,GAAU,GAAzC,IAAyC;IAAA,IAAAL,EAAA;IAAA,IAAAZ,CAAA,SAAAO,EAAA,IAAAP,CAAA,SAAAW,EAAA;MAD5CC,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAL,EAAoC,CAAC,CAC/C,CAAAI,EAAwC,CAC3C,EAFC,IAAI,CAEE;MAAAX,CAAA,OAAAO,EAAA;MAAAP,CAAA,OAAAW,EAAA;MAAAX,CAAA,OAAAY,EAAA;IAAA;MAAAA,EAAA,GAAAZ,CAAA;IAAA;IACS,MAAAkB,EAAA,IAACrB,UAAU;IAAA,IAAAsB,EAAA;IAAA,IAAAnB,CAAA,UAAAkB,EAAA;MAA3BC,EAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,EAAU,CAAC,CAAE,EAAE,EAA9B,IAAI,CAAiC;MAAAlB,CAAA,QAAAkB,EAAA;MAAAlB,CAAA,QAAAmB,EAAA;IAAA;MAAAA,EAAA,GAAAnB,CAAA;IAAA;IACzB,MAAAqB,EAAA,GAAAxB,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;IAAA,IAAAM,EAAA;IAAA,IAAAtB,CAAA,UAAAJ,IAAA,CAAAwB,IAAA,IAAApB,CAAA,UAAAqB,EAAA;MAAlDC,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAD,EAAoC,CAAC,CAAG,CAAAzB,IAAI,CAAAwB,IAAI,CAAE,EAA9D,IAAI,CAAiE;MAAApB,CAAA,QAAAJ,IAAA,CAAAwB,IAAA;MAAApB,CAAA,QAAAqB,EAAA;MAAArB,CAAA,QAAAsB,EAAA;IAAA;MAAAA,EAAA,GAAAtB,CAAA;IAAA;IACtD,MAAAyB,EAAA,IAAC5B,UAAU;IAAA,IAAA6B,EAAA;IAAA,IAAA1B,CAAA,UAAAuB,MAAA,CAAAC,GAAA;MAEzBE,EAAA,IAAC,IAAI,CAAiB,eAAuB,CAAvB,uBAAuB,CAAC,GAAG,EAAhD,IAAI,CAAmD;MAAA1B,CAAA,QAAA0B,EAAA;IAAA;MAAAA,EAAA,GAAA1B,CAAA;IAAA;IAAA,IAAA4B,GAAA;IAAA,IAAA5B,CAAA,UAAAyB,EAAA;MAF1DG,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAH,EAAU,CAAC,CACxB,IAAE,CACH,CAAAC,EAAuD,CACzD,EAHC,IAAI,CAGE;MAAA1B,CAAA,QAAAyB,EAAA;MAAAzB,CAAA,QAAA4B,GAAA;IAAA;MAAAA,GAAA,GAAA5B,CAAA;IAAA;IACS,MAAA6B,GAAA,IAAChC,UAAU;IAAA,IAAAiC,GAAA;IAAA,IAAA9B,CAAA,UAAA2C,YAAA,IAAA3C,CAAA,UAAA6B,GAAA;MAA3BC,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,GAAU,CAAC,CAAE,GAAIzB,aAAS,CAAE,CAAC,EAA5C,IAAI,CAA+C;MAAAJ,CAAA,QAAA2C,YAAA;MAAA3C,CAAA,QAAA6B,GAAA;MAAA7B,CAAA,QAAA8B,GAAA;IAAA;MAAAA,GAAA,GAAA9B,CAAA;IAAA;IACpC,MAAA+B,GAAA,IAAClC,UAAU;IAAA,IAAAmC,GAAA;IAAA,IAAAhC,CAAA,UAAA4C,YAAA,IAAA5C,CAAA,UAAA+B,GAAA;MAA3BC,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,GAAU,CAAC,CAAG1B,aAAS,CAAE,EAAxC,IAAI,CAA2C;MAAAL,CAAA,QAAA4C,YAAA;MAAA5C,CAAA,QAAA+B,GAAA;MAAA/B,CAAA,QAAAgC,GAAA;IAAA;MAAAA,GAAA,GAAAhC,CAAA;IAAA;IAAA,IAAAmC,GAAA;IAAA,IAAAnC,CAAA,UAAA4B,GAAA,IAAA5B,CAAA,UAAA8B,GAAA,IAAA9B,CAAA,UAAAgC,GAAA,IAAAhC,CAAA,UAAAY,EAAA,IAAAZ,CAAA,UAAAmB,EAAA,IAAAnB,CAAA,UAAAsB,EAAA;MAXlDa,GAAA,IAAC,GAAG,CACF,CAAAvB,EAEM,CACN,CAAAO,EAAqC,CACrC,CAAAG,EAAqE,CACrE,CAAAM,GAGM,CACN,CAAAE,GAAmD,CACnD,CAAAE,GAA+C,CACjD,EAZC,GAAG,CAYE;MAAAhC,CAAA,QAAA4B,GAAA;MAAA5B,CAAA,QAAA8B,GAAA;MAAA9B,CAAA,QAAAgC,GAAA;MAAAhC,CAAA,QAAAY,EAAA;MAAAZ,CAAA,QAAAmB,EAAA;MAAAnB,CAAA,QAAAsB,EAAA;MAAAtB,CAAA,QAAAmC,GAAA;IAAA;MAAAA,GAAA,GAAAnC,CAAA;IAAA;IAAA,OAZNmC,GAYM;EAAA;EAMO,MAAA5B,EAAA,GAAAV,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;EAC/C,MAAAL,EAAA,GAAAd,UAAU,GAAV,GAAgBV,OAAO,CAAA8B,OAAQ,GAAU,GAAzC,IAAyC;EAAA,IAAAL,EAAA;EAAA,IAAAZ,CAAA,UAAAO,EAAA,IAAAP,CAAA,UAAAW,EAAA;IAD5CC,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAL,EAAoC,CAAC,CAC/C,CAAAI,EAAwC,CAC3C,EAFC,IAAI,CAEE;IAAAX,CAAA,QAAAO,EAAA;IAAAP,CAAA,QAAAW,EAAA;IAAAX,CAAA,QAAAY,EAAA;EAAA;IAAAA,EAAA,GAAAZ,CAAA;EAAA;EACM,MAAAkB,EAAA,GAAArB,UAAU,GAAV,YAAqC,GAArCmB,SAAqC;EAAA,IAAAG,EAAA;EAAA,IAAAnB,CAAA,UAAAJ,IAAA,CAAAwB,IAAA,IAAApB,CAAA,UAAAkB,EAAA;IAAlDC,EAAA,IAAC,IAAI,CAAQ,KAAqC,CAArC,CAAAD,EAAoC,CAAC,CAAG,CAAAtB,IAAI,CAAAwB,IAAI,CAAE,EAA9D,IAAI,CAAiE;IAAApB,CAAA,QAAAJ,IAAA,CAAAwB,IAAA;IAAApB,CAAA,QAAAkB,EAAA;IAAAlB,CAAA,QAAAmB,EAAA;EAAA;IAAAA,EAAA,GAAAnB,CAAA;EAAA;EACtD,MAAAqB,EAAA,IAACxB,UAAU;EAAA,IAAAyB,EAAA;EAAA,IAAAtB,CAAA,UAAAuB,MAAA,CAAAC,GAAA;IAEzBF,EAAA,IAAC,IAAI,CAAiB,eAAuB,CAAvB,uBAAuB,CAAC,GAAG,EAAhD,IAAI,CAAmD;IAAAtB,CAAA,QAAAsB,EAAA;EAAA;IAAAA,EAAA,GAAAtB,CAAA;EAAA;EAAA,IAAAyB,EAAA;EAAA,IAAAzB,CAAA,UAAAqB,EAAA;IAF1DI,EAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAJ,EAAU,CAAC,CACxB,IAAE,CACH,CAAAC,EAAuD,CACzD,EAHC,IAAI,CAGE;IAAAtB,CAAA,QAAAqB,EAAA;IAAArB,CAAA,QAAAyB,EAAA;EAAA;IAAAA,EAAA,GAAAzB,CAAA;EAAA;EACS,MAAA0B,EAAA,IAAC7B,UAAU;EAAA,IAAA+B,GAAA;EAAA,IAAA5B,CAAA,UAAA2C,YAAA,IAAA3C,CAAA,UAAA0B,EAAA;IAA3BE,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAF,EAAU,CAAC,CAAE,GAAItB,aAAS,CAAE,CAAC,EAA5C,IAAI,CAA+C;IAAAJ,CAAA,QAAA2C,YAAA;IAAA3C,CAAA,QAAA0B,EAAA;IAAA1B,CAAA,QAAA4B,GAAA;EAAA;IAAAA,GAAA,GAAA5B,CAAA;EAAA;EACpC,MAAA6B,GAAA,IAAChC,UAAU;EAAA,IAAAiC,GAAA;EAAA,IAAA9B,CAAA,UAAA4C,YAAA,IAAA5C,CAAA,UAAA6B,GAAA;IAA3BC,GAAA,IAAC,IAAI,CAAW,QAAW,CAAX,CAAAD,GAAU,CAAC,CAAGxB,aAAS,CAAE,EAAxC,IAAI,CAA2C;IAAAL,CAAA,QAAA4C,YAAA;IAAA5C,CAAA,QAAA6B,GAAA;IAAA7B,CAAA,QAAA8B,GAAA;EAAA;IAAAA,GAAA,GAAA9B,CAAA;EAAA;EAAA,IAAA+B,GAAA;EAAA,IAAA/B,CAAA,UAAA4B,GAAA,IAAA5B,CAAA,UAAA8B,GAAA,IAAA9B,CAAA,UAAAY,EAAA,IAAAZ,CAAA,UAAAmB,EAAA,IAAAnB,CAAA,UAAAyB,EAAA;IAVlDM,GAAA,IAAC,GAAG,CACF,CAAAnB,EAEM,CACN,CAAAO,EAAqE,CACrE,CAAAM,EAGM,CACN,CAAAG,GAAmD,CACnD,CAAAE,GAA+C,CACjD,EAXC,GAAG,CAWE;IAAA9B,CAAA,QAAA4B,GAAA;IAAA5B,CAAA,QAAA8B,GAAA;IAAA9B,CAAA,QAAAY,EAAA;IAAAZ,CAAA,QAAAmB,EAAA;IAAAnB,CAAA,QAAAyB,EAAA;IAAAzB,CAAA,QAAA+B,GAAA;EAAA;IAAAA,GAAA,GAAA/B,CAAA;EAAA;EAAA,OAXN+B,GAWM;AAAA","ignoreList":[]}

src/commands/plugin/ValidatePlugin.tsx

@@ -0,0 +1,98 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import * as React from 'react';
+import { useEffect } from 'react';
+import { Box, Text } from '../../ink.js';
+import { errorMessage } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { validateManifest } from '../../utils/plugins/validatePlugin.js';
+import { plural } from '../../utils/stringUtils.js';
+type Props = {
+  onComplete: (result?: string) => void;
+  path?: string;
+};
+export function ValidatePlugin(t0) {
+  const $ = _c(5);
+  const {
+    onComplete,
+    path
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== onComplete || $[1] !== path) {
+    t1 = () => {
+      const runValidation = async function runValidation() {
+        if (!path) {
+          onComplete("Usage: /plugin validate <path>\n\nValidate a plugin or marketplace manifest file or directory.\n\nExamples:\n  /plugin validate .claude-plugin/plugin.json\n  /plugin validate /path/to/plugin-directory\n  /plugin validate .\n\nWhen given a directory, automatically validates .claude-plugin/marketplace.json\nor .claude-plugin/plugin.json (prefers marketplace if both exist).\n\nOr from the command line:\n  claude plugin validate <path>");
+          return;
+        }
+        ;
+        try {
+          const result = await validateManifest(path);
+          let output = "";
+          output = output + `Validating ${result.fileType} manifest: ${result.filePath}\n\n`;
+          output;
+          if (result.errors.length > 0) {
+            output = output + `${figures.cross} Found ${result.errors.length} ${plural(result.errors.length, "error")}:\n\n`;
+            output;
+            result.errors.forEach(error_0 => {
+              output = output + `  ${figures.pointer} ${error_0.path}: ${error_0.message}\n`;
+              output;
+            });
+            output = output + "\n";
+            output;
+          }
+          if (result.warnings.length > 0) {
+            output = output + `${figures.warning} Found ${result.warnings.length} ${plural(result.warnings.length, "warning")}:\n\n`;
+            output;
+            result.warnings.forEach(warning => {
+              output = output + `  ${figures.pointer} ${warning.path}: ${warning.message}\n`;
+              output;
+            });
+            output = output + "\n";
+            output;
+          }
+          if (result.success) {
+            if (result.warnings.length > 0) {
+              output = output + `${figures.tick} Validation passed with warnings\n`;
+              output;
+            } else {
+              output = output + `${figures.tick} Validation passed\n`;
+              output;
+            }
+            process.exitCode = 0;
+          } else {
+            output = output + `${figures.cross} Validation failed\n`;
+            output;
+            process.exitCode = 1;
+          }
+          onComplete(output);
+        } catch (t3) {
+          const error = t3;
+          process.exitCode = 2;
+          logError(error);
+          onComplete(`${figures.cross} Unexpected error during validation: ${errorMessage(error)}`);
+        }
+      };
+      runValidation();
+    };
+    t2 = [onComplete, path];
+    $[0] = onComplete;
+    $[1] = path;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t1 = $[2];
+    t2 = $[3];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = <Box flexDirection="column"><Text>Running validation...</Text></Box>;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useEffect","Box","Text","errorMessage","logError","validateManifest","plural","Props","onComplete","result","path","ValidatePlugin","t0","$","_c","t1","t2","runValidation","output","fileType","filePath","errors","length","cross","forEach","error_0","pointer","error","message","warnings","warning","success","tick","process","exitCode","t3","Symbol","for"],"sources":["ValidatePlugin.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { useEffect } from 'react'\nimport { Box, Text } from '../../ink.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { validateManifest } from '../../utils/plugins/validatePlugin.js'\nimport { plural } from '../../utils/stringUtils.js'\n\ntype Props = {\n  onComplete: (result?: string) => void\n  path?: string\n}\n\nexport function ValidatePlugin({ onComplete, path }: Props): React.ReactNode {\n  useEffect(() => {\n    async function runValidation() {\n      // If no path provided, show usage\n      if (!path) {\n        onComplete(\n          'Usage: /plugin validate <path>\\n\\n' +\n            'Validate a plugin or marketplace manifest file or directory.\\n\\n' +\n            'Examples:\\n' +\n            '  /plugin validate .claude-plugin/plugin.json\\n' +\n            '  /plugin validate /path/to/plugin-directory\\n' +\n            '  /plugin validate .\\n\\n' +\n            'When given a directory, automatically validates .claude-plugin/marketplace.json\\n' +\n            'or .claude-plugin/plugin.json (prefers marketplace if both exist).\\n\\n' +\n            'Or from the command line:\\n' +\n            '  claude plugin validate <path>',\n        )\n        return\n      }\n\n      try {\n        const result = await validateManifest(path)\n\n        let output = ''\n\n        // Add header\n        output += `Validating ${result.fileType} manifest: ${result.filePath}\\n\\n`\n\n        // Show errors\n        if (result.errors.length > 0) {\n          output += `${figures.cross} Found ${result.errors.length} ${plural(result.errors.length, 'error')}:\\n\\n`\n\n          result.errors.forEach(error => {\n            output += `  ${figures.pointer} ${error.path}: ${error.message}\\n`\n          })\n\n          output += '\\n'\n        }\n\n        // Show warnings\n        if (result.warnings.length > 0) {\n          output += `${figures.warning} Found ${result.warnings.length} ${plural(result.warnings.length, 'warning')}:\\n\\n`\n\n          result.warnings.forEach(warning => {\n            output += `  ${figures.pointer} ${warning.path}: ${warning.message}\\n`\n          })\n\n          output += '\\n'\n        }\n\n        // Show success or failure\n        if (result.success) {\n          if (result.warnings.length > 0) {\n            output += `${figures.tick} Validation passed with warnings\\n`\n          } else {\n            output += `${figures.tick} Validation passed\\n`\n          }\n\n          // Exit with code 0 (success)\n          process.exitCode = 0\n        } else {\n          output += `${figures.cross} Validation failed\\n`\n\n          // Exit with code 1 (validation failure)\n          process.exitCode = 1\n        }\n\n        onComplete(output)\n      } catch (error) {\n        // Exit with code 2 (unexpected error)\n        process.exitCode = 2\n\n        logError(error)\n\n        onComplete(\n          `${figures.cross} Unexpected error during validation: ${errorMessage(error)}`,\n        )\n      }\n    }\n\n    void runValidation()\n  }, [onComplete, path])\n\n  return (\n    <Box flexDirection=\"column\">\n      <Text>Running validation...</Text>\n    </Box>\n  )\n}\n"],"mappings":";AAAA,OAAOA,OAAO,MAAM,SAAS;AAC7B,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,SAASC,SAAS,QAAQ,OAAO;AACjC,SAASC,GAAG,EAAEC,IAAI,QAAQ,cAAc;AACxC,SAASC,YAAY,QAAQ,uBAAuB;AACpD,SAASC,QAAQ,QAAQ,oBAAoB;AAC7C,SAASC,gBAAgB,QAAQ,uCAAuC;AACxE,SAASC,MAAM,QAAQ,4BAA4B;AAEnD,KAAKC,KAAK,GAAG;EACXC,UAAU,EAAE,CAACC,MAAe,CAAR,EAAE,MAAM,EAAE,GAAG,IAAI;EACrCC,IAAI,CAAC,EAAE,MAAM;AACf,CAAC;AAED,OAAO,SAAAC,eAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAwB;IAAAN,UAAA;IAAAE;EAAA,IAAAE,EAA2B;EAAA,IAAAG,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAH,CAAA,QAAAL,UAAA,IAAAK,CAAA,QAAAH,IAAA;IAC9CK,EAAA,GAAAA,CAAA;MACR,MAAAE,aAAA,kBAAAA,cAAA;QAEE,IAAI,CAACP,IAAI;UACPF,UAAU,CACR,qbAUF,CAAC;UAAA;QAAA;QAEF;QAED;UACE,MAAAC,MAAA,GAAe,MAAMJ,gBAAgB,CAACK,IAAI,CAAC;UAE3C,IAAAQ,MAAA,GAAa,EAAE;UAGfA,MAAA,GAAAA,MAAM,GAAI,cAAcT,MAAM,CAAAU,QAAS,cAAcV,MAAM,CAAAW,QAAS,MAAM;UAA1EF,MAA0E;UAG1E,IAAIT,MAAM,CAAAY,MAAO,CAAAC,MAAO,GAAG,CAAC;YAC1BJ,MAAA,GAAAA,MAAM,GAAI,GAAGpB,OAAO,CAAAyB,KAAM,UAAUd,MAAM,CAAAY,MAAO,CAAAC,MAAO,IAAIhB,MAAM,CAACG,MAAM,CAAAY,MAAO,CAAAC,MAAO,EAAE,OAAO,CAAC,OAAO;YAAxGJ,MAAwG;YAExGT,MAAM,CAAAY,MAAO,CAAAG,OAAQ,CAACC,OAAA;cACpBP,MAAA,GAAAA,MAAM,GAAI,KAAKpB,OAAO,CAAA4B,OAAQ,IAAIC,OAAK,CAAAjB,IAAK,KAAKiB,OAAK,CAAAC,OAAQ,IAAI;cAAlEV,MAAkE;YAAA,CACnE,CAAC;YAEFA,MAAA,GAAAA,MAAM,GAAI,IAAI;YAAdA,MAAc;UAAA;UAIhB,IAAIT,MAAM,CAAAoB,QAAS,CAAAP,MAAO,GAAG,CAAC;YAC5BJ,MAAA,GAAAA,MAAM,GAAI,GAAGpB,OAAO,CAAAgC,OAAQ,UAAUrB,MAAM,CAAAoB,QAAS,CAAAP,MAAO,IAAIhB,MAAM,CAACG,MAAM,CAAAoB,QAAS,CAAAP,MAAO,EAAE,SAAS,CAAC,OAAO;YAAhHJ,MAAgH;YAEhHT,MAAM,CAAAoB,QAAS,CAAAL,OAAQ,CAACM,OAAA;cACtBZ,MAAA,GAAAA,MAAM,GAAI,KAAKpB,OAAO,CAAA4B,OAAQ,IAAII,OAAO,CAAApB,IAAK,KAAKoB,OAAO,CAAAF,OAAQ,IAAI;cAAtEV,MAAsE;YAAA,CACvE,CAAC;YAEFA,MAAA,GAAAA,MAAM,GAAI,IAAI;YAAdA,MAAc;UAAA;UAIhB,IAAIT,MAAM,CAAAsB,OAAQ;YAChB,IAAItB,MAAM,CAAAoB,QAAS,CAAAP,MAAO,GAAG,CAAC;cAC5BJ,MAAA,GAAAA,MAAM,GAAI,GAAGpB,OAAO,CAAAkC,IAAK,oCAAoC;cAA7Dd,MAA6D;YAAA;cAE7DA,MAAA,GAAAA,MAAM,GAAI,GAAGpB,OAAO,CAAAkC,IAAK,sBAAsB;cAA/Cd,MAA+C;YAAA;YAIjDe,OAAO,CAAAC,QAAA,GAAY,CAAH;UAAA;YAEhBhB,MAAA,GAAAA,MAAM,GAAI,GAAGpB,OAAO,CAAAyB,KAAM,sBAAsB;YAAhDL,MAAgD;YAGhDe,OAAO,CAAAC,QAAA,GAAY,CAAH;UAAA;UAGlB1B,UAAU,CAACU,MAAM,CAAC;QAAA,SAAAiB,EAAA;UACXR,KAAA,CAAAA,KAAA,CAAAA,CAAA,CAAAA,EAAK;UAEZM,OAAO,CAAAC,QAAA,GAAY,CAAH;UAEhB9B,QAAQ,CAACuB,KAAK,CAAC;UAEfnB,UAAU,CACR,GAAGV,OAAO,CAAAyB,KAAM,wCAAwCpB,YAAY,CAACwB,KAAK,CAAC,EAC7E,CAAC;QAAA;MACF,CACF;MAEIV,aAAa,CAAC,CAAC;IAAA,CACrB;IAAED,EAAA,IAACR,UAAU,EAAEE,IAAI,CAAC;IAAAG,CAAA,MAAAL,UAAA;IAAAK,CAAA,MAAAH,IAAA;IAAAG,CAAA,MAAAE,EAAA;IAAAF,CAAA,MAAAG,EAAA;EAAA;IAAAD,EAAA,GAAAF,CAAA;IAAAG,EAAA,GAAAH,CAAA;EAAA;EAhFrBb,SAAS,CAACe,EAgFT,EAAEC,EAAkB,CAAC;EAAA,IAAAmB,EAAA;EAAA,IAAAtB,CAAA,QAAAuB,MAAA,CAAAC,GAAA;IAGpBF,EAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAC,IAAI,CAAC,qBAAqB,EAA1B,IAAI,CACP,EAFC,GAAG,CAEE;IAAAtB,CAAA,MAAAsB,EAAA;EAAA;IAAAA,EAAA,GAAAtB,CAAA;EAAA;EAAA,OAFNsB,EAEM;AAAA","ignoreList":[]}

src/commands/plugin/index.tsx

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js';
+const plugin = {
+  type: 'local-jsx',
+  name: 'plugin',
+  aliases: ['plugins', 'marketplace'],
+  description: 'Manage Claude Code plugins',
+  immediate: true,
+  load: () => import('./plugin.js')
+} satisfies Command;
+export default plugin;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDb21tYW5kIiwicGx1Z2luIiwidHlwZSIsIm5hbWUiLCJhbGlhc2VzIiwiZGVzY3JpcHRpb24iLCJpbW1lZGlhdGUiLCJsb2FkIl0sInNvdXJjZXMiOlsiaW5kZXgudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQ29tbWFuZCB9IGZyb20gJy4uLy4uL2NvbW1hbmRzLmpzJ1xuXG5jb25zdCBwbHVnaW4gPSB7XG4gIHR5cGU6ICdsb2NhbC1qc3gnLFxuICBuYW1lOiAncGx1Z2luJyxcbiAgYWxpYXNlczogWydwbHVnaW5zJywgJ21hcmtldHBsYWNlJ10sXG4gIGRlc2NyaXB0aW9uOiAnTWFuYWdlIENsYXVkZSBDb2RlIHBsdWdpbnMnLFxuICBpbW1lZGlhdGU6IHRydWUsXG4gIGxvYWQ6ICgpID0+IGltcG9ydCgnLi9wbHVnaW4uanMnKSxcbn0gc2F0aXNmaWVzIENvbW1hbmRcblxuZXhwb3J0IGRlZmF1bHQgcGx1Z2luXG4iXSwibWFwcGluZ3MiOiJBQUFBLGNBQWNBLE9BQU8sUUFBUSxtQkFBbUI7QUFFaEQsTUFBTUMsTUFBTSxHQUFHO0VBQ2JDLElBQUksRUFBRSxXQUFXO0VBQ2pCQyxJQUFJLEVBQUUsUUFBUTtFQUNkQyxPQUFPLEVBQUUsQ0FBQyxTQUFTLEVBQUUsYUFBYSxDQUFDO0VBQ25DQyxXQUFXLEVBQUUsNEJBQTRCO0VBQ3pDQyxTQUFTLEVBQUUsSUFBSTtFQUNmQyxJQUFJLEVBQUVBLENBQUEsS0FBTSxNQUFNLENBQUMsYUFBYTtBQUNsQyxDQUFDLFdBQVdQLE9BQU87QUFFbkIsZUFBZUMsTUFBTSIsImlnbm9yZUxpc3QiOltdfQ==

src/commands/plugin/parseArgs.ts

@@ -0,0 +1,103 @@
+// Parse plugin subcommand arguments into structured commands
+export type ParsedCommand =
+  | { type: 'menu' }
+  | { type: 'help' }
+  | { type: 'install'; marketplace?: string; plugin?: string }
+  | { type: 'manage' }
+  | { type: 'uninstall'; plugin?: string }
+  | { type: 'enable'; plugin?: string }
+  | { type: 'disable'; plugin?: string }
+  | { type: 'validate'; path?: string }
+  | {
+      type: 'marketplace'
+      action?: 'add' | 'remove' | 'update' | 'list'
+      target?: string
+    }
+
+export function parsePluginArgs(args?: string): ParsedCommand {
+  if (!args) {
+    return { type: 'menu' }
+  }
+
+  const parts = args.trim().split(/\s+/)
+  const command = parts[0]?.toLowerCase()
+
+  switch (command) {
+    case 'help':
+    case '--help':
+    case '-h':
+      return { type: 'help' }
+
+    case 'install':
+    case 'i': {
+      const target = parts[1]
+      if (!target) {
+        return { type: 'install' }
+      }
+
+      // Check if it's in format plugin@marketplace
+      if (target.includes('@')) {
+        const [plugin, marketplace] = target.split('@')
+        return { type: 'install', plugin, marketplace }
+      }
+
+      // Check if the target looks like a marketplace (URL or path)
+      const isMarketplace =
+        target.startsWith('http://') ||
+        target.startsWith('https://') ||
+        target.startsWith('file://') ||
+        target.includes('/') ||
+        target.includes('\\')
+
+      if (isMarketplace) {
+        // This is a marketplace URL/path, no plugin specified
+        return { type: 'install', marketplace: target }
+      }
+
+      // Otherwise treat it as a plugin name
+      return { type: 'install', plugin: target }
+    }
+
+    case 'manage':
+      return { type: 'manage' }
+
+    case 'uninstall':
+      return { type: 'uninstall', plugin: parts[1] }
+
+    case 'enable':
+      return { type: 'enable', plugin: parts[1] }
+
+    case 'disable':
+      return { type: 'disable', plugin: parts[1] }
+
+    case 'validate': {
+      const target = parts.slice(1).join(' ').trim()
+      return { type: 'validate', path: target || undefined }
+    }
+
+    case 'marketplace':
+    case 'market': {
+      const action = parts[1]?.toLowerCase()
+      const target = parts.slice(2).join(' ')
+
+      switch (action) {
+        case 'add':
+          return { type: 'marketplace', action: 'add', target }
+        case 'remove':
+        case 'rm':
+          return { type: 'marketplace', action: 'remove', target }
+        case 'update':
+          return { type: 'marketplace', action: 'update', target }
+        case 'list':
+          return { type: 'marketplace', action: 'list' }
+        default:
+          // No action specified, show marketplace menu
+          return { type: 'marketplace' }
+      }
+    }
+
+    default:
+      // Unknown command, show menu
+      return { type: 'menu' }
+  }
+}