diff --git a/src/commands/add-dir/add-dir.tsx b/src/commands/add-dir/add-dir.tsx new file mode 100644 index 0000000000000000000000000000000000000000..b1a2b4de1f2d24185e389bd0982450de33cee68d --- /dev/null +++ b/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 = {figures.pointer} /add-dir {args}; + $[3] = args; + $[4] = t3; + } else { + t3 = $[4]; + } + let t4; + if ($[5] !== message) { + t4 = {message}; + $[5] = message; + $[6] = t4; + } else { + t4 = $[6]; + } + let t5; + if ($[7] !== t3 || $[8] !== t4) { + t5 = {t3}{t4}; + $[7] = t3; + $[8] = t4; + $[9] = t5; + } else { + t5 = $[9]; + } + return t5; +} +export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext, args?: string): Promise { + 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 { + onDone('Did not add a working directory.'); + }} />; + } + const result = await validateDirectoryForWorkspace(directoryPath, appState.toolPermissionContext); + if (result.resultType !== 'success') { + const message = addDirHelpMessage(result); + return onDone(message)} />; + } + return { + 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":";AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,OAAOC,OAAO,MAAM,SAAS;AAC7B,OAAOC,KAAK,IAAIC,SAAS,QAAQ,OAAO;AACxC,SACEC,mCAAmC,EACnCC,mCAAmC,QAC9B,0BAA0B;AACjC,cAAcC,sBAAsB,QAAQ,mBAAmB;AAC/D,SAASC,eAAe,QAAQ,qCAAqC;AACrE,SAASC,qBAAqB,QAAQ,6DAA6D;AACnG,SAASC,GAAG,EAAEC,IAAI,QAAQ,cAAc;AACxC,cAAcC,qBAAqB,QAAQ,wBAAwB;AACnE,SACEC,qBAAqB,EACrBC,uBAAuB,QAClB,6CAA6C;AACpD,cAAcC,2BAA2B,QAAQ,mDAAmD;AACpG,SAASC,cAAc,QAAQ,wCAAwC;AACvE,SACEC,iBAAiB,EACjBC,6BAA6B,QACxB,iBAAiB;AAExB,SAAAC,YAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAqB;IAAAC,OAAA;IAAAC,IAAA;IAAAC;EAAA,IAAAL,EAQpB;EAAA,IAAAM,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAN,CAAA,QAAAI,MAAA;IACWC,EAAA,GAAAA,CAAA;MAIR,MAAAE,KAAA,GAAcC,UAAU,CAACJ,MAAM,EAAE,CAAC,CAAC;MAAA,OAC5B,MAAMK,YAAY,CAACF,KAAK,CAAC;IAAA,CACjC;IAAED,EAAA,IAACF,MAAM,CAAC;IAAAJ,CAAA,MAAAI,MAAA;IAAAJ,CAAA,MAAAK,EAAA;IAAAL,CAAA,MAAAM,EAAA;EAAA;IAAAD,EAAA,GAAAL,CAAA;IAAAM,EAAA,GAAAN,CAAA;EAAA;EANXjB,SAAS,CAACsB,EAMT,EAAEC,EAAQ,CAAC;EAAA,IAAAI,EAAA;EAAA,IAAAV,CAAA,QAAAG,IAAA;IAIRO,EAAA,IAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CACX,CAAA7B,OAAO,CAAA8B,OAAO,CAAE,UAAWR,KAAG,CACjC,EAFC,IAAI,CAEE;IAAAH,CAAA,MAAAG,IAAA;IAAAH,CAAA,MAAAU,EAAA;EAAA;IAAAA,EAAA,GAAAV,CAAA;EAAA;EAAA,IAAAY,EAAA;EAAA,IAAAZ,CAAA,QAAAE,OAAA;IACPU,EAAA,IAAC,eAAe,CACd,CAAC,IAAI,CAAEV,QAAM,CAAE,EAAd,IAAI,CACP,EAFC,eAAe,CAEE;IAAAF,CAAA,MAAAE,OAAA;IAAAF,CAAA,MAAAY,EAAA;EAAA;IAAAA,EAAA,GAAAZ,CAAA;EAAA;EAAA,IAAAa,EAAA;EAAA,IAAAb,CAAA,QAAAU,EAAA,IAAAV,CAAA,QAAAY,EAAA;IANpBC,EAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAAH,EAEM,CACN,CAAAE,EAEiB,CACnB,EAPC,GAAG,CAOE;IAAAZ,CAAA,MAAAU,EAAA;IAAAV,CAAA,MAAAY,EAAA;IAAAZ,CAAA,MAAAa,EAAA;EAAA;IAAAA,EAAA,GAAAb,CAAA;EAAA;EAAA,OAPNa,EAOM;AAAA;AAIV,OAAO,eAAeC,IAAIA,CACxBV,MAAM,EAAEb,qBAAqB,EAC7BwB,OAAO,EAAE7B,sBAAsB,EAC/BiB,IAAa,CAAR,EAAE,MAAM,CACd,EAAEa,OAAO,CAAClC,KAAK,CAACmC,SAAS,CAAC,CAAC;EAC1B,MAAMC,aAAa,GAAG,CAACf,IAAI,IAAI,EAAE,EAAEgB,IAAI,CAAC,CAAC;EACzC,MAAMC,QAAQ,GAAGL,OAAO,CAACM,WAAW,CAAC,CAAC;;EAEtC;EACA,MAAMC,kBAAkB,GAAG,MAAAA,CAAOC,IAAI,EAAE,MAAM,EAAEC,QAAQ,GAAG,KAAK,KAAK;IACnE,MAAMC,WAAW,EAAE/B,2BAA2B,GAAG8B,QAAQ,GACrD,eAAe,GACf,SAAS;IAEb,MAAME,gBAAgB,GAAG;MACvBC,IAAI,EAAE,gBAAgB,IAAIC,KAAK;MAC/BC,WAAW,EAAE,CAACN,IAAI,CAAC;MACnBE;IACF,CAAC;;IAED;IACA,MAAMK,cAAc,GAAGf,OAAO,CAACM,WAAW,CAAC,CAAC;IAC5C,MAAMU,cAAc,GAAGvC,qBAAqB,CAC1CsC,cAAc,CAACE,qBAAqB,EACpCN,gBACF,CAAC;IACDX,OAAO,CAACkB,WAAW,CAACC,IAAI,KAAK;MAC3B,GAAGA,IAAI;MACPF,qBAAqB,EAAED;IACzB,CAAC,CAAC,CAAC;;IAEH;IACA;IACA;IACA;IACA,MAAMI,WAAW,GAAGnD,mCAAmC,CAAC,CAAC;IACzD,IAAI,CAACmD,WAAW,CAACC,QAAQ,CAACb,IAAI,CAAC,EAAE;MAC/BtC,mCAAmC,CAAC,CAAC,GAAGkD,WAAW,EAAEZ,IAAI,CAAC,CAAC;IAC7D;IACA5B,cAAc,CAAC0C,aAAa,CAAC,CAAC;IAE9B,IAAInC,OAAO,EAAE,MAAM;IAEnB,IAAIsB,QAAQ,EAAE;MACZ,IAAI;QACF/B,uBAAuB,CAACiC,gBAAgB,CAAC;QACzCxB,OAAO,GAAG,SAAStB,KAAK,CAAC0D,IAAI,CAACf,IAAI,CAAC,qDAAqD;MAC1F,CAAC,CAAC,OAAOgB,KAAK,EAAE;QACdrC,OAAO,GAAG,SAAStB,KAAK,CAAC0D,IAAI,CAACf,IAAI,CAAC,8DAA8DgB,KAAK,YAAYC,KAAK,GAAGD,KAAK,CAACrC,OAAO,GAAG,eAAe,EAAE;MAC7J;IACF,CAAC,MAAM;MACLA,OAAO,GAAG,SAAStB,KAAK,CAAC0D,IAAI,CAACf,IAAI,CAAC,0CAA0C;IAC/E;IAEA,MAAMkB,eAAe,GAAG,GAAGvC,OAAO,IAAItB,KAAK,CAAC8D,GAAG,CAAC,0BAA0B,CAAC,EAAE;IAC7EtC,MAAM,CAACqC,eAAe,CAAC;EACzB,CAAC;;EAED;EACA;EACA,IAAI,CAACvB,aAAa,EAAE;IAClB,OACE,CAAC,qBAAqB,CACpB,iBAAiB,CAAC,CAACE,QAAQ,CAACY,qBAAqB,CAAC,CAClD,cAAc,CAAC,CAACV,kBAAkB,CAAC,CACnC,QAAQ,CAAC,CAAC,MAAM;MACdlB,MAAM,CAAC,kCAAkC,CAAC;IAC5C,CAAC,CAAC,GACF;EAEN;EAEA,MAAMuC,MAAM,GAAG,MAAM9C,6BAA6B,CAChDqB,aAAa,EACbE,QAAQ,CAACY,qBACX,CAAC;EAED,IAAIW,MAAM,CAACC,UAAU,KAAK,SAAS,EAAE;IACnC,MAAM1C,OAAO,GAAGN,iBAAiB,CAAC+C,MAAM,CAAC;IAEzC,OACE,CAAC,WAAW,CACV,OAAO,CAAC,CAACzC,OAAO,CAAC,CACjB,IAAI,CAAC,CAACC,IAAI,IAAI,EAAE,CAAC,CACjB,MAAM,CAAC,CAAC,MAAMC,MAAM,CAACF,OAAO,CAAC,CAAC,GAC9B;EAEN;EAEA,OACE,CAAC,qBAAqB,CACpB,aAAa,CAAC,CAACyC,MAAM,CAACE,YAAY,CAAC,CACnC,iBAAiB,CAAC,CAACzB,QAAQ,CAACY,qBAAqB,CAAC,CAClD,cAAc,CAAC,CAACV,kBAAkB,CAAC,CACnC,QAAQ,CAAC,CAAC,MAAM;IACdlB,MAAM,CACJ,eAAexB,KAAK,CAAC0D,IAAI,CAACK,MAAM,CAACE,YAAY,CAAC,0BAChD,CAAC;EACH,CAAC,CAAC,GACF;AAEN","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/add-dir/index.ts b/src/commands/add-dir/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..e3475492bc7531d262ad442e8a66aa24dfe36d93 --- /dev/null +++ b/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: '', + load: () => import('./add-dir.js'), +} satisfies Command + +export default addDir diff --git a/src/commands/agents/agents.tsx b/src/commands/agents/agents.tsx new file mode 100644 index 0000000000000000000000000000000000000000..3af6273712ca291e7c30586a8031fb843b1912d1 --- /dev/null +++ b/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 { + const appState = context.getAppState(); + const permissionContext = appState.toolPermissionContext; + const tools = getTools(permissionContext); + return ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkFnZW50c01lbnUiLCJUb29sVXNlQ29udGV4dCIsImdldFRvb2xzIiwiTG9jYWxKU1hDb21tYW5kT25Eb25lIiwiY2FsbCIsIm9uRG9uZSIsImNvbnRleHQiLCJQcm9taXNlIiwiUmVhY3ROb2RlIiwiYXBwU3RhdGUiLCJnZXRBcHBTdGF0ZSIsInBlcm1pc3Npb25Db250ZXh0IiwidG9vbFBlcm1pc3Npb25Db250ZXh0IiwidG9vbHMiXSwic291cmNlcyI6WyJhZ2VudHMudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgQWdlbnRzTWVudSB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvYWdlbnRzL0FnZW50c01lbnUuanMnXG5pbXBvcnQgdHlwZSB7IFRvb2xVc2VDb250ZXh0IH0gZnJvbSAnLi4vLi4vVG9vbC5qcydcbmltcG9ydCB7IGdldFRvb2xzIH0gZnJvbSAnLi4vLi4vdG9vbHMuanMnXG5pbXBvcnQgdHlwZSB7IExvY2FsSlNYQ29tbWFuZE9uRG9uZSB9IGZyb20gJy4uLy4uL3R5cGVzL2NvbW1hbmQuanMnXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBjYWxsKFxuICBvbkRvbmU6IExvY2FsSlNYQ29tbWFuZE9uRG9uZSxcbiAgY29udGV4dDogVG9vbFVzZUNvbnRleHQsXG4pOiBQcm9taXNlPFJlYWN0LlJlYWN0Tm9kZT4ge1xuICBjb25zdCBhcHBTdGF0ZSA9IGNvbnRleHQuZ2V0QXBwU3RhdGUoKVxuICBjb25zdCBwZXJtaXNzaW9uQ29udGV4dCA9IGFwcFN0YXRlLnRvb2xQZXJtaXNzaW9uQ29udGV4dFxuICBjb25zdCB0b29scyA9IGdldFRvb2xzKHBlcm1pc3Npb25Db250ZXh0KVxuXG4gIHJldHVybiA8QWdlbnRzTWVudSB0b29scz17dG9vbHN9IG9uRXhpdD17b25Eb25lfSAvPlxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUtBLEtBQUssTUFBTSxPQUFPO0FBQzlCLFNBQVNDLFVBQVUsUUFBUSx1Q0FBdUM7QUFDbEUsY0FBY0MsY0FBYyxRQUFRLGVBQWU7QUFDbkQsU0FBU0MsUUFBUSxRQUFRLGdCQUFnQjtBQUN6QyxjQUFjQyxxQkFBcUIsUUFBUSx3QkFBd0I7QUFFbkUsT0FBTyxlQUFlQyxJQUFJQSxDQUN4QkMsTUFBTSxFQUFFRixxQkFBcUIsRUFDN0JHLE9BQU8sRUFBRUwsY0FBYyxDQUN4QixFQUFFTSxPQUFPLENBQUNSLEtBQUssQ0FBQ1MsU0FBUyxDQUFDLENBQUM7RUFDMUIsTUFBTUMsUUFBUSxHQUFHSCxPQUFPLENBQUNJLFdBQVcsQ0FBQyxDQUFDO0VBQ3RDLE1BQU1DLGlCQUFpQixHQUFHRixRQUFRLENBQUNHLHFCQUFxQjtFQUN4RCxNQUFNQyxLQUFLLEdBQUdYLFFBQVEsQ0FBQ1MsaUJBQWlCLENBQUM7RUFFekMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQ0UsS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUNSLE1BQU0sQ0FBQyxHQUFHO0FBQ3JEIiwiaWdub3JlTGlzdCI6W119 \ No newline at end of file diff --git a/src/commands/agents/index.ts b/src/commands/agents/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..ac43d2ec95258f2a7badafd9497c09e513e808b3 --- /dev/null +++ b/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 diff --git a/src/commands/ant-trace/index.js b/src/commands/ant-trace/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e1a619d254332b7e0c662931b91aae3a9f9c3b0e --- /dev/null +++ b/src/commands/ant-trace/index.js @@ -0,0 +1 @@ +export default { isEnabled: () => false, isHidden: true, name: 'stub' }; diff --git a/src/commands/autofix-pr/index.js b/src/commands/autofix-pr/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e1a619d254332b7e0c662931b91aae3a9f9c3b0e --- /dev/null +++ b/src/commands/autofix-pr/index.js @@ -0,0 +1 @@ +export default { isEnabled: () => false, isHidden: true, name: 'stub' }; diff --git a/src/commands/branch/branch.ts b/src/commands/branch/branch.ts new file mode 100644 index 0000000000000000000000000000000000000000..4a7c2779a408830c4fb5aa67463205fa03c342f9 --- /dev/null +++ b/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 | 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(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 { + 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([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 { + 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 + } +} diff --git a/src/commands/branch/index.ts b/src/commands/branch/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..731ff39fe572417053fceebe850fe118472b977f --- /dev/null +++ b/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 diff --git a/src/commands/break-cache/index.js b/src/commands/break-cache/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e1a619d254332b7e0c662931b91aae3a9f9c3b0e --- /dev/null +++ b/src/commands/break-cache/index.js @@ -0,0 +1 @@ +export default { isEnabled: () => false, isHidden: true, name: 'stub' }; diff --git a/src/commands/btw/index.ts b/src/commands/btw/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..d4888711d3b0779b7119e7d052b6b267998a6a39 --- /dev/null +++ b/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: '', + load: () => import('./btw.js'), +} satisfies Command + +export default btw diff --git a/src/commands/chrome/index.ts b/src/commands/chrome/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..0e9af5ff3c871e06879d217ec920b011a192f1cd --- /dev/null +++ b/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 diff --git a/src/commands/clear/clear.ts b/src/commands/clear/clear.ts new file mode 100644 index 0000000000000000000000000000000000000000..24c6295a1d4e36283582eaef179eb00c3bdc3cd3 --- /dev/null +++ b/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: '' } +} diff --git a/src/commands/clear/index.ts b/src/commands/clear/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..a426de6fa2048b3696ebfecf188e2431d7a39c10 --- /dev/null +++ b/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 diff --git a/src/commands/color/color.ts b/src/commands/color/color.ts new file mode 100644 index 0000000000000000000000000000000000000000..e4420b7f941e0b64e37347191b77632cff815641 --- /dev/null +++ b/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 { + // 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 +} diff --git a/src/commands/mcp/addCommand.ts b/src/commands/mcp/addCommand.ts new file mode 100644 index 0000000000000000000000000000000000000000..aeb3bc0537a6f266845e2b0d28c9971d8fd733c9 --- /dev/null +++ b/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 [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 ', + 'Configuration scope (local, user, or project)', + 'local', + ) + .option( + '-t, --transport ', + 'Transport type (stdio, sse, http). Defaults to stdio if not specified.', + ) + .option( + '-e, --env ', + 'Set environment variables (e.g. -e KEY=value)', + ) + .option( + '-H, --header ', + 'Set WebSocket headers (e.g. -H "X-Api-Key: abc123" -H "X-Custom: value")', + ) + .option('--client-id ', '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 ', + '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 [args...]', + ) + } else if (!actualCommand) { + cliError( + 'Error: Command is required when server name is provided.\n' + + 'Usage: claude mcp add [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) + } + }) +} diff --git a/src/commands/mcp/index.ts b/src/commands/mcp/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..153ac5b2c6393d695393b45d8b060be443bfc69a --- /dev/null +++ b/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 diff --git a/src/commands/mcp/mcp.tsx b/src/commands/mcp/mcp.tsx new file mode 100644 index 0000000000000000000000000000000000000000..f5cf40daf997e8f9530e519ebfb64a8a190c03a6 --- /dev/null +++ b/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 { + if (args) { + const parts = args.trim().split(/\s+/); + + // Allow /mcp no-redirect to bypass the redirect for testing + if (parts[0] === 'no-redirect') { + return ; + } + if (parts[0] === 'reconnect' && parts[1]) { + return ; + } + if (parts[0] === 'enable' || parts[0] === 'disable') { + return 1 ? parts.slice(1).join(' ') : 'all'} onComplete={onDone} />; + } + } + + // Redirect base /mcp command to /plugins installed tab for ant users + if ("external" === 'ant') { + return ; + } + return ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","MCPSettings","MCPReconnect","useMcpToggleEnabled","useAppState","LocalJSXCommandOnDone","PluginSettings","MCPToggle","t0","$","_c","action","target","onComplete","mcpClients","_temp","toggleMcpServer","didRun","t1","t2","current","isEnabling","clients","filter","_temp2","toToggle","c_0","c","type","c_1","name","length","s_0","s","mcp","call","onDone","_context","args","Promise","ReactNode","parts","trim","split","slice","join"],"sources":["mcp.tsx"],"sourcesContent":["import React, { useEffect, useRef } from 'react'\nimport { MCPSettings } from '../../components/mcp/index.js'\nimport { MCPReconnect } from '../../components/mcp/MCPReconnect.js'\nimport { useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js'\nimport { useAppState } from '../../state/AppState.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { PluginSettings } from '../plugin/PluginSettings.js'\n\n// TODO: This is a hack to get the context value from toggleMcpServer (useContext only works in a component)\n// Ideally, all MCP state and functions would be in global state.\nfunction MCPToggle({\n  action,\n  target,\n  onComplete,\n}: {\n  action: 'enable' | 'disable'\n  target: string\n  onComplete: (result: string) => void\n}): null {\n  const mcpClients = useAppState(s => s.mcp.clients)\n  const toggleMcpServer = useMcpToggleEnabled()\n  const didRun = useRef(false)\n\n  useEffect(() => {\n    if (didRun.current) return\n    didRun.current = true\n\n    const isEnabling = action === 'enable'\n    const clients = mcpClients.filter(c => c.name !== 'ide')\n    const toToggle =\n      target === 'all'\n        ? clients.filter(c =>\n            isEnabling ? c.type === 'disabled' : c.type !== 'disabled',\n          )\n        : clients.filter(c => c.name === target)\n\n    if (toToggle.length === 0) {\n      onComplete(\n        target === 'all'\n          ? `All MCP servers are already ${isEnabling ? 'enabled' : 'disabled'}`\n          : `MCP server \"${target}\" not found`,\n      )\n      return\n    }\n\n    for (const s of toToggle) {\n      void toggleMcpServer(s.name)\n    }\n\n    onComplete(\n      target === 'all'\n        ? `${isEnabling ? 'Enabled' : 'Disabled'} ${toToggle.length} MCP server(s)`\n        : `MCP server \"${target}\" ${isEnabling ? 'enabled' : 'disabled'}`,\n    )\n  }, [action, target, mcpClients, toggleMcpServer, onComplete])\n\n  return null\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  _context: unknown,\n  args?: string,\n): Promise<React.ReactNode> {\n  if (args) {\n    const parts = args.trim().split(/\\s+/)\n\n    // Allow /mcp no-redirect to bypass the redirect for testing\n    if (parts[0] === 'no-redirect') {\n      return <MCPSettings onComplete={onDone} />\n    }\n\n    if (parts[0] === 'reconnect' && parts[1]) {\n      return (\n        <MCPReconnect\n          serverName={parts.slice(1).join(' ')}\n          onComplete={onDone}\n        />\n      )\n    }\n\n    if (parts[0] === 'enable' || parts[0] === 'disable') {\n      return (\n        <MCPToggle\n          action={parts[0]}\n          target={parts.length > 1 ? parts.slice(1).join(' ') : 'all'}\n          onComplete={onDone}\n        />\n      )\n    }\n  }\n\n  // Redirect base /mcp command to /plugins installed tab for ant users\n  if (\"external\" === 'ant') {\n    return (\n      <PluginSettings\n        onComplete={onDone}\n        args=\"manage\"\n        showMcpRedirectMessage\n      />\n    )\n  }\n\n  return <MCPSettings onComplete={onDone} />\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/mcp/xaaIdpCommand.ts b/src/commands/mcp/xaaIdpCommand.ts new file mode 100644 index 0000000000000000000000000000000000000000..df8a8881bf6eecfdcbff5b373601da5239b5d720 --- /dev/null +++ b/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 ', 'IdP issuer URL (OIDC discovery)') + .requiredOption('--client-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 ', + '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 ', + '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') + }) +} diff --git a/src/commands/memory/index.ts b/src/commands/memory/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..31f254c95d63206431d3f1a72dbedcc2433c009c --- /dev/null +++ b/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 diff --git a/src/commands/memory/memory.tsx b/src/commands/memory/memory.tsx new file mode 100644 index 0000000000000000000000000000000000000000..5ca53ae450e935bfdbf569a06c80321051fef42e --- /dev/null +++ b/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 + + + + + + + + Learn more: + + + + ; +} +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 ; +}; +//# 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":[]} \ No newline at end of file diff --git a/src/commands/mobile/index.ts b/src/commands/mobile/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..2657aa8429532c00252cbf5f498e9117a0961f1e --- /dev/null +++ b/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 diff --git a/src/commands/mobile/mobile.tsx b/src/commands/mobile/mobile.tsx new file mode 100644 index 0000000000000000000000000000000000000000..40968c19ec83dad03a686c613dce3cfd517d7099 --- /dev/null +++ b/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 = { + 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 = ; + t12 = ; + $[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 = ; + t15 = ; + $[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 = iOS; + $[23] = t16; + $[24] = t17; + $[25] = t18; + } else { + t18 = $[25]; + } + let t19; + if ($[26] === Symbol.for("react.memo_cache_sentinel")) { + t19 = {" / "}; + $[26] = t19; + } else { + t19 = $[26]; + } + const t20 = platform === "android"; + const t21 = platform === "android"; + let t22; + if ($[27] !== t20 || $[28] !== t21) { + t22 = Android; + $[27] = t20; + $[28] = t21; + $[29] = t22; + } else { + t22 = $[29]; + } + let t23; + if ($[30] !== t18 || $[31] !== t22) { + t23 = {t18}{t19}{t22}; + $[30] = t18; + $[31] = t22; + $[32] = t23; + } else { + t23 = $[32]; + } + let t24; + if ($[33] === Symbol.for("react.memo_cache_sentinel")) { + t24 = (tab to switch, esc to close); + $[33] = t24; + } else { + t24 = $[33]; + } + let t25; + if ($[34] !== t23) { + t25 = {t23}{t24}; + $[34] = t23; + $[35] = t25; + } else { + t25 = $[35]; + } + let t26; + if ($[36] !== url) { + t26 = {url}; + $[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 = {t11}{t12}{t13}{t14}{t15}{t25}{t26}; + $[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 = {t27}; + $[49] = T1; + $[50] = t27; + $[51] = t28; + } else { + t28 = $[51]; + } + return t28; +} +function _temp4(line_0, i) { + return {line_0}; +} +function _temp3(line) { + return line.length > 0; +} +function _temp2(prev) { + return prev === "ios" ? "android" : "ios"; +} +function _temp() {} +export async function call(onDone: LocalJSXCommandOnDone): Promise { + return ; +} +//# 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":[]} \ No newline at end of file diff --git a/src/commands/mock-limits/index.js b/src/commands/mock-limits/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e1a619d254332b7e0c662931b91aae3a9f9c3b0e --- /dev/null +++ b/src/commands/mock-limits/index.js @@ -0,0 +1 @@ +export default { isEnabled: () => false, isHidden: true, name: 'stub' }; diff --git a/src/commands/model/index.ts b/src/commands/model/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..5554906e65a01482ecba040a9d182cf8b6a513f8 --- /dev/null +++ b/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 diff --git a/src/commands/model/model.tsx b/src/commands/model/model.tsx new file mode 100644 index 0000000000000000000000000000000000000000..65c084d9fb959e43044d1806983b4a2fa6e9fb6a --- /dev/null +++ b/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 = ; + $[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 { + 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 ; + } + 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 ; + } + return ; +}; +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":";AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,cAAcC,oBAAoB,QAAQ,mBAAmB;AAC7D,SAASC,WAAW,QAAQ,iCAAiC;AAC7D,SAASC,gBAAgB,EAAEC,gBAAgB,QAAQ,wBAAwB;AAC3E,SACE,KAAKC,0DAA0D,EAC/DC,QAAQ,QACH,mCAAmC;AAC1C,SAASC,WAAW,EAAEC,cAAc,QAAQ,yBAAyB;AACrE,cAAcC,mBAAmB,QAAQ,wBAAwB;AACjE,cAAcC,WAAW,QAAQ,uBAAuB;AACxD,SAASC,oBAAoB,QAAQ,2BAA2B;AAChE,SACEC,qBAAqB,EACrBC,mBAAmB,EACnBC,iBAAiB,EACjBC,0BAA0B,QACrB,yBAAyB;AAChC,SAASC,aAAa,QAAQ,8BAA8B;AAC5D,SACEC,iBAAiB,EACjBC,mBAAmB,QACd,oCAAoC;AAC3C,SACEC,8BAA8B,EAC9BC,oBAAoB,EACpBC,yBAAyB,QACpB,4BAA4B;AACnC,SAASC,cAAc,QAAQ,qCAAqC;AACpE,SAASC,aAAa,QAAQ,oCAAoC;AAElE,SAAAC,mBAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAA4B;IAAAC;EAAA,IAAAH,EAO3B;EACC,MAAAI,aAAA,GAAsBtB,WAAW,CAACuB,KAAoB,CAAC;EACvD,MAAAC,uBAAA,GAAgCxB,WAAW,CAACyB,MAA8B,CAAC;EAC3E,MAAAC,UAAA,GAAmB1B,WAAW,CAAC2B,MAAe,CAAC;EAC/C,MAAAC,WAAA,GAAoB3B,cAAc,CAAC,CAAC;EAAA,IAAA4B,EAAA;EAAA,IAAAV,CAAA,QAAAG,aAAA,IAAAH,CAAA,QAAAE,MAAA;IAEpCQ,EAAA,YAAAC,aAAA;MACE/B,QAAQ,CAAC,0BAA0B,EAAE;QAAAgC,MAAA,EAEjC,QAAQ,IAAIjC;MAChB,CAAC,CAAC;MACF,MAAAkC,YAAA,GAAqBC,gBAAgB,CAACX,aAAa,CAAC;MACpDD,MAAM,CAAC,iBAAiB7B,KAAK,CAAA0C,IAAK,CAACF,YAAY,CAAC,EAAE,EAAE;QAAAG,OAAA,EACzC;MACX,CAAC,CAAC;IAAA,CACH;IAAAhB,CAAA,MAAAG,aAAA;IAAAH,CAAA,MAAAE,MAAA;IAAAF,CAAA,MAAAU,EAAA;EAAA;IAAAA,EAAA,GAAAV,CAAA;EAAA;EATD,MAAAW,YAAA,GAAAD,EASC;EAAA,IAAAO,EAAA;EAAA,IAAAjB,CAAA,QAAAO,UAAA,IAAAP,CAAA,QAAAG,aAAA,IAAAH,CAAA,QAAAE,MAAA,IAAAF,CAAA,QAAAS,WAAA;IAEDQ,EAAA,YAAAC,aAAAC,KAAA,EAAAC,MAAA;MAIExC,QAAQ,CAAC,0BAA0B,EAAE;QAAAgC,MAAA,EAEjCO,KAAK,IAAIxC,0DAA0D;QAAA0C,UAAA,EAEnElB,aAAa,IAAIxB,0DAA0D;QAAA2C,QAAA,EAE3EH,KAAK,IAAIxC;MACb,CAAC,CAAC;MACF8B,WAAW,CAACc,IAAA,KAAS;QAAA,GAChBA,IAAI;QAAApB,aAAA,EACQgB,KAAK;QAAAd,uBAAA,EACK;MAC3B,CAAC,CAAC,CAAC;MAEH,IAAAmB,OAAA,GAAc,gBAAgBnD,KAAK,CAAA0C,IAAK,CAACD,gBAAgB,CAACK,KAAK,CAAC,CAAC,EAAE;MACnE,IAAIC,MAAM,KAAKK,SAAS;QACtBD,OAAA,GAAAA,OAAO,GAAI,SAASnD,KAAK,CAAA0C,IAAK,CAACK,MAAM,CAAC,SAAS;MAAA;MAIjD,IAAAM,oBAAA,GAA2BD,SAAS;MACpC,IAAIrC,iBAAiB,CAAC,CAAC;QACrBF,qBAAqB,CAAC,CAAC;QACvB,IAAI,CAACG,0BAA0B,CAAC8B,KAAK,CAAe,IAAhDZ,UAAgD;UAClDE,WAAW,CAACkB,MAGV,CAAC;UACHD,oBAAA,CAAAA,CAAA,CAAuBA,KAAK;QAAR;UAEf,IACLrC,0BAA0B,CAAC8B,KACP,CAAC,IAArBhC,mBAAmB,CAAC,CACV,IAFVoB,UAEU;YAEViB,OAAA,GAAAA,OAAO,GAAI,oBAAiB;YAC5BE,oBAAA,CAAAA,CAAA,CAAuBA,IAAI;UAAP;QACrB;MAAA;MAGH,IACEzC,oBAAoB,CAClBkC,KAAK,EACLO,oBAAoB,KAAK,IAAI,EAC7BhC,oBAAoB,CAAC,CACvB,CAAC;QAED8B,OAAA,GAAAA,OAAO,GAAI,6BAA0B;MAAA;MAGvC,IAAIE,oBAAoB,KAAK,KAAK;QAEhCF,OAAA,GAAAA,OAAO,GAAI,qBAAkB;MAAA;MAG/BtB,MAAM,CAACsB,OAAO,CAAC;IAAA,CAChB;IAAAxB,CAAA,MAAAO,UAAA;IAAAP,CAAA,MAAAG,aAAA;IAAAH,CAAA,MAAAE,MAAA;IAAAF,CAAA,MAAAS,WAAA;IAAAT,CAAA,MAAAiB,EAAA;EAAA;IAAAA,EAAA,GAAAjB,CAAA;EAAA;EA5DD,MAAAkB,YAAA,GAAAD,EA4DC;EAAA,IAAAW,EAAA;EAAA,IAAA5B,CAAA,QAAAO,UAAA,IAAAP,CAAA,QAAAG,aAAA;IAUKyB,EAAA,GAAAxC,iBAAiB,CACR,CAAC,IADVmB,UAEyC,IAAzClB,0BAA0B,CAACc,aAAa,CACnB,IAArBhB,mBAAmB,CAAC,CAAC;IAAAa,CAAA,MAAAO,UAAA;IAAAP,CAAA,MAAAG,aAAA;IAAAH,CAAA,OAAA4B,EAAA;EAAA;IAAAA,EAAA,GAAA5B,CAAA;EAAA;EAAA,IAAA6B,EAAA;EAAA,IAAA7B,CAAA,SAAAW,YAAA,IAAAX,CAAA,SAAAkB,YAAA,IAAAlB,CAAA,SAAAG,aAAA,IAAAH,CAAA,SAAAK,uBAAA,IAAAL,CAAA,SAAA4B,EAAA;IAVzBC,EAAA,IAAC,WAAW,CACD1B,OAAa,CAAbA,cAAY,CAAC,CACRE,YAAuB,CAAvBA,wBAAsB,CAAC,CAC3Ba,QAAY,CAAZA,aAAW,CAAC,CACZP,QAAY,CAAZA,aAAW,CAAC,CACtB,mBAAmB,CAAnB,KAAkB,CAAC,CAEjB,kBAGqB,CAHrB,CAAAiB,EAGoB,CAAC,GAEvB;IAAA5B,CAAA,OAAAW,YAAA;IAAAX,CAAA,OAAAkB,YAAA;IAAAlB,CAAA,OAAAG,aAAA;IAAAH,CAAA,OAAAK,uBAAA;IAAAL,CAAA,OAAA4B,EAAA;IAAA5B,CAAA,OAAA6B,EAAA;EAAA;IAAAA,EAAA,GAAA7B,CAAA;EAAA;EAAA,OAZF6B,EAYE;AAAA;AAnGN,SAAAF,OAAAG,MAAA;EAAA,OAoD6B;IAAA,GAChBP,MAAI;IAAAQ,QAAA,EACG;EACZ,CAAC;AAAA;AAvDT,SAAAvB,OAAAwB,GAAA;EAAA,OAUsCC,GAAC,CAAAF,QAAS;AAAA;AAVhD,SAAAzB,OAAA4B,GAAA;EAAA,OASmDD,GAAC,CAAA5B,uBAAwB;AAAA;AAT5E,SAAAD,MAAA6B,CAAA;EAAA,OAQyCA,CAAC,CAAA9B,aAAc;AAAA;AA+FxD,SAASgC,gBAAgBA,CAAC;EACxBC,IAAI;EACJlC;AAOF,CANC,EAAE;EACDkC,IAAI,EAAE,MAAM;EACZlC,MAAM,EAAE,CACNmC,MAAe,CAAR,EAAE,MAAM,EACfC,OAA4C,CAApC,EAAE;IAAEtB,OAAO,CAAC,EAAEzC,oBAAoB;EAAC,CAAC,EAC5C,GAAG,IAAI;AACX,CAAC,CAAC,EAAED,KAAK,CAACiE,SAAS,CAAC;EAClB,MAAMhC,UAAU,GAAG1B,WAAW,CAACoD,CAAC,IAAIA,CAAC,CAACF,QAAQ,CAAC;EAC/C,MAAMtB,WAAW,GAAG3B,cAAc,CAAC,CAAC;EACpC,MAAMqC,KAAK,GAAGiB,IAAI,KAAK,SAAS,GAAG,IAAI,GAAGA,IAAI;EAE9C9D,KAAK,CAACkE,SAAS,CAAC,MAAM;IACpB,eAAeC,iBAAiBA,CAAA,CAAE,EAAEC,OAAO,CAAC,IAAI,CAAC,CAAC;MAChD,IAAIvB,KAAK,IAAI,CAACvB,cAAc,CAACuB,KAAK,CAAC,EAAE;QACnCjB,MAAM,CACJ,UAAUiB,KAAK,kEAAkE,EACjF;UAAEH,OAAO,EAAE;QAAS,CACtB,CAAC;QACD;MACF;;MAEA;MACA,IAAIG,KAAK,IAAIwB,mBAAmB,CAACxB,KAAK,CAAC,EAAE;QACvCjB,MAAM,CACJ,+IAA+I,EAC/I;UAAEc,OAAO,EAAE;QAAS,CACtB,CAAC;QACD;MACF;MAEA,IAAIG,KAAK,IAAIyB,qBAAqB,CAACzB,KAAK,CAAC,EAAE;QACzCjB,MAAM,CACJ,iJAAiJ,EACjJ;UAAEc,OAAO,EAAE;QAAS,CACtB,CAAC;QACD;MACF;;MAEA;MACA,IAAI,CAACG,KAAK,EAAE;QACV0B,QAAQ,CAAC,IAAI,CAAC;QACd;MACF;;MAEA;MACA,IAAIC,YAAY,CAAC3B,KAAK,CAAC,EAAE;QACvB0B,QAAQ,CAAC1B,KAAK,CAAC;QACf;MACF;;MAEA;MACA,IAAI;QACF;QACA;QACA,MAAM;UAAE4B,KAAK;UAAEC,KAAK,EAALA;QAAM,CAAC,GAAG,MAAMnD,aAAa,CAACsB,KAAK,CAAC;QAEnD,IAAI4B,KAAK,EAAE;UACTF,QAAQ,CAAC1B,KAAK,CAAC;QACjB,CAAC,MAAM;UACLjB,MAAM,CAAC8C,OAAK,IAAI,UAAU7B,KAAK,aAAa,EAAE;YAC5CH,OAAO,EAAE;UACX,CAAC,CAAC;QACJ;MACF,CAAC,CAAC,OAAOgC,KAAK,EAAE;QACd9C,MAAM,CAAC,6BAA6B,CAAC8C,KAAK,IAAIC,KAAK,EAAEzB,OAAO,EAAE,EAAE;UAC9DR,OAAO,EAAE;QACX,CAAC,CAAC;MACJ;IACF;IAEA,SAAS6B,QAAQA,CAACK,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC;MACjDzC,WAAW,CAACc,IAAI,KAAK;QACnB,GAAGA,IAAI;QACPpB,aAAa,EAAE+C,UAAU;QACzB7C,uBAAuB,EAAE;MAC3B,CAAC,CAAC,CAAC;MACH,IAAImB,OAAO,GAAG,gBAAgBnD,KAAK,CAAC0C,IAAI,CAACD,gBAAgB,CAACoC,UAAU,CAAC,CAAC,EAAE;MAExE,IAAIxB,oBAAoB,GAAGD,SAAS;MACpC,IAAIrC,iBAAiB,CAAC,CAAC,EAAE;QACvBF,qBAAqB,CAAC,CAAC;QACvB,IAAI,CAACG,0BAA0B,CAAC6D,UAAU,CAAC,IAAI3C,UAAU,EAAE;UACzDE,WAAW,CAACc,MAAI,KAAK;YACnB,GAAGA,MAAI;YACPQ,QAAQ,EAAE;UACZ,CAAC,CAAC,CAAC;UACHL,oBAAoB,GAAG,KAAK;UAC5B;QACF,CAAC,MAAM,IAAIrC,0BAA0B,CAAC6D,UAAU,CAAC,IAAI3C,UAAU,EAAE;UAC/DiB,OAAO,IAAI,iBAAiB;UAC5BE,oBAAoB,GAAG,IAAI;QAC7B;MACF;MAEA,IACEzC,oBAAoB,CAClBiE,UAAU,EACVxB,oBAAoB,KAAK,IAAI,EAC7BhC,oBAAoB,CAAC,CACvB,CAAC,EACD;QACA8B,OAAO,IAAI,0BAA0B;MACvC;MAEA,IAAIE,oBAAoB,KAAK,KAAK,EAAE;QAClC;QACAF,OAAO,IAAI,kBAAkB;MAC/B;MAEAtB,MAAM,CAACsB,OAAO,CAAC;IACjB;IAEA,KAAKiB,iBAAiB,CAAC,CAAC;EAC1B,CAAC,EAAE,CAACtB,KAAK,EAAEjB,MAAM,EAAEO,WAAW,CAAC,CAAC;EAEhC,OAAO,IAAI;AACb;AAEA,SAASqC,YAAYA,CAAC3B,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC;EAC5C,OAAO,CAAC7B,aAAa,IAAI,SAAS,MAAM,EAAE,EAAE6D,QAAQ,CAClDhC,KAAK,CAACiC,WAAW,CAAC,CAAC,CAACC,IAAI,CAAC,CAC3B,CAAC;AACH;AAEA,SAASV,mBAAmBA,CAACxB,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC;EACnD,MAAMmC,CAAC,GAAGnC,KAAK,CAACiC,WAAW,CAAC,CAAC;EAC7B,OACE,CAAC7D,iBAAiB,CAAC,CAAC,IACpB,CAACG,oBAAoB,CAAC,CAAC,IACvB4D,CAAC,CAACH,QAAQ,CAAC,MAAM,CAAC,IAClBG,CAAC,CAACH,QAAQ,CAAC,MAAM,CAAC;AAEtB;AAEA,SAASP,qBAAqBA,CAACzB,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC;EACrD,MAAMmC,CAAC,GAAGnC,KAAK,CAACiC,WAAW,CAAC,CAAC;EAC7B;EACA;EACA,OACE,CAAC5D,mBAAmB,CAAC,CAAC,KACrB8D,CAAC,CAACH,QAAQ,CAAC,YAAY,CAAC,IAAIG,CAAC,CAACH,QAAQ,CAAC,gBAAgB,CAAC,CAAC;AAE9D;AAEA,SAAAI,kBAAAxD,EAAA;EAA2B;IAAAG;EAAA,IAAAH,EAI1B;EACC,MAAAI,aAAA,GAAsBtB,WAAW,CAAC2E,MAAoB,CAAC;EACvD,MAAAnD,uBAAA,GAAgCxB,WAAW,CAAC4E,MAA8B,CAAC;EAC3E,MAAAC,WAAA,GAAoB7E,WAAW,CAAC8E,MAAkB,CAAC;EACnD,MAAA9C,YAAA,GAAqBC,gBAAgB,CAACX,aAAa,CAAC;EACpD,MAAAyD,UAAA,GACEF,WAAW,KAAKjC,SAA4C,GAA5D,aAAyCiC,WAAW,GAAQ,GAA5D,EAA4D;EAE9D,IAAIrD,uBAAuB;IACzBH,MAAM,CACJ,kBAAkB7B,KAAK,CAAA0C,IAAK,CAACD,gBAAgB,CAACT,uBAAuB,CAAC,CAAC,mDAAmDQ,YAAY,GAAG+C,UAAU,EACrJ,CAAC;EAAA;IAED1D,MAAM,CAAC,kBAAkBW,YAAY,GAAG+C,UAAU,EAAE,CAAC;EAAA;EACtD,OAEM,IAAI;AAAA;AApBb,SAAAD,OAAA3B,GAAA;EAAA,OAOuCC,GAAC,CAAAyB,WAAY;AAAA;AAPpD,SAAAD,OAAAvB,GAAA;EAAA,OAMmDD,GAAC,CAAA5B,uBAAwB;AAAA;AAN5E,SAAAmD,OAAAvB,CAAA;EAAA,OAKyCA,CAAC,CAAA9B,aAAc;AAAA;AAkBxD,OAAO,MAAM0D,IAAI,EAAE9E,mBAAmB,GAAG,MAAA8E,CAAO3D,MAAM,EAAE4D,QAAQ,EAAE1B,IAAI,KAAK;EACzEA,IAAI,GAAGA,IAAI,EAAEiB,IAAI,CAAC,CAAC,IAAI,EAAE;EACzB,IAAI3E,gBAAgB,CAACyE,QAAQ,CAACf,IAAI,CAAC,EAAE;IACnCxD,QAAQ,CAAC,iCAAiC,EAAE;MAC1CwD,IAAI,EAAEA,IAAI,IAAIzD;IAChB,CAAC,CAAC;IACF,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAACuB,MAAM,CAAC,GAAG;EAC9C;EACA,IAAIzB,gBAAgB,CAAC0E,QAAQ,CAACf,IAAI,CAAC,EAAE;IACnClC,MAAM,CACJ,sFAAsF,EACtF;MAAEc,OAAO,EAAE;IAAS,CACtB,CAAC;IACD;EACF;EAEA,IAAIoB,IAAI,EAAE;IACRxD,QAAQ,CAAC,4BAA4B,EAAE;MACrCwD,IAAI,EAAEA,IAAI,IAAIzD;IAChB,CAAC,CAAC;IACF,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAACyD,IAAI,CAAC,CAAC,MAAM,CAAC,CAAClC,MAAM,CAAC,GAAG;EACzD;EAEA,OAAO,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAACA,MAAM,CAAC,GAAG;AAC/C,CAAC;AAED,SAASY,gBAAgBA,CAACK,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,EAAE,MAAM,CAAC;EACtD,MAAM4C,QAAQ,GAAGpE,yBAAyB,CACxCwB,KAAK,IAAI1B,8BAA8B,CAAC,CAC1C,CAAC;EACD,OAAO0B,KAAK,KAAK,IAAI,GAAG,GAAG4C,QAAQ,YAAY,GAAGA,QAAQ;AAC5D","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/oauth-refresh/index.js b/src/commands/oauth-refresh/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e1a619d254332b7e0c662931b91aae3a9f9c3b0e --- /dev/null +++ b/src/commands/oauth-refresh/index.js @@ -0,0 +1 @@ +export default { isEnabled: () => false, isHidden: true, name: 'stub' }; diff --git a/src/commands/onboarding/index.js b/src/commands/onboarding/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e1a619d254332b7e0c662931b91aae3a9f9c3b0e --- /dev/null +++ b/src/commands/onboarding/index.js @@ -0,0 +1 @@ +export default { isEnabled: () => false, isHidden: true, name: 'stub' }; diff --git a/src/commands/output-style/index.ts b/src/commands/output-style/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..5cb0e25e62094f477e8fe052c0a7db65842217cc --- /dev/null +++ b/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 diff --git a/src/commands/output-style/output-style.tsx b/src/commands/output-style/output-style.tsx new file mode 100644 index 0000000000000000000000000000000000000000..9e26bf38271aa34831198486cd6a281b3837e7ed --- /dev/null +++ b/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 { + 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 \ No newline at end of file diff --git a/src/commands/passes/index.ts b/src/commands/passes/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..fc160132296f2fb58af3998a9caf8fd263cd0f0b --- /dev/null +++ b/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 diff --git a/src/commands/passes/passes.tsx b/src/commands/passes/passes.tsx new file mode 100644 index 0000000000000000000000000000000000000000..c17cb59471931801247123bf435029f4f2e94479 --- /dev/null +++ b/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 { + // 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 ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/src/commands/perf-issue/index.js b/src/commands/perf-issue/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e1a619d254332b7e0c662931b91aae3a9f9c3b0e --- /dev/null +++ b/src/commands/perf-issue/index.js @@ -0,0 +1 @@ +export default { isEnabled: () => false, isHidden: true, name: 'stub' }; diff --git a/src/commands/permissions/index.ts b/src/commands/permissions/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..ef4641f0e342b2ff65ce92725648fab0ef9de14e --- /dev/null +++ b/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 diff --git a/src/commands/permissions/permissions.tsx b/src/commands/permissions/permissions.tsx new file mode 100644 index 0000000000000000000000000000000000000000..6248fd96b8e10b7fc067855bdeed5bb52f09f042 --- /dev/null +++ b/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 { + context.setMessages(prev => [...prev, createPermissionRetryMessage(commands)]); + }} />; +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlBlcm1pc3Npb25SdWxlTGlzdCIsIkxvY2FsSlNYQ29tbWFuZENhbGwiLCJjcmVhdGVQZXJtaXNzaW9uUmV0cnlNZXNzYWdlIiwiY2FsbCIsIm9uRG9uZSIsImNvbnRleHQiLCJjb21tYW5kcyIsInNldE1lc3NhZ2VzIiwicHJldiJdLCJzb3VyY2VzIjpbInBlcm1pc3Npb25zLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tICdyZWFjdCdcbmltcG9ydCB7IFBlcm1pc3Npb25SdWxlTGlzdCB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvcGVybWlzc2lvbnMvcnVsZXMvUGVybWlzc2lvblJ1bGVMaXN0LmpzJ1xuaW1wb3J0IHR5cGUgeyBMb2NhbEpTWENvbW1hbmRDYWxsIH0gZnJvbSAnLi4vLi4vdHlwZXMvY29tbWFuZC5qcydcbmltcG9ydCB7IGNyZWF0ZVBlcm1pc3Npb25SZXRyeU1lc3NhZ2UgfSBmcm9tICcuLi8uLi91dGlscy9tZXNzYWdlcy5qcydcblxuZXhwb3J0IGNvbnN0IGNhbGw6IExvY2FsSlNYQ29tbWFuZENhbGwgPSBhc3luYyAob25Eb25lLCBjb250ZXh0KSA9PiB7XG4gIHJldHVybiAoXG4gICAgPFBlcm1pc3Npb25SdWxlTGlzdFxuICAgICAgb25FeGl0PXtvbkRvbmV9XG4gICAgICBvblJldHJ5RGVuaWFscz17Y29tbWFuZHMgPT4ge1xuICAgICAgICBjb250ZXh0LnNldE1lc3NhZ2VzKHByZXYgPT4gW1xuICAgICAgICAgIC4uLnByZXYsXG4gICAgICAgICAgY3JlYXRlUGVybWlzc2lvblJldHJ5TWVzc2FnZShjb21tYW5kcyksXG4gICAgICAgIF0pXG4gICAgICB9fVxuICAgIC8+XG4gIClcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLQSxLQUFLLE1BQU0sT0FBTztBQUM5QixTQUFTQyxrQkFBa0IsUUFBUSwwREFBMEQ7QUFDN0YsY0FBY0MsbUJBQW1CLFFBQVEsd0JBQXdCO0FBQ2pFLFNBQVNDLDRCQUE0QixRQUFRLHlCQUF5QjtBQUV0RSxPQUFPLE1BQU1DLElBQUksRUFBRUYsbUJBQW1CLEdBQUcsTUFBQUUsQ0FBT0MsTUFBTSxFQUFFQyxPQUFPLEtBQUs7RUFDbEUsT0FDRSxDQUFDLGtCQUFrQixDQUNqQixNQUFNLENBQUMsQ0FBQ0QsTUFBTSxDQUFDLENBQ2YsY0FBYyxDQUFDLENBQUNFLFFBQVEsSUFBSTtJQUMxQkQsT0FBTyxDQUFDRSxXQUFXLENBQUNDLElBQUksSUFBSSxDQUMxQixHQUFHQSxJQUFJLEVBQ1BOLDRCQUE0QixDQUFDSSxRQUFRLENBQUMsQ0FDdkMsQ0FBQztFQUNKLENBQUMsQ0FBQyxHQUNGO0FBRU4sQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ== \ No newline at end of file diff --git a/src/commands/plan/index.ts b/src/commands/plan/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..c710899c9f634c18dc6964a9340c968969325efa --- /dev/null +++ b/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|]', + load: () => import('./plan.js'), +} satisfies Command + +export default plan diff --git a/src/commands/plan/plan.tsx b/src/commands/plan/plan.tsx new file mode 100644 index 0000000000000000000000000000000000000000..c8597b0c2f6852f04a975cf2dffa74348b03f55a --- /dev/null +++ b/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 = Current Plan; + $[0] = t1; + } else { + t1 = $[0]; + } + let t2; + if ($[1] !== planPath) { + t2 = {planPath}; + $[1] = planPath; + $[2] = t2; + } else { + t2 = $[2]; + } + let t3; + if ($[3] !== planContent) { + t3 = {planContent}; + $[3] = planContent; + $[4] = t3; + } else { + t3 = $[4]; + } + let t4; + if ($[5] !== editorName) { + t4 = editorName && "/plan open" to edit this plan in {editorName}; + $[5] = editorName; + $[6] = t4; + } else { + t4 = $[6]; + } + let t5; + if ($[7] !== t2 || $[8] !== t3 || $[9] !== t4) { + t5 = {t1}{t2}{t3}{t4}; + $[7] = t2; + $[8] = t3; + $[9] = t4; + $[10] = t5; + } else { + t5 = $[10]; + } + return t5; +} +export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext, args: string): Promise { + 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 = ; + + // 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":[]} \ No newline at end of file diff --git a/src/commands/plugin/AddMarketplace.tsx b/src/commands/plugin/AddMarketplace.tsx new file mode 100644 index 0000000000000000000000000000000000000000..79b8188db376c397ac1df2030010d0f692fe67f9 --- /dev/null +++ b/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; + 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(''); + 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 + + + Add Marketplace + + + Enter marketplace source: + Examples: + · owner/repo (GitHub) + · git@github.com:owner/repo.git (SSH) + · https://example.com/marketplace.json + · ./path/to/marketplace + + + + + {isLoading && + + + {progressMessage || 'Adding marketplace to configuration…'} + + } + {error && + {error} + } + {result && + {result} + } + + + + + + + + + + ; +} +//# 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":[]} \ No newline at end of file diff --git a/src/commands/plugin/BrowseMarketplace.tsx b/src/commands/plugin/BrowseMarketplace.tsx new file mode 100644 index 0000000000000000000000000000000000000000..4d1a24d42f5a02b172863c454ee4dcd36ab7b389 --- /dev/null +++ b/src/commands/plugin/BrowseMarketplace.tsx @@ -0,0 +1,802 @@ +import figures from 'figures'; +import * as React from 'react'; +import { useEffect, useState } from 'react'; +import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'; +import { Byline } from '../../components/design-system/Byline.js'; +import { Box, Text } from '../../ink.js'; +import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js'; +import type { LoadedPlugin } from '../../types/plugin.js'; +import { count } from '../../utils/array.js'; +import { openBrowser } from '../../utils/browser.js'; +import { logForDebugging } from '../../utils/debug.js'; +import { errorMessage } from '../../utils/errors.js'; +import { clearAllCaches } from '../../utils/plugins/cacheUtils.js'; +import { formatInstallCount, getInstallCounts } from '../../utils/plugins/installCounts.js'; +import { isPluginGloballyInstalled, isPluginInstalled } from '../../utils/plugins/installedPluginsManager.js'; +import { createPluginId, formatFailureDetails, formatMarketplaceLoadingErrors, getMarketplaceSourceDisplay, loadMarketplacesWithGracefulDegradation } from '../../utils/plugins/marketplaceHelpers.js'; +import { getMarketplace, loadKnownMarketplacesConfig } from '../../utils/plugins/marketplaceManager.js'; +import { OFFICIAL_MARKETPLACE_NAME } from '../../utils/plugins/officialMarketplace.js'; +import { installPluginFromMarketplace } from '../../utils/plugins/pluginInstallationHelpers.js'; +import { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js'; +import { plural } from '../../utils/stringUtils.js'; +import { truncateToWidth } from '../../utils/truncate.js'; +import { findPluginOptionsTarget, PluginOptionsFlow } from './PluginOptionsFlow.js'; +import { PluginTrustWarning } from './PluginTrustWarning.js'; +import { buildPluginDetailsMenuOptions, extractGitHubRepo, type InstallablePlugin, PluginSelectionKeyHint } from './pluginDetailsHelpers.js'; +import type { ViewState as ParentViewState } from './types.js'; +import { usePagination } from './usePagination.js'; +type Props = { + error: string | null; + setError: (error: string | null) => void; + result: string | null; + setResult: (result: string | null) => void; + setViewState: (state: ParentViewState) => void; + onInstallComplete?: () => void | Promise; + targetMarketplace?: string; + targetPlugin?: string; +}; +type ViewState = 'marketplace-list' | 'plugin-list' | 'plugin-details' | { + type: 'plugin-options'; + plugin: LoadedPlugin; + pluginId: string; +}; +type MarketplaceInfo = { + name: string; + totalPlugins: number; + installedCount: number; + source?: string; +}; +export function BrowseMarketplace({ + error, + setError, + result: _result, + setResult, + setViewState: setParentViewState, + onInstallComplete, + targetMarketplace, + targetPlugin +}: Props): React.ReactNode { + // View state + const [viewState, setViewState] = useState('marketplace-list'); + const [selectedMarketplace, setSelectedMarketplace] = useState(null); + const [selectedPlugin, setSelectedPlugin] = useState(null); + + // Data state + const [marketplaces, setMarketplaces] = useState([]); + const [availablePlugins, setAvailablePlugins] = useState([]); + const [loading, setLoading] = useState(true); + const [installCounts, setInstallCounts] = useState | null>(null); + + // Selection state + const [selectedIndex, setSelectedIndex] = useState(0); + const [selectedForInstall, setSelectedForInstall] = useState>(new Set()); + const [installingPlugins, setInstallingPlugins] = useState>(new Set()); + + // Pagination for plugin list (continuous scrolling) + const pagination = usePagination({ + totalItems: availablePlugins.length, + selectedIndex + }); + + // Details view state + const [detailsMenuIndex, setDetailsMenuIndex] = useState(0); + const [isInstalling, setIsInstalling] = useState(false); + const [installError, setInstallError] = useState(null); + + // Warning state for non-critical errors (e.g., some marketplaces failed to load) + const [warning, setWarning] = useState(null); + + // Handle escape to go back - viewState-dependent navigation + const handleBack = React.useCallback(() => { + if (viewState === 'plugin-list') { + // If navigated directly to a specific marketplace via targetMarketplace, + // go back to manage-marketplaces showing that marketplace's details + if (targetMarketplace) { + setParentViewState({ + type: 'manage-marketplaces', + targetMarketplace + }); + } else if (marketplaces.length === 1) { + // If there's only one marketplace, skip the marketplace-list view + // since we auto-navigated past it on load + setParentViewState({ + type: 'menu' + }); + } else { + setViewState('marketplace-list'); + setSelectedMarketplace(null); + setSelectedForInstall(new Set()); + } + } else if (viewState === 'plugin-details') { + setViewState('plugin-list'); + setSelectedPlugin(null); + } else { + // At root level (marketplace-list), exit the plugin menu + setParentViewState({ + type: 'menu' + }); + } + }, [viewState, targetMarketplace, setParentViewState, marketplaces.length]); + useKeybinding('confirm:no', handleBack, { + context: 'Confirmation' + }); + + // Load marketplaces and count installed plugins + useEffect(() => { + async function loadMarketplaceData() { + try { + const config = await loadKnownMarketplacesConfig(); + + // Load marketplaces with graceful degradation + const { + marketplaces: marketplaces_0, + failures + } = await loadMarketplacesWithGracefulDegradation(config); + const marketplaceInfos: MarketplaceInfo[] = []; + for (const { + name, + config: marketplaceConfig, + data: marketplace + } of marketplaces_0) { + if (marketplace) { + // Count how many plugins from this marketplace are installed + const installedFromThisMarketplace = count(marketplace.plugins, plugin => isPluginInstalled(createPluginId(plugin.name, name))); + marketplaceInfos.push({ + name, + totalPlugins: marketplace.plugins.length, + installedCount: installedFromThisMarketplace, + source: getMarketplaceSourceDisplay(marketplaceConfig.source) + }); + } + } + + // Sort so claude-plugin-directory is always first + marketplaceInfos.sort((a, b) => { + if (a.name === 'claude-plugin-directory') return -1; + if (b.name === 'claude-plugin-directory') return 1; + return 0; + }); + setMarketplaces(marketplaceInfos); + + // Handle marketplace loading errors/warnings + const successCount = count(marketplaces_0, m => m.data !== null); + const errorResult = formatMarketplaceLoadingErrors(failures, successCount); + if (errorResult) { + if (errorResult.type === 'warning') { + setWarning(errorResult.message + '. Showing available marketplaces.'); + } else { + throw new Error(errorResult.message); + } + } + + // Skip marketplace selection if there's only one marketplace + if (marketplaceInfos.length === 1 && !targetMarketplace && !targetPlugin) { + const singleMarketplace = marketplaceInfos[0]; + if (singleMarketplace) { + setSelectedMarketplace(singleMarketplace.name); + setViewState('plugin-list'); + } + } + + // Handle targetMarketplace and targetPlugin after marketplaces are loaded + if (targetPlugin) { + // Search for the plugin across all marketplaces + let foundPlugin: InstallablePlugin | null = null; + let foundMarketplace: string | null = null; + for (const [name_0] of Object.entries(config)) { + const marketplace_0 = await getMarketplace(name_0); + if (marketplace_0) { + const plugin_0 = marketplace_0.plugins.find(p => p.name === targetPlugin); + if (plugin_0) { + const pluginId = createPluginId(plugin_0.name, name_0); + foundPlugin = { + entry: plugin_0, + marketplaceName: name_0, + pluginId, + // isPluginGloballyInstalled: only block when user/managed scope + // exists (nothing to add). Project/local-scope installs don't + // block — user may want to promote to user scope (gh-29997). + isInstalled: isPluginGloballyInstalled(pluginId) + }; + foundMarketplace = name_0; + break; + } + } + } + if (foundPlugin && foundMarketplace) { + // Block only on global (user/managed) install — project/local scope + // means the user might still want to add a user-scope entry so the + // plugin is available in other projects (gh-29997, gh-29240, gh-29392). + // The plugin-details view offers all three scope options; the backend + // (installPluginOp → addInstalledPlugin) already supports multiple + // scope entries per plugin. + const pluginId_0 = foundPlugin.pluginId; + const globallyInstalled = isPluginGloballyInstalled(pluginId_0); + if (globallyInstalled) { + setError(`Plugin '${pluginId_0}' is already installed globally. Use '/plugin' to manage existing plugins.`); + } else { + // Navigate to the plugin details view + setSelectedMarketplace(foundMarketplace); + setSelectedPlugin(foundPlugin); + setViewState('plugin-details'); + } + } else { + setError(`Plugin "${targetPlugin}" not found in any marketplace`); + } + } else if (targetMarketplace) { + // Navigate directly to the specified marketplace + const marketplaceExists = marketplaceInfos.some(m_0 => m_0.name === targetMarketplace); + if (marketplaceExists) { + setSelectedMarketplace(targetMarketplace); + setViewState('plugin-list'); + } else { + setError(`Marketplace "${targetMarketplace}" not found`); + } + } + } catch (err) { + setError(err instanceof Error ? err.message : 'Failed to load marketplaces'); + } finally { + setLoading(false); + } + } + void loadMarketplaceData(); + }, [setError, targetMarketplace, targetPlugin]); + + // Load plugins when a marketplace is selected + useEffect(() => { + if (!selectedMarketplace) return; + let cancelled = false; + async function loadPluginsForMarketplace(marketplaceName: string) { + setLoading(true); + try { + const marketplace_1 = await getMarketplace(marketplaceName); + if (cancelled) return; + if (!marketplace_1) { + throw new Error(`Failed to load marketplace: ${marketplaceName}`); + } + + // Filter out already installed plugins + const installablePlugins: InstallablePlugin[] = []; + for (const entry of marketplace_1.plugins) { + const pluginId_1 = createPluginId(entry.name, marketplaceName); + if (isPluginBlockedByPolicy(pluginId_1)) continue; + installablePlugins.push({ + entry, + marketplaceName: marketplaceName, + pluginId: pluginId_1, + // Only mark as "installed" when globally scoped (user/managed). + // Project/local installs don't block — user can add user scope + // via the plugin-details view (gh-29997). + isInstalled: isPluginGloballyInstalled(pluginId_1) + }); + } + + // Fetch install counts and sort by popularity + try { + const counts = await getInstallCounts(); + if (cancelled) return; + setInstallCounts(counts); + if (counts) { + // Sort by install count (descending), then alphabetically + installablePlugins.sort((a_1, b_1) => { + const countA = counts.get(a_1.pluginId) ?? 0; + const countB = counts.get(b_1.pluginId) ?? 0; + if (countA !== countB) return countB - countA; + return a_1.entry.name.localeCompare(b_1.entry.name); + }); + } else { + // No counts available - sort alphabetically + installablePlugins.sort((a_2, b_2) => a_2.entry.name.localeCompare(b_2.entry.name)); + } + } catch (error_0) { + if (cancelled) return; + // Log the error, then gracefully degrade to alphabetical sort + logForDebugging(`Failed to fetch install counts: ${errorMessage(error_0)}`); + installablePlugins.sort((a_0, b_0) => a_0.entry.name.localeCompare(b_0.entry.name)); + } + setAvailablePlugins(installablePlugins); + setSelectedIndex(0); + setSelectedForInstall(new Set()); + } catch (err_0) { + if (cancelled) return; + setError(err_0 instanceof Error ? err_0.message : 'Failed to load plugins'); + } finally { + setLoading(false); + } + } + void loadPluginsForMarketplace(selectedMarketplace); + return () => { + cancelled = true; + }; + }, [selectedMarketplace, setError]); + + // Install selected plugins + const installSelectedPlugins = async () => { + if (selectedForInstall.size === 0) return; + const pluginsToInstall = availablePlugins.filter(p_0 => selectedForInstall.has(p_0.pluginId)); + setInstallingPlugins(new Set(pluginsToInstall.map(p_1 => p_1.pluginId))); + let successCount_0 = 0; + let failureCount = 0; + const newFailedPlugins: Array<{ + name: string; + reason: string; + }> = []; + for (const plugin_1 of pluginsToInstall) { + const result = await installPluginFromMarketplace({ + pluginId: plugin_1.pluginId, + entry: plugin_1.entry, + marketplaceName: plugin_1.marketplaceName, + scope: 'user' + }); + if (result.success) { + successCount_0++; + } else { + failureCount++; + newFailedPlugins.push({ + name: plugin_1.entry.name, + reason: result.error + }); + } + } + setInstallingPlugins(new Set()); + setSelectedForInstall(new Set()); + clearAllCaches(); + + // Handle installation results + if (failureCount === 0) { + // All succeeded + const message = `✓ Installed ${successCount_0} ${plural(successCount_0, 'plugin')}. ` + `Run /reload-plugins to activate.`; + setResult(message); + } else if (successCount_0 === 0) { + // All failed - show error with reasons + setError(`Failed to install: ${formatFailureDetails(newFailedPlugins, true)}`); + } else { + // Mixed results - show partial success + const message_0 = `✓ Installed ${successCount_0} of ${successCount_0 + failureCount} plugins. ` + `Failed: ${formatFailureDetails(newFailedPlugins, false)}. ` + `Run /reload-plugins to activate successfully installed plugins.`; + setResult(message_0); + } + + // Handle completion callback and navigation + if (successCount_0 > 0) { + if (onInstallComplete) { + await onInstallComplete(); + } + } + setParentViewState({ + type: 'menu' + }); + }; + + // Install single plugin from details view + const handleSinglePluginInstall = async (plugin_2: InstallablePlugin, scope: 'user' | 'project' | 'local' = 'user') => { + setIsInstalling(true); + setInstallError(null); + const result_0 = await installPluginFromMarketplace({ + pluginId: plugin_2.pluginId, + entry: plugin_2.entry, + marketplaceName: plugin_2.marketplaceName, + scope + }); + if (result_0.success) { + const loaded = await findPluginOptionsTarget(plugin_2.pluginId); + if (loaded) { + setIsInstalling(false); + setViewState({ + type: 'plugin-options', + plugin: loaded, + pluginId: plugin_2.pluginId + }); + return; + } + setResult(result_0.message); + if (onInstallComplete) { + await onInstallComplete(); + } + setParentViewState({ + type: 'menu' + }); + } else { + setIsInstalling(false); + setInstallError(result_0.error); + } + }; + + // Handle error state + useEffect(() => { + if (error) { + setResult(error); + } + }, [error, setResult]); + + // Marketplace-list navigation + useKeybindings({ + 'select:previous': () => { + if (selectedIndex > 0) { + setSelectedIndex(selectedIndex - 1); + } + }, + 'select:next': () => { + if (selectedIndex < marketplaces.length - 1) { + setSelectedIndex(selectedIndex + 1); + } + }, + 'select:accept': () => { + const marketplace_2 = marketplaces[selectedIndex]; + if (marketplace_2) { + setSelectedMarketplace(marketplace_2.name); + setViewState('plugin-list'); + } + } + }, { + context: 'Select', + isActive: viewState === 'marketplace-list' + }); + + // Plugin-list navigation + useKeybindings({ + 'select:previous': () => { + if (selectedIndex > 0) { + pagination.handleSelectionChange(selectedIndex - 1, setSelectedIndex); + } + }, + 'select:next': () => { + if (selectedIndex < availablePlugins.length - 1) { + pagination.handleSelectionChange(selectedIndex + 1, setSelectedIndex); + } + }, + 'select:accept': () => { + if (selectedIndex === availablePlugins.length && selectedForInstall.size > 0) { + void installSelectedPlugins(); + } else if (selectedIndex < availablePlugins.length) { + const plugin_3 = availablePlugins[selectedIndex]; + if (plugin_3) { + if (plugin_3.isInstalled) { + setParentViewState({ + type: 'manage-plugins', + targetPlugin: plugin_3.entry.name, + targetMarketplace: plugin_3.marketplaceName + }); + } else { + setSelectedPlugin(plugin_3); + setViewState('plugin-details'); + setDetailsMenuIndex(0); + setInstallError(null); + } + } + } + } + }, { + context: 'Select', + isActive: viewState === 'plugin-list' + }); + useKeybindings({ + 'plugin:toggle': () => { + if (selectedIndex < availablePlugins.length) { + const plugin_4 = availablePlugins[selectedIndex]; + if (plugin_4 && !plugin_4.isInstalled) { + const newSelection = new Set(selectedForInstall); + if (newSelection.has(plugin_4.pluginId)) { + newSelection.delete(plugin_4.pluginId); + } else { + newSelection.add(plugin_4.pluginId); + } + setSelectedForInstall(newSelection); + } + } + }, + 'plugin:install': () => { + if (selectedForInstall.size > 0) { + void installSelectedPlugins(); + } + } + }, { + context: 'Plugin', + isActive: viewState === 'plugin-list' + }); + + // Plugin-details navigation + const detailsMenuOptions = React.useMemo(() => { + if (!selectedPlugin) return []; + const hasHomepage = selectedPlugin.entry.homepage; + const githubRepo = extractGitHubRepo(selectedPlugin); + return buildPluginDetailsMenuOptions(hasHomepage, githubRepo); + }, [selectedPlugin]); + useKeybindings({ + 'select:previous': () => { + if (detailsMenuIndex > 0) { + setDetailsMenuIndex(detailsMenuIndex - 1); + } + }, + 'select:next': () => { + if (detailsMenuIndex < detailsMenuOptions.length - 1) { + setDetailsMenuIndex(detailsMenuIndex + 1); + } + }, + 'select:accept': () => { + if (!selectedPlugin) return; + const action = detailsMenuOptions[detailsMenuIndex]?.action; + const hasHomepage_0 = selectedPlugin.entry.homepage; + const githubRepo_0 = extractGitHubRepo(selectedPlugin); + if (action === 'install-user') { + void handleSinglePluginInstall(selectedPlugin, 'user'); + } else if (action === 'install-project') { + void handleSinglePluginInstall(selectedPlugin, 'project'); + } else if (action === 'install-local') { + void handleSinglePluginInstall(selectedPlugin, 'local'); + } else if (action === 'homepage' && hasHomepage_0) { + void openBrowser(hasHomepage_0); + } else if (action === 'github' && githubRepo_0) { + void openBrowser(`https://github.com/${githubRepo_0}`); + } else if (action === 'back') { + setViewState('plugin-list'); + setSelectedPlugin(null); + } + } + }, { + context: 'Select', + isActive: viewState === 'plugin-details' && !!selectedPlugin + }); + if (typeof viewState === 'object' && viewState.type === 'plugin-options') { + const { + plugin: plugin_5, + pluginId: pluginId_2 + } = viewState; + function finish(msg: string): void { + setResult(msg); + if (onInstallComplete) { + void onInstallComplete(); + } + setParentViewState({ + type: 'menu' + }); + } + return { + switch (outcome) { + case 'configured': + finish(`✓ Installed and configured ${plugin_5.name}. Run /reload-plugins to apply.`); + break; + case 'skipped': + finish(`✓ Installed ${plugin_5.name}. Run /reload-plugins to apply.`); + break; + case 'error': + finish(`Installed but failed to save config: ${detail}`); + break; + } + }} />; + } + + // Loading state + if (loading) { + return Loading…; + } + + // Error state + if (error) { + return {error}; + } + + // Marketplace selection view + if (viewState === 'marketplace-list') { + if (marketplaces.length === 0) { + return + + Select marketplace + + No marketplaces configured. + + Add a marketplace first using {"'Add marketplace'"}. + + + + + + + ; + } + return + + Select marketplace + + + {/* Warning banner for marketplace load failures */} + {warning && + + {figures.warning} {warning} + + } + {marketplaces.map((marketplace_3, index) => + + + {selectedIndex === index ? figures.pointer : ' '}{' '} + {marketplace_3.name} + + + + + {marketplace_3.totalPlugins}{' '} + {plural(marketplace_3.totalPlugins, 'plugin')} available + {marketplace_3.installedCount > 0 && ` · ${marketplace_3.installedCount} already installed`} + {marketplace_3.source && ` · ${marketplace_3.source}`} + + + )} + + + + + + + + + + ; + } + + // Plugin details view + if (viewState === 'plugin-details' && selectedPlugin) { + const hasHomepage_1 = selectedPlugin.entry.homepage; + const githubRepo_1 = extractGitHubRepo(selectedPlugin); + const menuOptions = buildPluginDetailsMenuOptions(hasHomepage_1, githubRepo_1); + return + + Plugin Details + + + {/* Plugin metadata */} + + {selectedPlugin.entry.name} + {selectedPlugin.entry.version && Version: {selectedPlugin.entry.version}} + {selectedPlugin.entry.description && + {selectedPlugin.entry.description} + } + {selectedPlugin.entry.author && + + By:{' '} + {typeof selectedPlugin.entry.author === 'string' ? selectedPlugin.entry.author : selectedPlugin.entry.author.name} + + } + + + {/* What will be installed */} + + Will install: + {selectedPlugin.entry.commands && + · Commands:{' '} + {Array.isArray(selectedPlugin.entry.commands) ? selectedPlugin.entry.commands.join(', ') : Object.keys(selectedPlugin.entry.commands).join(', ')} + } + {selectedPlugin.entry.agents && + · Agents:{' '} + {Array.isArray(selectedPlugin.entry.agents) ? selectedPlugin.entry.agents.join(', ') : Object.keys(selectedPlugin.entry.agents).join(', ')} + } + {selectedPlugin.entry.hooks && + · Hooks: {Object.keys(selectedPlugin.entry.hooks).join(', ')} + } + {selectedPlugin.entry.mcpServers && + · MCP Servers:{' '} + {Array.isArray(selectedPlugin.entry.mcpServers) ? selectedPlugin.entry.mcpServers.join(', ') : typeof selectedPlugin.entry.mcpServers === 'object' ? Object.keys(selectedPlugin.entry.mcpServers).join(', ') : 'configured'} + } + {!selectedPlugin.entry.commands && !selectedPlugin.entry.agents && !selectedPlugin.entry.hooks && !selectedPlugin.entry.mcpServers && <> + {typeof selectedPlugin.entry.source === 'object' && 'source' in selectedPlugin.entry.source && (selectedPlugin.entry.source.source === 'github' || selectedPlugin.entry.source.source === 'url' || selectedPlugin.entry.source.source === 'npm' || selectedPlugin.entry.source.source === 'pip') ? + · Component summary not available for remote plugin + : + // TODO: Actually scan local plugin directories to show real components + // This would require accessing the filesystem to check for: + // - commands/ directory and list files + // - agents/ directory and list files + // - hooks/ directory and list files + // - .mcp.json or mcp-servers.json files + + · Components will be discovered at installation + } + } + + + + + {/* Error message */} + {installError && + Error: {installError} + } + + {/* Menu options */} + + {menuOptions.map((option, index_0) => + {detailsMenuIndex === index_0 && {'> '}} + {detailsMenuIndex !== index_0 && {' '}} + + {isInstalling && option.action === 'install' ? 'Installing…' : option.label} + + )} + + + + + + + + + + + ; + } + + // Plugin installation view + if (availablePlugins.length === 0) { + return + + Install plugins + + No new plugins available to install. + + All plugins from this marketplace are already installed. + + + + + + + ; + } + + // Get visible plugins from pagination + const visiblePlugins = pagination.getVisibleItems(availablePlugins); + return + + Install Plugins + + + {/* Scroll up indicator */} + {pagination.scrollPosition.canScrollUp && + {figures.arrowUp} more above + } + + {/* Plugin list */} + {visiblePlugins.map((plugin_6, visibleIndex) => { + const actualIndex = pagination.toActualIndex(visibleIndex); + const isSelected = selectedIndex === actualIndex; + const isSelectedForInstall = selectedForInstall.has(plugin_6.pluginId); + const isInstalling_0 = installingPlugins.has(plugin_6.pluginId); + const isLast = visibleIndex === visiblePlugins.length - 1; + return + + + {isSelected ? figures.pointer : ' '}{' '} + + + {plugin_6.isInstalled ? figures.tick : isInstalling_0 ? figures.ellipsis : isSelectedForInstall ? figures.radioOn : figures.radioOff}{' '} + {plugin_6.entry.name} + {plugin_6.entry.category && [{plugin_6.entry.category}]} + {plugin_6.entry.tags?.includes('community-managed') && [Community Managed]} + {plugin_6.isInstalled && (installed)} + {installCounts && selectedMarketplace === OFFICIAL_MARKETPLACE_NAME && + {' · '} + {formatInstallCount(installCounts.get(plugin_6.pluginId) ?? 0)}{' '} + installs + } + + + {plugin_6.entry.description && + + {truncateToWidth(plugin_6.entry.description, 60)} + + {plugin_6.entry.version && · v{plugin_6.entry.version}} + } + ; + })} + + {/* Scroll down indicator */} + {pagination.scrollPosition.canScrollDown && + {figures.arrowDown} more below + } + + {/* Error messages shown in the UI */} + {error && + + {figures.cross} {error} + + } + + 0} /> + ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useEffect","useState","ConfigurableShortcutHint","Byline","Box","Text","useKeybinding","useKeybindings","LoadedPlugin","count","openBrowser","logForDebugging","errorMessage","clearAllCaches","formatInstallCount","getInstallCounts","isPluginGloballyInstalled","isPluginInstalled","createPluginId","formatFailureDetails","formatMarketplaceLoadingErrors","getMarketplaceSourceDisplay","loadMarketplacesWithGracefulDegradation","getMarketplace","loadKnownMarketplacesConfig","OFFICIAL_MARKETPLACE_NAME","installPluginFromMarketplace","isPluginBlockedByPolicy","plural","truncateToWidth","findPluginOptionsTarget","PluginOptionsFlow","PluginTrustWarning","buildPluginDetailsMenuOptions","extractGitHubRepo","InstallablePlugin","PluginSelectionKeyHint","ViewState","ParentViewState","usePagination","Props","error","setError","result","setResult","setViewState","state","onInstallComplete","Promise","targetMarketplace","targetPlugin","type","plugin","pluginId","MarketplaceInfo","name","totalPlugins","installedCount","source","BrowseMarketplace","_result","setParentViewState","ReactNode","viewState","selectedMarketplace","setSelectedMarketplace","selectedPlugin","setSelectedPlugin","marketplaces","setMarketplaces","availablePlugins","setAvailablePlugins","loading","setLoading","installCounts","setInstallCounts","Map","selectedIndex","setSelectedIndex","selectedForInstall","setSelectedForInstall","Set","installingPlugins","setInstallingPlugins","pagination","totalItems","length","detailsMenuIndex","setDetailsMenuIndex","isInstalling","setIsInstalling","installError","setInstallError","warning","setWarning","handleBack","useCallback","context","loadMarketplaceData","config","failures","marketplaceInfos","marketplaceConfig","data","marketplace","installedFromThisMarketplace","plugins","push","sort","a","b","successCount","m","errorResult","message","Error","singleMarketplace","foundPlugin","foundMarketplace","Object","entries","find","p","entry","marketplaceName","isInstalled","globallyInstalled","marketplaceExists","some","err","cancelled","loadPluginsForMarketplace","installablePlugins","counts","countA","get","countB","localeCompare","installSelectedPlugins","size","pluginsToInstall","filter","has","map","failureCount","newFailedPlugins","Array","reason","scope","success","handleSinglePluginInstall","loaded","select:previous","select:next","select:accept","isActive","handleSelectionChange","plugin:toggle","newSelection","delete","add","plugin:install","detailsMenuOptions","useMemo","hasHomepage","homepage","githubRepo","action","finish","msg","outcome","detail","index","undefined","pointer","menuOptions","version","description","author","commands","isArray","join","keys","agents","hooks","mcpServers","option","label","visiblePlugins","getVisibleItems","scrollPosition","canScrollUp","arrowUp","visibleIndex","actualIndex","toActualIndex","isSelected","isSelectedForInstall","isLast","tick","ellipsis","radioOn","radioOff","category","tags","includes","canScrollDown","arrowDown","cross"],"sources":["BrowseMarketplace.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { Box, Text } from '../../ink.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport type { LoadedPlugin } from '../../types/plugin.js'\nimport { count } from '../../utils/array.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport {\n  formatInstallCount,\n  getInstallCounts,\n} from '../../utils/plugins/installCounts.js'\nimport {\n  isPluginGloballyInstalled,\n  isPluginInstalled,\n} from '../../utils/plugins/installedPluginsManager.js'\nimport {\n  createPluginId,\n  formatFailureDetails,\n  formatMarketplaceLoadingErrors,\n  getMarketplaceSourceDisplay,\n  loadMarketplacesWithGracefulDegradation,\n} from '../../utils/plugins/marketplaceHelpers.js'\nimport {\n  getMarketplace,\n  loadKnownMarketplacesConfig,\n} from '../../utils/plugins/marketplaceManager.js'\nimport { OFFICIAL_MARKETPLACE_NAME } from '../../utils/plugins/officialMarketplace.js'\nimport { installPluginFromMarketplace } from '../../utils/plugins/pluginInstallationHelpers.js'\nimport { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport { truncateToWidth } from '../../utils/truncate.js'\nimport {\n  findPluginOptionsTarget,\n  PluginOptionsFlow,\n} from './PluginOptionsFlow.js'\nimport { PluginTrustWarning } from './PluginTrustWarning.js'\nimport {\n  buildPluginDetailsMenuOptions,\n  extractGitHubRepo,\n  type InstallablePlugin,\n  PluginSelectionKeyHint,\n} from './pluginDetailsHelpers.js'\nimport type { ViewState as ParentViewState } from './types.js'\nimport { usePagination } from './usePagination.js'\n\ntype Props = {\n  error: string | null\n  setError: (error: string | null) => void\n  result: string | null\n  setResult: (result: string | null) => void\n  setViewState: (state: ParentViewState) => void\n  onInstallComplete?: () => void | Promise<void>\n  targetMarketplace?: string\n  targetPlugin?: string\n}\n\ntype ViewState =\n  | 'marketplace-list'\n  | 'plugin-list'\n  | 'plugin-details'\n  | { type: 'plugin-options'; plugin: LoadedPlugin; pluginId: string }\n\ntype MarketplaceInfo = {\n  name: string\n  totalPlugins: number\n  installedCount: number\n  source?: string\n}\n\nexport function BrowseMarketplace({\n  error,\n  setError,\n  result: _result,\n  setResult,\n  setViewState: setParentViewState,\n  onInstallComplete,\n  targetMarketplace,\n  targetPlugin,\n}: Props): React.ReactNode {\n  // View state\n  const [viewState, setViewState] = useState<ViewState>('marketplace-list')\n  const [selectedMarketplace, setSelectedMarketplace] = useState<string | null>(\n    null,\n  )\n  const [selectedPlugin, setSelectedPlugin] =\n    useState<InstallablePlugin | null>(null)\n\n  // Data state\n  const [marketplaces, setMarketplaces] = useState<MarketplaceInfo[]>([])\n  const [availablePlugins, setAvailablePlugins] = useState<InstallablePlugin[]>(\n    [],\n  )\n  const [loading, setLoading] = useState(true)\n  const [installCounts, setInstallCounts] = useState<Map<\n    string,\n    number\n  > | null>(null)\n\n  // Selection state\n  const [selectedIndex, setSelectedIndex] = useState(0)\n  const [selectedForInstall, setSelectedForInstall] = useState<Set<string>>(\n    new Set(),\n  )\n  const [installingPlugins, setInstallingPlugins] = useState<Set<string>>(\n    new Set(),\n  )\n\n  // Pagination for plugin list (continuous scrolling)\n  const pagination = usePagination<InstallablePlugin>({\n    totalItems: availablePlugins.length,\n    selectedIndex,\n  })\n\n  // Details view state\n  const [detailsMenuIndex, setDetailsMenuIndex] = useState(0)\n  const [isInstalling, setIsInstalling] = useState(false)\n  const [installError, setInstallError] = useState<string | null>(null)\n\n  // Warning state for non-critical errors (e.g., some marketplaces failed to load)\n  const [warning, setWarning] = useState<string | null>(null)\n\n  // Handle escape to go back - viewState-dependent navigation\n  const handleBack = React.useCallback(() => {\n    if (viewState === 'plugin-list') {\n      // If navigated directly to a specific marketplace via targetMarketplace,\n      // go back to manage-marketplaces showing that marketplace's details\n      if (targetMarketplace) {\n        setParentViewState({\n          type: 'manage-marketplaces',\n          targetMarketplace,\n        })\n      } else if (marketplaces.length === 1) {\n        // If there's only one marketplace, skip the marketplace-list view\n        // since we auto-navigated past it on load\n        setParentViewState({ type: 'menu' })\n      } else {\n        setViewState('marketplace-list')\n        setSelectedMarketplace(null)\n        setSelectedForInstall(new Set())\n      }\n    } else if (viewState === 'plugin-details') {\n      setViewState('plugin-list')\n      setSelectedPlugin(null)\n    } else {\n      // At root level (marketplace-list), exit the plugin menu\n      setParentViewState({ type: 'menu' })\n    }\n  }, [viewState, targetMarketplace, setParentViewState, marketplaces.length])\n\n  useKeybinding('confirm:no', handleBack, { context: 'Confirmation' })\n\n  // Load marketplaces and count installed plugins\n  useEffect(() => {\n    async function loadMarketplaceData() {\n      try {\n        const config = await loadKnownMarketplacesConfig()\n\n        // Load marketplaces with graceful degradation\n        const { marketplaces, failures } =\n          await loadMarketplacesWithGracefulDegradation(config)\n\n        const marketplaceInfos: MarketplaceInfo[] = []\n        for (const {\n          name,\n          config: marketplaceConfig,\n          data: marketplace,\n        } of marketplaces) {\n          if (marketplace) {\n            // Count how many plugins from this marketplace are installed\n            const installedFromThisMarketplace = count(\n              marketplace.plugins,\n              plugin => isPluginInstalled(createPluginId(plugin.name, name)),\n            )\n\n            marketplaceInfos.push({\n              name,\n              totalPlugins: marketplace.plugins.length,\n              installedCount: installedFromThisMarketplace,\n              source: getMarketplaceSourceDisplay(marketplaceConfig.source),\n            })\n          }\n        }\n\n        // Sort so claude-plugin-directory is always first\n        marketplaceInfos.sort((a, b) => {\n          if (a.name === 'claude-plugin-directory') return -1\n          if (b.name === 'claude-plugin-directory') return 1\n          return 0\n        })\n\n        setMarketplaces(marketplaceInfos)\n\n        // Handle marketplace loading errors/warnings\n        const successCount = count(marketplaces, m => m.data !== null)\n        const errorResult = formatMarketplaceLoadingErrors(\n          failures,\n          successCount,\n        )\n        if (errorResult) {\n          if (errorResult.type === 'warning') {\n            setWarning(\n              errorResult.message + '. Showing available marketplaces.',\n            )\n          } else {\n            throw new Error(errorResult.message)\n          }\n        }\n\n        // Skip marketplace selection if there's only one marketplace\n        if (\n          marketplaceInfos.length === 1 &&\n          !targetMarketplace &&\n          !targetPlugin\n        ) {\n          const singleMarketplace = marketplaceInfos[0]\n          if (singleMarketplace) {\n            setSelectedMarketplace(singleMarketplace.name)\n            setViewState('plugin-list')\n          }\n        }\n\n        // Handle targetMarketplace and targetPlugin after marketplaces are loaded\n        if (targetPlugin) {\n          // Search for the plugin across all marketplaces\n          let foundPlugin: InstallablePlugin | null = null\n          let foundMarketplace: string | null = null\n\n          for (const [name] of Object.entries(config)) {\n            const marketplace = await getMarketplace(name)\n            if (marketplace) {\n              const plugin = marketplace.plugins.find(\n                p => p.name === targetPlugin,\n              )\n              if (plugin) {\n                const pluginId = createPluginId(plugin.name, name)\n                foundPlugin = {\n                  entry: plugin,\n                  marketplaceName: name,\n                  pluginId,\n                  // isPluginGloballyInstalled: only block when user/managed scope\n                  // exists (nothing to add). Project/local-scope installs don't\n                  // block — user may want to promote to user scope (gh-29997).\n                  isInstalled: isPluginGloballyInstalled(pluginId),\n                }\n                foundMarketplace = name\n                break\n              }\n            }\n          }\n\n          if (foundPlugin && foundMarketplace) {\n            // Block only on global (user/managed) install — project/local scope\n            // means the user might still want to add a user-scope entry so the\n            // plugin is available in other projects (gh-29997, gh-29240, gh-29392).\n            // The plugin-details view offers all three scope options; the backend\n            // (installPluginOp → addInstalledPlugin) already supports multiple\n            // scope entries per plugin.\n            const pluginId = foundPlugin.pluginId\n            const globallyInstalled = isPluginGloballyInstalled(pluginId)\n\n            if (globallyInstalled) {\n              setError(\n                `Plugin '${pluginId}' is already installed globally. Use '/plugin' to manage existing plugins.`,\n              )\n            } else {\n              // Navigate to the plugin details view\n              setSelectedMarketplace(foundMarketplace)\n              setSelectedPlugin(foundPlugin)\n              setViewState('plugin-details')\n            }\n          } else {\n            setError(`Plugin \"${targetPlugin}\" not found in any marketplace`)\n          }\n        } else if (targetMarketplace) {\n          // Navigate directly to the specified marketplace\n          const marketplaceExists = marketplaceInfos.some(\n            m => m.name === targetMarketplace,\n          )\n          if (marketplaceExists) {\n            setSelectedMarketplace(targetMarketplace)\n            setViewState('plugin-list')\n          } else {\n            setError(`Marketplace \"${targetMarketplace}\" not found`)\n          }\n        }\n      } catch (err) {\n        setError(\n          err instanceof Error ? err.message : 'Failed to load marketplaces',\n        )\n      } finally {\n        setLoading(false)\n      }\n    }\n    void loadMarketplaceData()\n  }, [setError, targetMarketplace, targetPlugin])\n\n  // Load plugins when a marketplace is selected\n  useEffect(() => {\n    if (!selectedMarketplace) return\n\n    let cancelled = false\n\n    async function loadPluginsForMarketplace(marketplaceName: string) {\n      setLoading(true)\n      try {\n        const marketplace = await getMarketplace(marketplaceName)\n        if (cancelled) return\n        if (!marketplace) {\n          throw new Error(`Failed to load marketplace: ${marketplaceName}`)\n        }\n\n        // Filter out already installed plugins\n        const installablePlugins: InstallablePlugin[] = []\n        for (const entry of marketplace.plugins) {\n          const pluginId = createPluginId(entry.name, marketplaceName)\n          if (isPluginBlockedByPolicy(pluginId)) continue\n          installablePlugins.push({\n            entry,\n            marketplaceName: marketplaceName,\n            pluginId,\n            // Only mark as \"installed\" when globally scoped (user/managed).\n            // Project/local installs don't block — user can add user scope\n            // via the plugin-details view (gh-29997).\n            isInstalled: isPluginGloballyInstalled(pluginId),\n          })\n        }\n\n        // Fetch install counts and sort by popularity\n        try {\n          const counts = await getInstallCounts()\n          if (cancelled) return\n          setInstallCounts(counts)\n\n          if (counts) {\n            // Sort by install count (descending), then alphabetically\n            installablePlugins.sort((a, b) => {\n              const countA = counts.get(a.pluginId) ?? 0\n              const countB = counts.get(b.pluginId) ?? 0\n              if (countA !== countB) return countB - countA\n              return a.entry.name.localeCompare(b.entry.name)\n            })\n          } else {\n            // No counts available - sort alphabetically\n            installablePlugins.sort((a, b) =>\n              a.entry.name.localeCompare(b.entry.name),\n            )\n          }\n        } catch (error) {\n          if (cancelled) return\n          // Log the error, then gracefully degrade to alphabetical sort\n          logForDebugging(\n            `Failed to fetch install counts: ${errorMessage(error)}`,\n          )\n          installablePlugins.sort((a, b) =>\n            a.entry.name.localeCompare(b.entry.name),\n          )\n        }\n\n        setAvailablePlugins(installablePlugins)\n        setSelectedIndex(0)\n        setSelectedForInstall(new Set())\n      } catch (err) {\n        if (cancelled) return\n        setError(err instanceof Error ? err.message : 'Failed to load plugins')\n      } finally {\n        setLoading(false)\n      }\n    }\n\n    void loadPluginsForMarketplace(selectedMarketplace)\n    return () => {\n      cancelled = true\n    }\n  }, [selectedMarketplace, setError])\n\n  // Install selected plugins\n  const installSelectedPlugins = async () => {\n    if (selectedForInstall.size === 0) return\n\n    const pluginsToInstall = availablePlugins.filter(p =>\n      selectedForInstall.has(p.pluginId),\n    )\n\n    setInstallingPlugins(new Set(pluginsToInstall.map(p => p.pluginId)))\n\n    let successCount = 0\n    let failureCount = 0\n    const newFailedPlugins: Array<{ name: string; reason: string }> = []\n\n    for (const plugin of pluginsToInstall) {\n      const result = await installPluginFromMarketplace({\n        pluginId: plugin.pluginId,\n        entry: plugin.entry,\n        marketplaceName: plugin.marketplaceName,\n        scope: 'user',\n      })\n\n      if (result.success) {\n        successCount++\n      } else {\n        failureCount++\n        newFailedPlugins.push({\n          name: plugin.entry.name,\n          reason: result.error,\n        })\n      }\n    }\n\n    setInstallingPlugins(new Set())\n    setSelectedForInstall(new Set())\n    clearAllCaches()\n\n    // Handle installation results\n    if (failureCount === 0) {\n      // All succeeded\n      const message =\n        `✓ Installed ${successCount} ${plural(successCount, 'plugin')}. ` +\n        `Run /reload-plugins to activate.`\n\n      setResult(message)\n    } else if (successCount === 0) {\n      // All failed - show error with reasons\n      setError(\n        `Failed to install: ${formatFailureDetails(newFailedPlugins, true)}`,\n      )\n    } else {\n      // Mixed results - show partial success\n      const message =\n        `✓ Installed ${successCount} of ${successCount + failureCount} plugins. ` +\n        `Failed: ${formatFailureDetails(newFailedPlugins, false)}. ` +\n        `Run /reload-plugins to activate successfully installed plugins.`\n\n      setResult(message)\n    }\n\n    // Handle completion callback and navigation\n    if (successCount > 0) {\n      if (onInstallComplete) {\n        await onInstallComplete()\n      }\n    }\n\n    setParentViewState({ type: 'menu' })\n  }\n\n  // Install single plugin from details view\n  const handleSinglePluginInstall = async (\n    plugin: InstallablePlugin,\n    scope: 'user' | 'project' | 'local' = 'user',\n  ) => {\n    setIsInstalling(true)\n    setInstallError(null)\n\n    const result = await installPluginFromMarketplace({\n      pluginId: plugin.pluginId,\n      entry: plugin.entry,\n      marketplaceName: plugin.marketplaceName,\n      scope,\n    })\n\n    if (result.success) {\n      const loaded = await findPluginOptionsTarget(plugin.pluginId)\n      if (loaded) {\n        setIsInstalling(false)\n        setViewState({\n          type: 'plugin-options',\n          plugin: loaded,\n          pluginId: plugin.pluginId,\n        })\n        return\n      }\n      setResult(result.message)\n      if (onInstallComplete) {\n        await onInstallComplete()\n      }\n      setParentViewState({ type: 'menu' })\n    } else {\n      setIsInstalling(false)\n      setInstallError(result.error)\n    }\n  }\n\n  // Handle error state\n  useEffect(() => {\n    if (error) {\n      setResult(error)\n    }\n  }, [error, setResult])\n\n  // Marketplace-list navigation\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (selectedIndex > 0) {\n          setSelectedIndex(selectedIndex - 1)\n        }\n      },\n      'select:next': () => {\n        if (selectedIndex < marketplaces.length - 1) {\n          setSelectedIndex(selectedIndex + 1)\n        }\n      },\n      'select:accept': () => {\n        const marketplace = marketplaces[selectedIndex]\n        if (marketplace) {\n          setSelectedMarketplace(marketplace.name)\n          setViewState('plugin-list')\n        }\n      },\n    },\n    { context: 'Select', isActive: viewState === 'marketplace-list' },\n  )\n\n  // Plugin-list navigation\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (selectedIndex > 0) {\n          pagination.handleSelectionChange(selectedIndex - 1, setSelectedIndex)\n        }\n      },\n      'select:next': () => {\n        if (selectedIndex < availablePlugins.length - 1) {\n          pagination.handleSelectionChange(selectedIndex + 1, setSelectedIndex)\n        }\n      },\n      'select:accept': () => {\n        if (\n          selectedIndex === availablePlugins.length &&\n          selectedForInstall.size > 0\n        ) {\n          void installSelectedPlugins()\n        } else if (selectedIndex < availablePlugins.length) {\n          const plugin = availablePlugins[selectedIndex]\n          if (plugin) {\n            if (plugin.isInstalled) {\n              setParentViewState({\n                type: 'manage-plugins',\n                targetPlugin: plugin.entry.name,\n                targetMarketplace: plugin.marketplaceName,\n              })\n            } else {\n              setSelectedPlugin(plugin)\n              setViewState('plugin-details')\n              setDetailsMenuIndex(0)\n              setInstallError(null)\n            }\n          }\n        }\n      },\n    },\n    { context: 'Select', isActive: viewState === 'plugin-list' },\n  )\n\n  useKeybindings(\n    {\n      'plugin:toggle': () => {\n        if (selectedIndex < availablePlugins.length) {\n          const plugin = availablePlugins[selectedIndex]\n          if (plugin && !plugin.isInstalled) {\n            const newSelection = new Set(selectedForInstall)\n            if (newSelection.has(plugin.pluginId)) {\n              newSelection.delete(plugin.pluginId)\n            } else {\n              newSelection.add(plugin.pluginId)\n            }\n            setSelectedForInstall(newSelection)\n          }\n        }\n      },\n      'plugin:install': () => {\n        if (selectedForInstall.size > 0) {\n          void installSelectedPlugins()\n        }\n      },\n    },\n    { context: 'Plugin', isActive: viewState === 'plugin-list' },\n  )\n\n  // Plugin-details navigation\n  const detailsMenuOptions = React.useMemo(() => {\n    if (!selectedPlugin) return []\n    const hasHomepage = selectedPlugin.entry.homepage\n    const githubRepo = extractGitHubRepo(selectedPlugin)\n    return buildPluginDetailsMenuOptions(hasHomepage, githubRepo)\n  }, [selectedPlugin])\n\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (detailsMenuIndex > 0) {\n          setDetailsMenuIndex(detailsMenuIndex - 1)\n        }\n      },\n      'select:next': () => {\n        if (detailsMenuIndex < detailsMenuOptions.length - 1) {\n          setDetailsMenuIndex(detailsMenuIndex + 1)\n        }\n      },\n      'select:accept': () => {\n        if (!selectedPlugin) return\n        const action = detailsMenuOptions[detailsMenuIndex]?.action\n        const hasHomepage = selectedPlugin.entry.homepage\n        const githubRepo = extractGitHubRepo(selectedPlugin)\n        if (action === 'install-user') {\n          void handleSinglePluginInstall(selectedPlugin, 'user')\n        } else if (action === 'install-project') {\n          void handleSinglePluginInstall(selectedPlugin, 'project')\n        } else if (action === 'install-local') {\n          void handleSinglePluginInstall(selectedPlugin, 'local')\n        } else if (action === 'homepage' && hasHomepage) {\n          void openBrowser(hasHomepage)\n        } else if (action === 'github' && githubRepo) {\n          void openBrowser(`https://github.com/${githubRepo}`)\n        } else if (action === 'back') {\n          setViewState('plugin-list')\n          setSelectedPlugin(null)\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive: viewState === 'plugin-details' && !!selectedPlugin,\n    },\n  )\n\n  if (typeof viewState === 'object' && viewState.type === 'plugin-options') {\n    const { plugin, pluginId } = viewState\n    function finish(msg: string): void {\n      setResult(msg)\n      if (onInstallComplete) {\n        void onInstallComplete()\n      }\n      setParentViewState({ type: 'menu' })\n    }\n    return (\n      <PluginOptionsFlow\n        plugin={plugin}\n        pluginId={pluginId}\n        onDone={(outcome, detail) => {\n          switch (outcome) {\n            case 'configured':\n              finish(\n                `✓ Installed and configured ${plugin.name}. Run /reload-plugins to apply.`,\n              )\n              break\n            case 'skipped':\n              finish(\n                `✓ Installed ${plugin.name}. Run /reload-plugins to apply.`,\n              )\n              break\n            case 'error':\n              finish(`Installed but failed to save config: ${detail}`)\n              break\n          }\n        }}\n      />\n    )\n  }\n\n  // Loading state\n  if (loading) {\n    return <Text>Loading…</Text>\n  }\n\n  // Error state\n  if (error) {\n    return <Text color=\"error\">{error}</Text>\n  }\n\n  // Marketplace selection view\n  if (viewState === 'marketplace-list') {\n    if (marketplaces.length === 0) {\n      return (\n        <Box flexDirection=\"column\">\n          <Box marginBottom={1}>\n            <Text bold>Select marketplace</Text>\n          </Box>\n          <Text>No marketplaces configured.</Text>\n          <Text dimColor>\n            Add a marketplace first using {\"'Add marketplace'\"}.\n          </Text>\n          <Box marginTop={1} paddingLeft={1}>\n            <Text dimColor>\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"go back\"\n              />\n            </Text>\n          </Box>\n        </Box>\n      )\n    }\n\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Select marketplace</Text>\n        </Box>\n\n        {/* Warning banner for marketplace load failures */}\n        {warning && (\n          <Box marginBottom={1} flexDirection=\"column\">\n            <Text color=\"warning\">\n              {figures.warning} {warning}\n            </Text>\n          </Box>\n        )}\n        {marketplaces.map((marketplace, index) => (\n          <Box\n            key={marketplace.name}\n            flexDirection=\"column\"\n            marginBottom={index < marketplaces.length - 1 ? 1 : 0}\n          >\n            <Box>\n              <Text color={selectedIndex === index ? 'suggestion' : undefined}>\n                {selectedIndex === index ? figures.pointer : ' '}{' '}\n                {marketplace.name}\n              </Text>\n            </Box>\n            <Box marginLeft={2}>\n              <Text dimColor>\n                {marketplace.totalPlugins}{' '}\n                {plural(marketplace.totalPlugins, 'plugin')} available\n                {marketplace.installedCount > 0 &&\n                  ` · ${marketplace.installedCount} already installed`}\n                {marketplace.source && ` · ${marketplace.source}`}\n              </Text>\n            </Box>\n          </Box>\n        ))}\n\n        <Box marginTop={1}>\n          <Text dimColor italic>\n            <Byline>\n              <ConfigurableShortcutHint\n                action=\"select:accept\"\n                context=\"Select\"\n                fallback=\"Enter\"\n                description=\"select\"\n              />\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"go back\"\n              />\n            </Byline>\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Plugin details view\n  if (viewState === 'plugin-details' && selectedPlugin) {\n    const hasHomepage = selectedPlugin.entry.homepage\n    const githubRepo = extractGitHubRepo(selectedPlugin)\n\n    const menuOptions = buildPluginDetailsMenuOptions(hasHomepage, githubRepo)\n\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Plugin Details</Text>\n        </Box>\n\n        {/* Plugin metadata */}\n        <Box flexDirection=\"column\" marginBottom={1}>\n          <Text bold>{selectedPlugin.entry.name}</Text>\n          {selectedPlugin.entry.version && (\n            <Text dimColor>Version: {selectedPlugin.entry.version}</Text>\n          )}\n          {selectedPlugin.entry.description && (\n            <Box marginTop={1}>\n              <Text>{selectedPlugin.entry.description}</Text>\n            </Box>\n          )}\n          {selectedPlugin.entry.author && (\n            <Box marginTop={1}>\n              <Text dimColor>\n                By:{' '}\n                {typeof selectedPlugin.entry.author === 'string'\n                  ? selectedPlugin.entry.author\n                  : selectedPlugin.entry.author.name}\n              </Text>\n            </Box>\n          )}\n        </Box>\n\n        {/* What will be installed */}\n        <Box flexDirection=\"column\" marginBottom={1}>\n          <Text bold>Will install:</Text>\n          {selectedPlugin.entry.commands && (\n            <Text dimColor>\n              · Commands:{' '}\n              {Array.isArray(selectedPlugin.entry.commands)\n                ? selectedPlugin.entry.commands.join(', ')\n                : Object.keys(selectedPlugin.entry.commands).join(', ')}\n            </Text>\n          )}\n          {selectedPlugin.entry.agents && (\n            <Text dimColor>\n              · Agents:{' '}\n              {Array.isArray(selectedPlugin.entry.agents)\n                ? selectedPlugin.entry.agents.join(', ')\n                : Object.keys(selectedPlugin.entry.agents).join(', ')}\n            </Text>\n          )}\n          {selectedPlugin.entry.hooks && (\n            <Text dimColor>\n              · Hooks: {Object.keys(selectedPlugin.entry.hooks).join(', ')}\n            </Text>\n          )}\n          {selectedPlugin.entry.mcpServers && (\n            <Text dimColor>\n              · MCP Servers:{' '}\n              {Array.isArray(selectedPlugin.entry.mcpServers)\n                ? selectedPlugin.entry.mcpServers.join(', ')\n                : typeof selectedPlugin.entry.mcpServers === 'object'\n                  ? Object.keys(selectedPlugin.entry.mcpServers).join(', ')\n                  : 'configured'}\n            </Text>\n          )}\n          {!selectedPlugin.entry.commands &&\n            !selectedPlugin.entry.agents &&\n            !selectedPlugin.entry.hooks &&\n            !selectedPlugin.entry.mcpServers && (\n              <>\n                {typeof selectedPlugin.entry.source === 'object' &&\n                'source' in selectedPlugin.entry.source &&\n                (selectedPlugin.entry.source.source === 'github' ||\n                  selectedPlugin.entry.source.source === 'url' ||\n                  selectedPlugin.entry.source.source === 'npm' ||\n                  selectedPlugin.entry.source.source === 'pip') ? (\n                  <Text dimColor>\n                    · Component summary not available for remote plugin\n                  </Text>\n                ) : (\n                  // TODO: Actually scan local plugin directories to show real components\n                  // This would require accessing the filesystem to check for:\n                  // - commands/ directory and list files\n                  // - agents/ directory and list files\n                  // - hooks/ directory and list files\n                  // - .mcp.json or mcp-servers.json files\n                  <Text dimColor>\n                    · Components will be discovered at installation\n                  </Text>\n                )}\n              </>\n            )}\n        </Box>\n\n        <PluginTrustWarning />\n\n        {/* Error message */}\n        {installError && (\n          <Box marginBottom={1}>\n            <Text color=\"error\">Error: {installError}</Text>\n          </Box>\n        )}\n\n        {/* Menu options */}\n        <Box flexDirection=\"column\">\n          {menuOptions.map((option, index) => (\n            <Box key={option.action}>\n              {detailsMenuIndex === index && <Text>{'> '}</Text>}\n              {detailsMenuIndex !== index && <Text>{'  '}</Text>}\n              <Text bold={detailsMenuIndex === index}>\n                {isInstalling && option.action === 'install'\n                  ? 'Installing…'\n                  : option.label}\n              </Text>\n            </Box>\n          ))}\n        </Box>\n\n        <Box marginTop={1} paddingLeft={1}>\n          <Text dimColor>\n            <Byline>\n              <ConfigurableShortcutHint\n                action=\"select:accept\"\n                context=\"Select\"\n                fallback=\"Enter\"\n                description=\"select\"\n              />\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"back\"\n              />\n            </Byline>\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Plugin installation view\n  if (availablePlugins.length === 0) {\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Install plugins</Text>\n        </Box>\n        <Text dimColor>No new plugins available to install.</Text>\n        <Text dimColor>\n          All plugins from this marketplace are already installed.\n        </Text>\n        <Box marginLeft={3}>\n          <Text dimColor italic>\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"go back\"\n            />\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Get visible plugins from pagination\n  const visiblePlugins = pagination.getVisibleItems(availablePlugins)\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box marginBottom={1}>\n        <Text bold>Install Plugins</Text>\n      </Box>\n\n      {/* Scroll up indicator */}\n      {pagination.scrollPosition.canScrollUp && (\n        <Box>\n          <Text dimColor> {figures.arrowUp} more above</Text>\n        </Box>\n      )}\n\n      {/* Plugin list */}\n      {visiblePlugins.map((plugin, visibleIndex) => {\n        const actualIndex = pagination.toActualIndex(visibleIndex)\n        const isSelected = selectedIndex === actualIndex\n        const isSelectedForInstall = selectedForInstall.has(plugin.pluginId)\n        const isInstalling = installingPlugins.has(plugin.pluginId)\n        const isLast = visibleIndex === visiblePlugins.length - 1\n\n        return (\n          <Box\n            key={plugin.pluginId}\n            flexDirection=\"column\"\n            marginBottom={isLast && !error ? 0 : 1}\n          >\n            <Box>\n              <Text color={isSelected ? 'suggestion' : undefined}>\n                {isSelected ? figures.pointer : ' '}{' '}\n              </Text>\n              <Text color={plugin.isInstalled ? 'success' : undefined}>\n                {plugin.isInstalled\n                  ? figures.tick\n                  : isInstalling\n                    ? figures.ellipsis\n                    : isSelectedForInstall\n                      ? figures.radioOn\n                      : figures.radioOff}{' '}\n                {plugin.entry.name}\n                {plugin.entry.category && (\n                  <Text dimColor> [{plugin.entry.category}]</Text>\n                )}\n                {plugin.entry.tags?.includes('community-managed') && (\n                  <Text dimColor> [Community Managed]</Text>\n                )}\n                {plugin.isInstalled && <Text dimColor> (installed)</Text>}\n                {installCounts &&\n                  selectedMarketplace === OFFICIAL_MARKETPLACE_NAME && (\n                    <Text dimColor>\n                      {' · '}\n                      {formatInstallCount(\n                        installCounts.get(plugin.pluginId) ?? 0,\n                      )}{' '}\n                      installs\n                    </Text>\n                  )}\n              </Text>\n            </Box>\n            {plugin.entry.description && (\n              <Box marginLeft={4}>\n                <Text dimColor>\n                  {truncateToWidth(plugin.entry.description, 60)}\n                </Text>\n                {plugin.entry.version && (\n                  <Text dimColor> · v{plugin.entry.version}</Text>\n                )}\n              </Box>\n            )}\n          </Box>\n        )\n      })}\n\n      {/* Scroll down indicator */}\n      {pagination.scrollPosition.canScrollDown && (\n        <Box>\n          <Text dimColor> {figures.arrowDown} more below</Text>\n        </Box>\n      )}\n\n      {/* Error messages shown in the UI */}\n      {error && (\n        <Box marginTop={1}>\n          <Text color=\"error\">\n            {figures.cross} {error}\n          </Text>\n        </Box>\n      )}\n\n      <PluginSelectionKeyHint hasSelection={selectedForInstall.size > 0} />\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/DiscoverPlugins.tsx b/src/commands/plugin/DiscoverPlugins.tsx new file mode 100644 index 0000000000000000000000000000000000000000..d62a8dbb54fa7bf6ee7a48b7324f25e70da491a9 --- /dev/null +++ b/src/commands/plugin/DiscoverPlugins.tsx @@ -0,0 +1,781 @@ +import { c as _c } from "react/compiler-runtime"; +import figures from 'figures'; +import * as React from 'react'; +import { useCallback, useEffect, useMemo, useState } from 'react'; +import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'; +import { Byline } from '../../components/design-system/Byline.js'; +import { SearchBox } from '../../components/SearchBox.js'; +import { useSearchInput } from '../../hooks/useSearchInput.js'; +import { useTerminalSize } from '../../hooks/useTerminalSize.js'; +// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input +import { Box, Text, useInput, useTerminalFocus } from '../../ink.js'; +import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js'; +import type { LoadedPlugin } from '../../types/plugin.js'; +import { count } from '../../utils/array.js'; +import { openBrowser } from '../../utils/browser.js'; +import { logForDebugging } from '../../utils/debug.js'; +import { errorMessage } from '../../utils/errors.js'; +import { clearAllCaches } from '../../utils/plugins/cacheUtils.js'; +import { formatInstallCount, getInstallCounts } from '../../utils/plugins/installCounts.js'; +import { isPluginGloballyInstalled } from '../../utils/plugins/installedPluginsManager.js'; +import { createPluginId, detectEmptyMarketplaceReason, type EmptyMarketplaceReason, formatFailureDetails, formatMarketplaceLoadingErrors, loadMarketplacesWithGracefulDegradation } from '../../utils/plugins/marketplaceHelpers.js'; +import { loadKnownMarketplacesConfig } from '../../utils/plugins/marketplaceManager.js'; +import { OFFICIAL_MARKETPLACE_NAME } from '../../utils/plugins/officialMarketplace.js'; +import { installPluginFromMarketplace } from '../../utils/plugins/pluginInstallationHelpers.js'; +import { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js'; +import { plural } from '../../utils/stringUtils.js'; +import { truncateToWidth } from '../../utils/truncate.js'; +import { findPluginOptionsTarget, PluginOptionsFlow } from './PluginOptionsFlow.js'; +import { PluginTrustWarning } from './PluginTrustWarning.js'; +import { buildPluginDetailsMenuOptions, extractGitHubRepo, type InstallablePlugin } from './pluginDetailsHelpers.js'; +import type { ViewState as ParentViewState } from './types.js'; +import { usePagination } from './usePagination.js'; +type Props = { + error: string | null; + setError: (error: string | null) => void; + result: string | null; + setResult: (result: string | null) => void; + setViewState: (state: ParentViewState) => void; + onInstallComplete?: () => void | Promise; + onSearchModeChange?: (isActive: boolean) => void; + targetPlugin?: string; +}; +type ViewState = 'plugin-list' | 'plugin-details' | { + type: 'plugin-options'; + plugin: LoadedPlugin; + pluginId: string; +}; +export function DiscoverPlugins({ + error, + setError, + result: _result, + setResult, + setViewState: setParentViewState, + onInstallComplete, + onSearchModeChange, + targetPlugin +}: Props): React.ReactNode { + // View state + const [viewState, setViewState] = useState('plugin-list'); + const [selectedPlugin, setSelectedPlugin] = useState(null); + + // Data state + const [availablePlugins, setAvailablePlugins] = useState([]); + const [loading, setLoading] = useState(true); + const [installCounts, setInstallCounts] = useState | null>(null); + + // Search state + const [isSearchMode, setIsSearchModeRaw] = useState(false); + const setIsSearchMode = useCallback((active: boolean) => { + setIsSearchModeRaw(active); + onSearchModeChange?.(active); + }, [onSearchModeChange]); + const { + query: searchQuery, + setQuery: setSearchQuery, + cursorOffset: searchCursorOffset + } = useSearchInput({ + isActive: viewState === 'plugin-list' && isSearchMode && !loading, + onExit: () => { + setIsSearchMode(false); + } + }); + const isTerminalFocused = useTerminalFocus(); + const { + columns: terminalWidth + } = useTerminalSize(); + + // Filter plugins based on search query + const filteredPlugins = useMemo(() => { + if (!searchQuery) return availablePlugins; + const lowerQuery = searchQuery.toLowerCase(); + return availablePlugins.filter(plugin => plugin.entry.name.toLowerCase().includes(lowerQuery) || plugin.entry.description?.toLowerCase().includes(lowerQuery) || plugin.marketplaceName.toLowerCase().includes(lowerQuery)); + }, [availablePlugins, searchQuery]); + + // Selection state + const [selectedIndex, setSelectedIndex] = useState(0); + const [selectedForInstall, setSelectedForInstall] = useState>(new Set()); + const [installingPlugins, setInstallingPlugins] = useState>(new Set()); + + // Pagination for plugin list (continuous scrolling) + const pagination = usePagination({ + totalItems: filteredPlugins.length, + selectedIndex + }); + + // Reset selection when search query changes + useEffect(() => { + setSelectedIndex(0); + }, [searchQuery]); + + // Details view state + const [detailsMenuIndex, setDetailsMenuIndex] = useState(0); + const [isInstalling, setIsInstalling] = useState(false); + const [installError, setInstallError] = useState(null); + + // Warning state for non-critical errors + const [warning, setWarning] = useState(null); + + // Empty state reason + const [emptyReason, setEmptyReason] = useState(null); + + // Load all plugins from all marketplaces + useEffect(() => { + async function loadAllPlugins() { + try { + const config = await loadKnownMarketplacesConfig(); + + // Load marketplaces with graceful degradation + const { + marketplaces, + failures + } = await loadMarketplacesWithGracefulDegradation(config); + + // Collect all plugins from all marketplaces + const allPlugins: InstallablePlugin[] = []; + for (const { + name, + data: marketplace + } of marketplaces) { + if (marketplace) { + for (const entry of marketplace.plugins) { + const pluginId = createPluginId(entry.name, name); + allPlugins.push({ + entry, + marketplaceName: name, + pluginId, + // Only block when globally installed (user/managed scope). + // Project/local-scope installs don't block — user may want to + // promote to user scope so it's available everywhere (gh-29997). + isInstalled: isPluginGloballyInstalled(pluginId) + }); + } + } + } + + // Filter out installed and policy-blocked plugins + const uninstalledPlugins = allPlugins.filter(p => !p.isInstalled && !isPluginBlockedByPolicy(p.pluginId)); + + // Fetch install counts and sort by popularity + try { + const counts = await getInstallCounts(); + setInstallCounts(counts); + if (counts) { + // Sort by install count (descending), then alphabetically + uninstalledPlugins.sort((a_0, b_0) => { + const countA = counts.get(a_0.pluginId) ?? 0; + const countB = counts.get(b_0.pluginId) ?? 0; + if (countA !== countB) return countB - countA; + return a_0.entry.name.localeCompare(b_0.entry.name); + }); + } else { + // No counts available - sort alphabetically + uninstalledPlugins.sort((a_1, b_1) => a_1.entry.name.localeCompare(b_1.entry.name)); + } + } catch (error_0) { + // Log the error, then gracefully degrade to alphabetical sort + logForDebugging(`Failed to fetch install counts: ${errorMessage(error_0)}`); + uninstalledPlugins.sort((a, b) => a.entry.name.localeCompare(b.entry.name)); + } + setAvailablePlugins(uninstalledPlugins); + + // Detect empty reason if no plugins available + const configuredCount = Object.keys(config).length; + if (uninstalledPlugins.length === 0) { + const reason = await detectEmptyMarketplaceReason({ + configuredMarketplaceCount: configuredCount, + failedMarketplaceCount: failures.length + }); + setEmptyReason(reason); + } + + // Handle marketplace loading errors/warnings + const successCount = count(marketplaces, m => m.data !== null); + const errorResult = formatMarketplaceLoadingErrors(failures, successCount); + if (errorResult) { + if (errorResult.type === 'warning') { + setWarning(errorResult.message + '. Showing available plugins.'); + } else { + throw new Error(errorResult.message); + } + } + + // Handle targetPlugin - navigate directly to plugin details + // Search in allPlugins (before filtering) to handle installed plugins gracefully + if (targetPlugin) { + const foundPlugin = allPlugins.find(p_0 => p_0.entry.name === targetPlugin); + if (foundPlugin) { + if (foundPlugin.isInstalled) { + setError(`Plugin '${foundPlugin.pluginId}' is already installed. Use '/plugin' to manage existing plugins.`); + } else { + setSelectedPlugin(foundPlugin); + setViewState('plugin-details'); + } + } else { + setError(`Plugin "${targetPlugin}" not found in any marketplace`); + } + } + } catch (err) { + setError(err instanceof Error ? err.message : 'Failed to load plugins'); + } finally { + setLoading(false); + } + } + void loadAllPlugins(); + }, [setError, targetPlugin]); + + // Install selected plugins + const installSelectedPlugins = async () => { + if (selectedForInstall.size === 0) return; + const pluginsToInstall = availablePlugins.filter(p_1 => selectedForInstall.has(p_1.pluginId)); + setInstallingPlugins(new Set(pluginsToInstall.map(p_2 => p_2.pluginId))); + let successCount_0 = 0; + let failureCount = 0; + const newFailedPlugins: Array<{ + name: string; + reason: string; + }> = []; + for (const plugin_0 of pluginsToInstall) { + const result = await installPluginFromMarketplace({ + pluginId: plugin_0.pluginId, + entry: plugin_0.entry, + marketplaceName: plugin_0.marketplaceName, + scope: 'user' + }); + if (result.success) { + successCount_0++; + } else { + failureCount++; + newFailedPlugins.push({ + name: plugin_0.entry.name, + reason: result.error + }); + } + } + setInstallingPlugins(new Set()); + setSelectedForInstall(new Set()); + clearAllCaches(); + + // Handle installation results + if (failureCount === 0) { + const message = `✓ Installed ${successCount_0} ${plural(successCount_0, 'plugin')}. ` + `Run /reload-plugins to activate.`; + setResult(message); + } else if (successCount_0 === 0) { + setError(`Failed to install: ${formatFailureDetails(newFailedPlugins, true)}`); + } else { + const message_0 = `✓ Installed ${successCount_0} of ${successCount_0 + failureCount} plugins. ` + `Failed: ${formatFailureDetails(newFailedPlugins, false)}. ` + `Run /reload-plugins to activate successfully installed plugins.`; + setResult(message_0); + } + if (successCount_0 > 0) { + if (onInstallComplete) { + await onInstallComplete(); + } + } + setParentViewState({ + type: 'menu' + }); + }; + + // Install single plugin from details view + const handleSinglePluginInstall = async (plugin_1: InstallablePlugin, scope: 'user' | 'project' | 'local' = 'user') => { + setIsInstalling(true); + setInstallError(null); + const result_0 = await installPluginFromMarketplace({ + pluginId: plugin_1.pluginId, + entry: plugin_1.entry, + marketplaceName: plugin_1.marketplaceName, + scope + }); + if (result_0.success) { + const loaded = await findPluginOptionsTarget(plugin_1.pluginId); + if (loaded) { + setIsInstalling(false); + setViewState({ + type: 'plugin-options', + plugin: loaded, + pluginId: plugin_1.pluginId + }); + return; + } + setResult(result_0.message); + if (onInstallComplete) { + await onInstallComplete(); + } + setParentViewState({ + type: 'menu' + }); + } else { + setIsInstalling(false); + setInstallError(result_0.error); + } + }; + + // Handle error state + useEffect(() => { + if (error) { + setResult(error); + } + }, [error, setResult]); + + // Escape in plugin-details view - go back to plugin-list + useKeybinding('confirm:no', () => { + setViewState('plugin-list'); + setSelectedPlugin(null); + }, { + context: 'Confirmation', + isActive: viewState === 'plugin-details' + }); + + // Escape in plugin-list view (not search mode) - exit to parent menu + useKeybinding('confirm:no', () => { + setParentViewState({ + type: 'menu' + }); + }, { + context: 'Confirmation', + isActive: viewState === 'plugin-list' && !isSearchMode + }); + + // Handle entering search mode (non-escape keys) + useInput((input, _key) => { + const keyIsNotCtrlOrMeta = !_key.ctrl && !_key.meta; + if (!isSearchMode) { + // Enter search mode with '/' or any printable character + if (input === '/' && keyIsNotCtrlOrMeta) { + setIsSearchMode(true); + setSearchQuery(''); + } else if (keyIsNotCtrlOrMeta && input.length > 0 && !/^\s+$/.test(input) && + // Don't enter search mode for navigation keys + input !== 'j' && input !== 'k' && input !== 'i') { + setIsSearchMode(true); + setSearchQuery(input); + } + } + }, { + isActive: viewState === 'plugin-list' && !loading + }); + + // Plugin-list navigation (non-search mode) + useKeybindings({ + 'select:previous': () => { + if (selectedIndex === 0) { + setIsSearchMode(true); + } else { + pagination.handleSelectionChange(selectedIndex - 1, setSelectedIndex); + } + }, + 'select:next': () => { + if (selectedIndex < filteredPlugins.length - 1) { + pagination.handleSelectionChange(selectedIndex + 1, setSelectedIndex); + } + }, + 'select:accept': () => { + if (selectedIndex === filteredPlugins.length && selectedForInstall.size > 0) { + void installSelectedPlugins(); + } else if (selectedIndex < filteredPlugins.length) { + const plugin_2 = filteredPlugins[selectedIndex]; + if (plugin_2) { + if (plugin_2.isInstalled) { + setParentViewState({ + type: 'manage-plugins', + targetPlugin: plugin_2.entry.name, + targetMarketplace: plugin_2.marketplaceName + }); + } else { + setSelectedPlugin(plugin_2); + setViewState('plugin-details'); + setDetailsMenuIndex(0); + setInstallError(null); + } + } + } + } + }, { + context: 'Select', + isActive: viewState === 'plugin-list' && !isSearchMode + }); + useKeybindings({ + 'plugin:toggle': () => { + if (selectedIndex < filteredPlugins.length) { + const plugin_3 = filteredPlugins[selectedIndex]; + if (plugin_3 && !plugin_3.isInstalled) { + const newSelection = new Set(selectedForInstall); + if (newSelection.has(plugin_3.pluginId)) { + newSelection.delete(plugin_3.pluginId); + } else { + newSelection.add(plugin_3.pluginId); + } + setSelectedForInstall(newSelection); + } + } + }, + 'plugin:install': () => { + if (selectedForInstall.size > 0) { + void installSelectedPlugins(); + } + } + }, { + context: 'Plugin', + isActive: viewState === 'plugin-list' && !isSearchMode + }); + + // Plugin-details navigation + const detailsMenuOptions = React.useMemo(() => { + if (!selectedPlugin) return []; + const hasHomepage = selectedPlugin.entry.homepage; + const githubRepo = extractGitHubRepo(selectedPlugin); + return buildPluginDetailsMenuOptions(hasHomepage, githubRepo); + }, [selectedPlugin]); + useKeybindings({ + 'select:previous': () => { + if (detailsMenuIndex > 0) { + setDetailsMenuIndex(detailsMenuIndex - 1); + } + }, + 'select:next': () => { + if (detailsMenuIndex < detailsMenuOptions.length - 1) { + setDetailsMenuIndex(detailsMenuIndex + 1); + } + }, + 'select:accept': () => { + if (!selectedPlugin) return; + const action = detailsMenuOptions[detailsMenuIndex]?.action; + const hasHomepage_0 = selectedPlugin.entry.homepage; + const githubRepo_0 = extractGitHubRepo(selectedPlugin); + if (action === 'install-user') { + void handleSinglePluginInstall(selectedPlugin, 'user'); + } else if (action === 'install-project') { + void handleSinglePluginInstall(selectedPlugin, 'project'); + } else if (action === 'install-local') { + void handleSinglePluginInstall(selectedPlugin, 'local'); + } else if (action === 'homepage' && hasHomepage_0) { + void openBrowser(hasHomepage_0); + } else if (action === 'github' && githubRepo_0) { + void openBrowser(`https://github.com/${githubRepo_0}`); + } else if (action === 'back') { + setViewState('plugin-list'); + setSelectedPlugin(null); + } + } + }, { + context: 'Select', + isActive: viewState === 'plugin-details' && !!selectedPlugin + }); + if (typeof viewState === 'object' && viewState.type === 'plugin-options') { + const { + plugin: plugin_4, + pluginId: pluginId_0 + } = viewState; + function finish(msg: string): void { + setResult(msg); + if (onInstallComplete) { + void onInstallComplete(); + } + setParentViewState({ + type: 'menu' + }); + } + return { + switch (outcome) { + case 'configured': + finish(`✓ Installed and configured ${plugin_4.name}. Run /reload-plugins to apply.`); + break; + case 'skipped': + finish(`✓ Installed ${plugin_4.name}. Run /reload-plugins to apply.`); + break; + case 'error': + finish(`Installed but failed to save config: ${detail}`); + break; + } + }} />; + } + + // Loading state + if (loading) { + return Loading…; + } + + // Error state + if (error) { + return {error}; + } + + // Plugin details view + if (viewState === 'plugin-details' && selectedPlugin) { + const hasHomepage_1 = selectedPlugin.entry.homepage; + const githubRepo_1 = extractGitHubRepo(selectedPlugin); + const menuOptions = buildPluginDetailsMenuOptions(hasHomepage_1, githubRepo_1); + return + + Plugin details + + + + {selectedPlugin.entry.name} + from {selectedPlugin.marketplaceName} + {selectedPlugin.entry.version && Version: {selectedPlugin.entry.version}} + {selectedPlugin.entry.description && + {selectedPlugin.entry.description} + } + {selectedPlugin.entry.author && + + By:{' '} + {typeof selectedPlugin.entry.author === 'string' ? selectedPlugin.entry.author : selectedPlugin.entry.author.name} + + } + + + + + {installError && + Error: {installError} + } + + + {menuOptions.map((option, index) => + {detailsMenuIndex === index && {'> '}} + {detailsMenuIndex !== index && {' '}} + + {isInstalling && option.action.startsWith('install-') ? 'Installing…' : option.label} + + )} + + + + + + + + + + + ; + } + + // Empty state + if (availablePlugins.length === 0) { + return + + Discover plugins + + + + + Esc to go back + + + ; + } + + // Get visible plugins from pagination + const visiblePlugins = pagination.getVisibleItems(filteredPlugins); + return + + Discover plugins + {pagination.needsPagination && + {' '} + ({pagination.scrollPosition.current}/ + {pagination.scrollPosition.total}) + } + + + {/* Search box */} + + + + + {/* Warning banner */} + {warning && + + {figures.warning} {warning} + + } + + {/* No search results */} + {filteredPlugins.length === 0 && searchQuery && + No plugins match "{searchQuery}" + } + + {/* Scroll up indicator */} + {pagination.scrollPosition.canScrollUp && + {figures.arrowUp} more above + } + + {/* Plugin list - use startIndex in key to force re-render on scroll */} + {visiblePlugins.map((plugin_5, visibleIndex) => { + const actualIndex = pagination.toActualIndex(visibleIndex); + const isSelected = selectedIndex === actualIndex; + const isSelectedForInstall = selectedForInstall.has(plugin_5.pluginId); + const isInstallingThis = installingPlugins.has(plugin_5.pluginId); + const isLast = visibleIndex === visiblePlugins.length - 1; + return + + + {isSelected && !isSearchMode ? figures.pointer : ' '}{' '} + + + {isInstallingThis ? figures.ellipsis : isSelectedForInstall ? figures.radioOn : figures.radioOff}{' '} + {plugin_5.entry.name} + · {plugin_5.marketplaceName} + {plugin_5.entry.tags?.includes('community-managed') && [Community Managed]} + {installCounts && plugin_5.marketplaceName === OFFICIAL_MARKETPLACE_NAME && + {' · '} + {formatInstallCount(installCounts.get(plugin_5.pluginId) ?? 0)}{' '} + installs + } + + + {plugin_5.entry.description && + + {truncateToWidth(plugin_5.entry.description, 60)} + + } + ; + })} + + {/* Scroll down indicator */} + {pagination.scrollPosition.canScrollDown && + {figures.arrowDown} more below + } + + {/* Error messages */} + {error && + + {figures.cross} {error} + + } + + 0} canToggle={selectedIndex < filteredPlugins.length && !filteredPlugins[selectedIndex]?.isInstalled} /> + ; +} +function DiscoverPluginsKeyHint(t0) { + const $ = _c(10); + const { + hasSelection, + canToggle + } = t0; + let t1; + if ($[0] !== hasSelection) { + t1 = hasSelection && ; + $[0] = hasSelection; + $[1] = t1; + } else { + t1 = $[1]; + } + let t2; + if ($[2] === Symbol.for("react.memo_cache_sentinel")) { + t2 = type to search; + $[2] = t2; + } else { + t2 = $[2]; + } + let t3; + if ($[3] !== canToggle) { + t3 = canToggle && ; + $[3] = canToggle; + $[4] = t3; + } else { + t3 = $[4]; + } + let t4; + let t5; + if ($[5] === Symbol.for("react.memo_cache_sentinel")) { + t4 = ; + t5 = ; + $[5] = t4; + $[6] = t5; + } else { + t4 = $[5]; + t5 = $[6]; + } + let t6; + if ($[7] !== t1 || $[8] !== t3) { + t6 = {t1}{t2}{t3}{t4}{t5}; + $[7] = t1; + $[8] = t3; + $[9] = t6; + } else { + t6 = $[9]; + } + return t6; +} + +/** + * Context-aware empty state message for the Discover screen + */ +function EmptyStateMessage(t0) { + const $ = _c(6); + const { + reason + } = t0; + switch (reason) { + case "git-not-installed": + { + let t1; + if ($[0] === Symbol.for("react.memo_cache_sentinel")) { + t1 = <>Git is required to install marketplaces.Please install git and restart Claude Code.; + $[0] = t1; + } else { + t1 = $[0]; + } + return t1; + } + case "all-blocked-by-policy": + { + let t1; + if ($[1] === Symbol.for("react.memo_cache_sentinel")) { + t1 = <>Your organization policy does not allow any external marketplaces.Contact your administrator.; + $[1] = t1; + } else { + t1 = $[1]; + } + return t1; + } + case "policy-restricts-sources": + { + let t1; + if ($[2] === Symbol.for("react.memo_cache_sentinel")) { + t1 = <>Your organization restricts which marketplaces can be added.Switch to the Marketplaces tab to view allowed sources.; + $[2] = t1; + } else { + t1 = $[2]; + } + return t1; + } + case "all-marketplaces-failed": + { + let t1; + if ($[3] === Symbol.for("react.memo_cache_sentinel")) { + t1 = <>Failed to load marketplace data.Check your network connection.; + $[3] = t1; + } else { + t1 = $[3]; + } + return t1; + } + case "all-plugins-installed": + { + let t1; + if ($[4] === Symbol.for("react.memo_cache_sentinel")) { + t1 = <>All available plugins are already installed.Check for new plugins later or add more marketplaces.; + $[4] = t1; + } else { + t1 = $[4]; + } + return t1; + } + case "no-marketplaces-configured": + default: + { + let t1; + if ($[5] === Symbol.for("react.memo_cache_sentinel")) { + t1 = <>No plugins available.Add a marketplace first using the Marketplaces tab.; + $[5] = t1; + } else { + t1 = $[5]; + } + return t1; + } + } +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useCallback","useEffect","useMemo","useState","ConfigurableShortcutHint","Byline","SearchBox","useSearchInput","useTerminalSize","Box","Text","useInput","useTerminalFocus","useKeybinding","useKeybindings","LoadedPlugin","count","openBrowser","logForDebugging","errorMessage","clearAllCaches","formatInstallCount","getInstallCounts","isPluginGloballyInstalled","createPluginId","detectEmptyMarketplaceReason","EmptyMarketplaceReason","formatFailureDetails","formatMarketplaceLoadingErrors","loadMarketplacesWithGracefulDegradation","loadKnownMarketplacesConfig","OFFICIAL_MARKETPLACE_NAME","installPluginFromMarketplace","isPluginBlockedByPolicy","plural","truncateToWidth","findPluginOptionsTarget","PluginOptionsFlow","PluginTrustWarning","buildPluginDetailsMenuOptions","extractGitHubRepo","InstallablePlugin","ViewState","ParentViewState","usePagination","Props","error","setError","result","setResult","setViewState","state","onInstallComplete","Promise","onSearchModeChange","isActive","targetPlugin","type","plugin","pluginId","DiscoverPlugins","_result","setParentViewState","ReactNode","viewState","selectedPlugin","setSelectedPlugin","availablePlugins","setAvailablePlugins","loading","setLoading","installCounts","setInstallCounts","Map","isSearchMode","setIsSearchModeRaw","setIsSearchMode","active","query","searchQuery","setQuery","setSearchQuery","cursorOffset","searchCursorOffset","onExit","isTerminalFocused","columns","terminalWidth","filteredPlugins","lowerQuery","toLowerCase","filter","entry","name","includes","description","marketplaceName","selectedIndex","setSelectedIndex","selectedForInstall","setSelectedForInstall","Set","installingPlugins","setInstallingPlugins","pagination","totalItems","length","detailsMenuIndex","setDetailsMenuIndex","isInstalling","setIsInstalling","installError","setInstallError","warning","setWarning","emptyReason","setEmptyReason","loadAllPlugins","config","marketplaces","failures","allPlugins","data","marketplace","plugins","push","isInstalled","uninstalledPlugins","p","counts","sort","a","b","countA","get","countB","localeCompare","configuredCount","Object","keys","reason","configuredMarketplaceCount","failedMarketplaceCount","successCount","m","errorResult","message","Error","foundPlugin","find","err","installSelectedPlugins","size","pluginsToInstall","has","map","failureCount","newFailedPlugins","Array","scope","success","handleSinglePluginInstall","loaded","context","input","_key","keyIsNotCtrlOrMeta","ctrl","meta","test","select:previous","handleSelectionChange","select:next","select:accept","targetMarketplace","plugin:toggle","newSelection","delete","add","plugin:install","detailsMenuOptions","hasHomepage","homepage","githubRepo","action","finish","msg","outcome","detail","menuOptions","version","author","option","index","startsWith","label","visiblePlugins","getVisibleItems","needsPagination","scrollPosition","current","total","canScrollUp","arrowUp","visibleIndex","actualIndex","toActualIndex","isSelected","isSelectedForInstall","isInstallingThis","isLast","startIndex","undefined","pointer","ellipsis","radioOn","radioOff","tags","canScrollDown","arrowDown","cross","DiscoverPluginsKeyHint","t0","$","_c","hasSelection","canToggle","t1","t2","Symbol","for","t3","t4","t5","t6","EmptyStateMessage"],"sources":["DiscoverPlugins.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { useCallback, useEffect, useMemo, useState } from 'react'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { SearchBox } from '../../components/SearchBox.js'\nimport { useSearchInput } from '../../hooks/useSearchInput.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input\nimport { Box, Text, useInput, useTerminalFocus } from '../../ink.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport type { LoadedPlugin } from '../../types/plugin.js'\nimport { count } from '../../utils/array.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport {\n  formatInstallCount,\n  getInstallCounts,\n} from '../../utils/plugins/installCounts.js'\nimport { isPluginGloballyInstalled } from '../../utils/plugins/installedPluginsManager.js'\nimport {\n  createPluginId,\n  detectEmptyMarketplaceReason,\n  type EmptyMarketplaceReason,\n  formatFailureDetails,\n  formatMarketplaceLoadingErrors,\n  loadMarketplacesWithGracefulDegradation,\n} from '../../utils/plugins/marketplaceHelpers.js'\nimport { loadKnownMarketplacesConfig } from '../../utils/plugins/marketplaceManager.js'\nimport { OFFICIAL_MARKETPLACE_NAME } from '../../utils/plugins/officialMarketplace.js'\nimport { installPluginFromMarketplace } from '../../utils/plugins/pluginInstallationHelpers.js'\nimport { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport { truncateToWidth } from '../../utils/truncate.js'\nimport {\n  findPluginOptionsTarget,\n  PluginOptionsFlow,\n} from './PluginOptionsFlow.js'\nimport { PluginTrustWarning } from './PluginTrustWarning.js'\nimport {\n  buildPluginDetailsMenuOptions,\n  extractGitHubRepo,\n  type InstallablePlugin,\n} from './pluginDetailsHelpers.js'\nimport type { ViewState as ParentViewState } from './types.js'\nimport { usePagination } from './usePagination.js'\n\ntype Props = {\n  error: string | null\n  setError: (error: string | null) => void\n  result: string | null\n  setResult: (result: string | null) => void\n  setViewState: (state: ParentViewState) => void\n  onInstallComplete?: () => void | Promise<void>\n  onSearchModeChange?: (isActive: boolean) => void\n  targetPlugin?: string\n}\n\ntype ViewState =\n  | 'plugin-list'\n  | 'plugin-details'\n  | { type: 'plugin-options'; plugin: LoadedPlugin; pluginId: string }\n\nexport function DiscoverPlugins({\n  error,\n  setError,\n  result: _result,\n  setResult,\n  setViewState: setParentViewState,\n  onInstallComplete,\n  onSearchModeChange,\n  targetPlugin,\n}: Props): React.ReactNode {\n  // View state\n  const [viewState, setViewState] = useState<ViewState>('plugin-list')\n  const [selectedPlugin, setSelectedPlugin] =\n    useState<InstallablePlugin | null>(null)\n\n  // Data state\n  const [availablePlugins, setAvailablePlugins] = useState<InstallablePlugin[]>(\n    [],\n  )\n  const [loading, setLoading] = useState(true)\n  const [installCounts, setInstallCounts] = useState<Map<\n    string,\n    number\n  > | null>(null)\n\n  // Search state\n  const [isSearchMode, setIsSearchModeRaw] = useState(false)\n  const setIsSearchMode = useCallback(\n    (active: boolean) => {\n      setIsSearchModeRaw(active)\n      onSearchModeChange?.(active)\n    },\n    [onSearchModeChange],\n  )\n  const {\n    query: searchQuery,\n    setQuery: setSearchQuery,\n    cursorOffset: searchCursorOffset,\n  } = useSearchInput({\n    isActive: viewState === 'plugin-list' && isSearchMode && !loading,\n    onExit: () => {\n      setIsSearchMode(false)\n    },\n  })\n  const isTerminalFocused = useTerminalFocus()\n  const { columns: terminalWidth } = useTerminalSize()\n\n  // Filter plugins based on search query\n  const filteredPlugins = useMemo(() => {\n    if (!searchQuery) return availablePlugins\n    const lowerQuery = searchQuery.toLowerCase()\n    return availablePlugins.filter(\n      plugin =>\n        plugin.entry.name.toLowerCase().includes(lowerQuery) ||\n        plugin.entry.description?.toLowerCase().includes(lowerQuery) ||\n        plugin.marketplaceName.toLowerCase().includes(lowerQuery),\n    )\n  }, [availablePlugins, searchQuery])\n\n  // Selection state\n  const [selectedIndex, setSelectedIndex] = useState(0)\n  const [selectedForInstall, setSelectedForInstall] = useState<Set<string>>(\n    new Set(),\n  )\n  const [installingPlugins, setInstallingPlugins] = useState<Set<string>>(\n    new Set(),\n  )\n\n  // Pagination for plugin list (continuous scrolling)\n  const pagination = usePagination<InstallablePlugin>({\n    totalItems: filteredPlugins.length,\n    selectedIndex,\n  })\n\n  // Reset selection when search query changes\n  useEffect(() => {\n    setSelectedIndex(0)\n  }, [searchQuery])\n\n  // Details view state\n  const [detailsMenuIndex, setDetailsMenuIndex] = useState(0)\n  const [isInstalling, setIsInstalling] = useState(false)\n  const [installError, setInstallError] = useState<string | null>(null)\n\n  // Warning state for non-critical errors\n  const [warning, setWarning] = useState<string | null>(null)\n\n  // Empty state reason\n  const [emptyReason, setEmptyReason] = useState<EmptyMarketplaceReason | null>(\n    null,\n  )\n\n  // Load all plugins from all marketplaces\n  useEffect(() => {\n    async function loadAllPlugins() {\n      try {\n        const config = await loadKnownMarketplacesConfig()\n\n        // Load marketplaces with graceful degradation\n        const { marketplaces, failures } =\n          await loadMarketplacesWithGracefulDegradation(config)\n\n        // Collect all plugins from all marketplaces\n        const allPlugins: InstallablePlugin[] = []\n\n        for (const { name, data: marketplace } of marketplaces) {\n          if (marketplace) {\n            for (const entry of marketplace.plugins) {\n              const pluginId = createPluginId(entry.name, name)\n              allPlugins.push({\n                entry,\n                marketplaceName: name,\n                pluginId,\n                // Only block when globally installed (user/managed scope).\n                // Project/local-scope installs don't block — user may want to\n                // promote to user scope so it's available everywhere (gh-29997).\n                isInstalled: isPluginGloballyInstalled(pluginId),\n              })\n            }\n          }\n        }\n\n        // Filter out installed and policy-blocked plugins\n        const uninstalledPlugins = allPlugins.filter(\n          p => !p.isInstalled && !isPluginBlockedByPolicy(p.pluginId),\n        )\n\n        // Fetch install counts and sort by popularity\n        try {\n          const counts = await getInstallCounts()\n          setInstallCounts(counts)\n\n          if (counts) {\n            // Sort by install count (descending), then alphabetically\n            uninstalledPlugins.sort((a, b) => {\n              const countA = counts.get(a.pluginId) ?? 0\n              const countB = counts.get(b.pluginId) ?? 0\n              if (countA !== countB) return countB - countA\n              return a.entry.name.localeCompare(b.entry.name)\n            })\n          } else {\n            // No counts available - sort alphabetically\n            uninstalledPlugins.sort((a, b) =>\n              a.entry.name.localeCompare(b.entry.name),\n            )\n          }\n        } catch (error) {\n          // Log the error, then gracefully degrade to alphabetical sort\n          logForDebugging(\n            `Failed to fetch install counts: ${errorMessage(error)}`,\n          )\n          uninstalledPlugins.sort((a, b) =>\n            a.entry.name.localeCompare(b.entry.name),\n          )\n        }\n\n        setAvailablePlugins(uninstalledPlugins)\n\n        // Detect empty reason if no plugins available\n        const configuredCount = Object.keys(config).length\n        if (uninstalledPlugins.length === 0) {\n          const reason = await detectEmptyMarketplaceReason({\n            configuredMarketplaceCount: configuredCount,\n            failedMarketplaceCount: failures.length,\n          })\n          setEmptyReason(reason)\n        }\n\n        // Handle marketplace loading errors/warnings\n        const successCount = count(marketplaces, m => m.data !== null)\n        const errorResult = formatMarketplaceLoadingErrors(\n          failures,\n          successCount,\n        )\n        if (errorResult) {\n          if (errorResult.type === 'warning') {\n            setWarning(errorResult.message + '. Showing available plugins.')\n          } else {\n            throw new Error(errorResult.message)\n          }\n        }\n\n        // Handle targetPlugin - navigate directly to plugin details\n        // Search in allPlugins (before filtering) to handle installed plugins gracefully\n        if (targetPlugin) {\n          const foundPlugin = allPlugins.find(\n            p => p.entry.name === targetPlugin,\n          )\n\n          if (foundPlugin) {\n            if (foundPlugin.isInstalled) {\n              setError(\n                `Plugin '${foundPlugin.pluginId}' is already installed. Use '/plugin' to manage existing plugins.`,\n              )\n            } else {\n              setSelectedPlugin(foundPlugin)\n              setViewState('plugin-details')\n            }\n          } else {\n            setError(`Plugin \"${targetPlugin}\" not found in any marketplace`)\n          }\n        }\n      } catch (err) {\n        setError(err instanceof Error ? err.message : 'Failed to load plugins')\n      } finally {\n        setLoading(false)\n      }\n    }\n    void loadAllPlugins()\n  }, [setError, targetPlugin])\n\n  // Install selected plugins\n  const installSelectedPlugins = async () => {\n    if (selectedForInstall.size === 0) return\n\n    const pluginsToInstall = availablePlugins.filter(p =>\n      selectedForInstall.has(p.pluginId),\n    )\n\n    setInstallingPlugins(new Set(pluginsToInstall.map(p => p.pluginId)))\n\n    let successCount = 0\n    let failureCount = 0\n    const newFailedPlugins: Array<{ name: string; reason: string }> = []\n\n    for (const plugin of pluginsToInstall) {\n      const result = await installPluginFromMarketplace({\n        pluginId: plugin.pluginId,\n        entry: plugin.entry,\n        marketplaceName: plugin.marketplaceName,\n        scope: 'user',\n      })\n\n      if (result.success) {\n        successCount++\n      } else {\n        failureCount++\n        newFailedPlugins.push({\n          name: plugin.entry.name,\n          reason: result.error,\n        })\n      }\n    }\n\n    setInstallingPlugins(new Set())\n    setSelectedForInstall(new Set())\n    clearAllCaches()\n\n    // Handle installation results\n    if (failureCount === 0) {\n      const message =\n        `✓ Installed ${successCount} ${plural(successCount, 'plugin')}. ` +\n        `Run /reload-plugins to activate.`\n      setResult(message)\n    } else if (successCount === 0) {\n      setError(\n        `Failed to install: ${formatFailureDetails(newFailedPlugins, true)}`,\n      )\n    } else {\n      const message =\n        `✓ Installed ${successCount} of ${successCount + failureCount} plugins. ` +\n        `Failed: ${formatFailureDetails(newFailedPlugins, false)}. ` +\n        `Run /reload-plugins to activate successfully installed plugins.`\n      setResult(message)\n    }\n\n    if (successCount > 0) {\n      if (onInstallComplete) {\n        await onInstallComplete()\n      }\n    }\n\n    setParentViewState({ type: 'menu' })\n  }\n\n  // Install single plugin from details view\n  const handleSinglePluginInstall = async (\n    plugin: InstallablePlugin,\n    scope: 'user' | 'project' | 'local' = 'user',\n  ) => {\n    setIsInstalling(true)\n    setInstallError(null)\n\n    const result = await installPluginFromMarketplace({\n      pluginId: plugin.pluginId,\n      entry: plugin.entry,\n      marketplaceName: plugin.marketplaceName,\n      scope,\n    })\n\n    if (result.success) {\n      const loaded = await findPluginOptionsTarget(plugin.pluginId)\n      if (loaded) {\n        setIsInstalling(false)\n        setViewState({\n          type: 'plugin-options',\n          plugin: loaded,\n          pluginId: plugin.pluginId,\n        })\n        return\n      }\n      setResult(result.message)\n      if (onInstallComplete) {\n        await onInstallComplete()\n      }\n      setParentViewState({ type: 'menu' })\n    } else {\n      setIsInstalling(false)\n      setInstallError(result.error)\n    }\n  }\n\n  // Handle error state\n  useEffect(() => {\n    if (error) {\n      setResult(error)\n    }\n  }, [error, setResult])\n\n  // Escape in plugin-details view - go back to plugin-list\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setViewState('plugin-list')\n      setSelectedPlugin(null)\n    },\n    {\n      context: 'Confirmation',\n      isActive: viewState === 'plugin-details',\n    },\n  )\n\n  // Escape in plugin-list view (not search mode) - exit to parent menu\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setParentViewState({ type: 'menu' })\n    },\n    {\n      context: 'Confirmation',\n      isActive: viewState === 'plugin-list' && !isSearchMode,\n    },\n  )\n\n  // Handle entering search mode (non-escape keys)\n  useInput(\n    (input, _key) => {\n      const keyIsNotCtrlOrMeta = !_key.ctrl && !_key.meta\n      if (!isSearchMode) {\n        // Enter search mode with '/' or any printable character\n        if (input === '/' && keyIsNotCtrlOrMeta) {\n          setIsSearchMode(true)\n          setSearchQuery('')\n        } else if (\n          keyIsNotCtrlOrMeta &&\n          input.length > 0 &&\n          !/^\\s+$/.test(input) &&\n          // Don't enter search mode for navigation keys\n          input !== 'j' &&\n          input !== 'k' &&\n          input !== 'i'\n        ) {\n          setIsSearchMode(true)\n          setSearchQuery(input)\n        }\n      }\n    },\n    { isActive: viewState === 'plugin-list' && !loading },\n  )\n\n  // Plugin-list navigation (non-search mode)\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (selectedIndex === 0) {\n          setIsSearchMode(true)\n        } else {\n          pagination.handleSelectionChange(selectedIndex - 1, setSelectedIndex)\n        }\n      },\n      'select:next': () => {\n        if (selectedIndex < filteredPlugins.length - 1) {\n          pagination.handleSelectionChange(selectedIndex + 1, setSelectedIndex)\n        }\n      },\n      'select:accept': () => {\n        if (\n          selectedIndex === filteredPlugins.length &&\n          selectedForInstall.size > 0\n        ) {\n          void installSelectedPlugins()\n        } else if (selectedIndex < filteredPlugins.length) {\n          const plugin = filteredPlugins[selectedIndex]\n          if (plugin) {\n            if (plugin.isInstalled) {\n              setParentViewState({\n                type: 'manage-plugins',\n                targetPlugin: plugin.entry.name,\n                targetMarketplace: plugin.marketplaceName,\n              })\n            } else {\n              setSelectedPlugin(plugin)\n              setViewState('plugin-details')\n              setDetailsMenuIndex(0)\n              setInstallError(null)\n            }\n          }\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive: viewState === 'plugin-list' && !isSearchMode,\n    },\n  )\n\n  useKeybindings(\n    {\n      'plugin:toggle': () => {\n        if (selectedIndex < filteredPlugins.length) {\n          const plugin = filteredPlugins[selectedIndex]\n          if (plugin && !plugin.isInstalled) {\n            const newSelection = new Set(selectedForInstall)\n            if (newSelection.has(plugin.pluginId)) {\n              newSelection.delete(plugin.pluginId)\n            } else {\n              newSelection.add(plugin.pluginId)\n            }\n            setSelectedForInstall(newSelection)\n          }\n        }\n      },\n      'plugin:install': () => {\n        if (selectedForInstall.size > 0) {\n          void installSelectedPlugins()\n        }\n      },\n    },\n    {\n      context: 'Plugin',\n      isActive: viewState === 'plugin-list' && !isSearchMode,\n    },\n  )\n\n  // Plugin-details navigation\n  const detailsMenuOptions = React.useMemo(() => {\n    if (!selectedPlugin) return []\n    const hasHomepage = selectedPlugin.entry.homepage\n    const githubRepo = extractGitHubRepo(selectedPlugin)\n    return buildPluginDetailsMenuOptions(hasHomepage, githubRepo)\n  }, [selectedPlugin])\n\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (detailsMenuIndex > 0) {\n          setDetailsMenuIndex(detailsMenuIndex - 1)\n        }\n      },\n      'select:next': () => {\n        if (detailsMenuIndex < detailsMenuOptions.length - 1) {\n          setDetailsMenuIndex(detailsMenuIndex + 1)\n        }\n      },\n      'select:accept': () => {\n        if (!selectedPlugin) return\n        const action = detailsMenuOptions[detailsMenuIndex]?.action\n        const hasHomepage = selectedPlugin.entry.homepage\n        const githubRepo = extractGitHubRepo(selectedPlugin)\n        if (action === 'install-user') {\n          void handleSinglePluginInstall(selectedPlugin, 'user')\n        } else if (action === 'install-project') {\n          void handleSinglePluginInstall(selectedPlugin, 'project')\n        } else if (action === 'install-local') {\n          void handleSinglePluginInstall(selectedPlugin, 'local')\n        } else if (action === 'homepage' && hasHomepage) {\n          void openBrowser(hasHomepage)\n        } else if (action === 'github' && githubRepo) {\n          void openBrowser(`https://github.com/${githubRepo}`)\n        } else if (action === 'back') {\n          setViewState('plugin-list')\n          setSelectedPlugin(null)\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive: viewState === 'plugin-details' && !!selectedPlugin,\n    },\n  )\n\n  if (typeof viewState === 'object' && viewState.type === 'plugin-options') {\n    const { plugin, pluginId } = viewState\n    function finish(msg: string): void {\n      setResult(msg)\n      if (onInstallComplete) {\n        void onInstallComplete()\n      }\n      setParentViewState({ type: 'menu' })\n    }\n    return (\n      <PluginOptionsFlow\n        plugin={plugin}\n        pluginId={pluginId}\n        onDone={(outcome, detail) => {\n          switch (outcome) {\n            case 'configured':\n              finish(\n                `✓ Installed and configured ${plugin.name}. Run /reload-plugins to apply.`,\n              )\n              break\n            case 'skipped':\n              finish(\n                `✓ Installed ${plugin.name}. Run /reload-plugins to apply.`,\n              )\n              break\n            case 'error':\n              finish(`Installed but failed to save config: ${detail}`)\n              break\n          }\n        }}\n      />\n    )\n  }\n\n  // Loading state\n  if (loading) {\n    return <Text>Loading…</Text>\n  }\n\n  // Error state\n  if (error) {\n    return <Text color=\"error\">{error}</Text>\n  }\n\n  // Plugin details view\n  if (viewState === 'plugin-details' && selectedPlugin) {\n    const hasHomepage = selectedPlugin.entry.homepage\n    const githubRepo = extractGitHubRepo(selectedPlugin)\n\n    const menuOptions = buildPluginDetailsMenuOptions(hasHomepage, githubRepo)\n\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Plugin details</Text>\n        </Box>\n\n        <Box flexDirection=\"column\" marginBottom={1}>\n          <Text bold>{selectedPlugin.entry.name}</Text>\n          <Text dimColor>from {selectedPlugin.marketplaceName}</Text>\n          {selectedPlugin.entry.version && (\n            <Text dimColor>Version: {selectedPlugin.entry.version}</Text>\n          )}\n          {selectedPlugin.entry.description && (\n            <Box marginTop={1}>\n              <Text>{selectedPlugin.entry.description}</Text>\n            </Box>\n          )}\n          {selectedPlugin.entry.author && (\n            <Box marginTop={1}>\n              <Text dimColor>\n                By:{' '}\n                {typeof selectedPlugin.entry.author === 'string'\n                  ? selectedPlugin.entry.author\n                  : selectedPlugin.entry.author.name}\n              </Text>\n            </Box>\n          )}\n        </Box>\n\n        <PluginTrustWarning />\n\n        {installError && (\n          <Box marginBottom={1}>\n            <Text color=\"error\">Error: {installError}</Text>\n          </Box>\n        )}\n\n        <Box flexDirection=\"column\">\n          {menuOptions.map((option, index) => (\n            <Box key={option.action}>\n              {detailsMenuIndex === index && <Text>{'> '}</Text>}\n              {detailsMenuIndex !== index && <Text>{'  '}</Text>}\n              <Text bold={detailsMenuIndex === index}>\n                {isInstalling && option.action.startsWith('install-')\n                  ? 'Installing…'\n                  : option.label}\n              </Text>\n            </Box>\n          ))}\n        </Box>\n\n        <Box marginTop={1}>\n          <Text dimColor>\n            <Byline>\n              <ConfigurableShortcutHint\n                action=\"select:accept\"\n                context=\"Select\"\n                fallback=\"Enter\"\n                description=\"select\"\n              />\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"back\"\n              />\n            </Byline>\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Empty state\n  if (availablePlugins.length === 0) {\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Discover plugins</Text>\n        </Box>\n        <EmptyStateMessage reason={emptyReason} />\n        <Box marginTop={1}>\n          <Text dimColor italic>\n            Esc to go back\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Get visible plugins from pagination\n  const visiblePlugins = pagination.getVisibleItems(filteredPlugins)\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box>\n        <Text bold>Discover plugins</Text>\n        {pagination.needsPagination && (\n          <Text dimColor>\n            {' '}\n            ({pagination.scrollPosition.current}/\n            {pagination.scrollPosition.total})\n          </Text>\n        )}\n      </Box>\n\n      {/* Search box */}\n      <Box marginBottom={1}>\n        <SearchBox\n          query={searchQuery}\n          isFocused={isSearchMode}\n          isTerminalFocused={isTerminalFocused}\n          width={terminalWidth - 4}\n          cursorOffset={searchCursorOffset}\n        />\n      </Box>\n\n      {/* Warning banner */}\n      {warning && (\n        <Box marginBottom={1}>\n          <Text color=\"warning\">\n            {figures.warning} {warning}\n          </Text>\n        </Box>\n      )}\n\n      {/* No search results */}\n      {filteredPlugins.length === 0 && searchQuery && (\n        <Box marginBottom={1}>\n          <Text dimColor>No plugins match &quot;{searchQuery}&quot;</Text>\n        </Box>\n      )}\n\n      {/* Scroll up indicator */}\n      {pagination.scrollPosition.canScrollUp && (\n        <Box>\n          <Text dimColor> {figures.arrowUp} more above</Text>\n        </Box>\n      )}\n\n      {/* Plugin list - use startIndex in key to force re-render on scroll */}\n      {visiblePlugins.map((plugin, visibleIndex) => {\n        const actualIndex = pagination.toActualIndex(visibleIndex)\n        const isSelected = selectedIndex === actualIndex\n        const isSelectedForInstall = selectedForInstall.has(plugin.pluginId)\n        const isInstallingThis = installingPlugins.has(plugin.pluginId)\n        const isLast = visibleIndex === visiblePlugins.length - 1\n\n        return (\n          <Box\n            key={`${pagination.startIndex}-${plugin.pluginId}`}\n            flexDirection=\"column\"\n            marginBottom={isLast && !error ? 0 : 1}\n          >\n            <Box>\n              <Text\n                color={isSelected && !isSearchMode ? 'suggestion' : undefined}\n              >\n                {isSelected && !isSearchMode ? figures.pointer : ' '}{' '}\n              </Text>\n              <Text>\n                {isInstallingThis\n                  ? figures.ellipsis\n                  : isSelectedForInstall\n                    ? figures.radioOn\n                    : figures.radioOff}{' '}\n                {plugin.entry.name}\n                <Text dimColor> · {plugin.marketplaceName}</Text>\n                {plugin.entry.tags?.includes('community-managed') && (\n                  <Text dimColor> [Community Managed]</Text>\n                )}\n                {installCounts &&\n                  plugin.marketplaceName === OFFICIAL_MARKETPLACE_NAME && (\n                    <Text dimColor>\n                      {' · '}\n                      {formatInstallCount(\n                        installCounts.get(plugin.pluginId) ?? 0,\n                      )}{' '}\n                      installs\n                    </Text>\n                  )}\n              </Text>\n            </Box>\n            {plugin.entry.description && (\n              <Box marginLeft={4}>\n                <Text dimColor>\n                  {truncateToWidth(plugin.entry.description, 60)}\n                </Text>\n              </Box>\n            )}\n          </Box>\n        )\n      })}\n\n      {/* Scroll down indicator */}\n      {pagination.scrollPosition.canScrollDown && (\n        <Box>\n          <Text dimColor> {figures.arrowDown} more below</Text>\n        </Box>\n      )}\n\n      {/* Error messages */}\n      {error && (\n        <Box marginTop={1}>\n          <Text color=\"error\">\n            {figures.cross} {error}\n          </Text>\n        </Box>\n      )}\n\n      <DiscoverPluginsKeyHint\n        hasSelection={selectedForInstall.size > 0}\n        canToggle={\n          selectedIndex < filteredPlugins.length &&\n          !filteredPlugins[selectedIndex]?.isInstalled\n        }\n      />\n    </Box>\n  )\n}\n\nfunction DiscoverPluginsKeyHint({\n  hasSelection,\n  canToggle,\n}: {\n  hasSelection: boolean\n  canToggle: boolean\n}): React.ReactNode {\n  return (\n    <Box marginTop={1}>\n      <Text dimColor italic>\n        <Byline>\n          {hasSelection && (\n            <ConfigurableShortcutHint\n              action=\"plugin:install\"\n              context=\"Plugin\"\n              fallback=\"i\"\n              description=\"install\"\n              bold\n            />\n          )}\n          <Text>type to search</Text>\n          {canToggle && (\n            <ConfigurableShortcutHint\n              action=\"plugin:toggle\"\n              context=\"Plugin\"\n              fallback=\"Space\"\n              description=\"toggle\"\n            />\n          )}\n          <ConfigurableShortcutHint\n            action=\"select:accept\"\n            context=\"Select\"\n            fallback=\"Enter\"\n            description=\"details\"\n          />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"back\"\n          />\n        </Byline>\n      </Text>\n    </Box>\n  )\n}\n\n/**\n * Context-aware empty state message for the Discover screen\n */\nfunction EmptyStateMessage({\n  reason,\n}: {\n  reason: EmptyMarketplaceReason | null\n}): React.ReactNode {\n  switch (reason) {\n    case 'git-not-installed':\n      return (\n        <>\n          <Text dimColor>Git is required to install marketplaces.</Text>\n          <Text dimColor>Please install git and restart Claude Code.</Text>\n        </>\n      )\n    case 'all-blocked-by-policy':\n      return (\n        <>\n          <Text dimColor>\n            Your organization policy does not allow any external marketplaces.\n          </Text>\n          <Text dimColor>Contact your administrator.</Text>\n        </>\n      )\n    case 'policy-restricts-sources':\n      return (\n        <>\n          <Text dimColor>\n            Your organization restricts which marketplaces can be added.\n          </Text>\n          <Text dimColor>\n            Switch to the Marketplaces tab to view allowed sources.\n          </Text>\n        </>\n      )\n    case 'all-marketplaces-failed':\n      return (\n        <>\n          <Text dimColor>Failed to load marketplace data.</Text>\n          <Text dimColor>Check your network connection.</Text>\n        </>\n      )\n    case 'all-plugins-installed':\n      return (\n        <>\n          <Text dimColor>All available plugins are already installed.</Text>\n          <Text dimColor>\n            Check for new plugins later or add more marketplaces.\n          </Text>\n        </>\n      )\n    case 'no-marketplaces-configured':\n    default:\n      return (\n        <>\n          <Text dimColor>No plugins available.</Text>\n          <Text dimColor>\n            Add a marketplace first using the Marketplaces tab.\n          </Text>\n        </>\n      )\n  }\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/ManageMarketplaces.tsx b/src/commands/plugin/ManageMarketplaces.tsx new file mode 100644 index 0000000000000000000000000000000000000000..0e5d3ccf1b5d042c6850bc812ab0718ec5d5e63d --- /dev/null +++ b/src/commands/plugin/ManageMarketplaces.tsx @@ -0,0 +1,838 @@ +import { c as _c } from "react/compiler-runtime"; +import figures from 'figures'; +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'; +// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for marketplace-specific u/r shortcuts and y/n confirmation not in keybinding schema +import { Box, Text, useInput } from '../../ink.js'; +import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js'; +import type { LoadedPlugin } from '../../types/plugin.js'; +import { count } from '../../utils/array.js'; +import { shouldSkipPluginAutoupdate } from '../../utils/config.js'; +import { errorMessage } from '../../utils/errors.js'; +import { clearAllCaches } from '../../utils/plugins/cacheUtils.js'; +import { createPluginId, formatMarketplaceLoadingErrors, getMarketplaceSourceDisplay, loadMarketplacesWithGracefulDegradation } from '../../utils/plugins/marketplaceHelpers.js'; +import { loadKnownMarketplacesConfig, refreshMarketplace, removeMarketplaceSource, setMarketplaceAutoUpdate } from '../../utils/plugins/marketplaceManager.js'; +import { updatePluginsForMarketplaces } from '../../utils/plugins/pluginAutoupdate.js'; +import { loadAllPlugins } from '../../utils/plugins/pluginLoader.js'; +import { isMarketplaceAutoUpdate } from '../../utils/plugins/schemas.js'; +import { getSettingsForSource, updateSettingsForSource } from '../../utils/settings/settings.js'; +import { plural } from '../../utils/stringUtils.js'; +import type { ViewState } from './types.js'; +type Props = { + setViewState: (state: ViewState) => void; + error?: string | null; + setError?: (error: string | null) => void; + setResult: (result: string | null) => void; + exitState: { + pending: boolean; + keyName: 'Ctrl-C' | 'Ctrl-D' | null; + }; + onManageComplete?: () => void | Promise; + targetMarketplace?: string; + action?: 'update' | 'remove'; +}; +type MarketplaceState = { + name: string; + source: string; + lastUpdated?: string; + pluginCount?: number; + installedPlugins?: LoadedPlugin[]; + pendingUpdate?: boolean; + pendingRemove?: boolean; + autoUpdate?: boolean; +}; +type InternalViewState = 'list' | 'details' | 'confirm-remove'; +export function ManageMarketplaces({ + setViewState, + error, + setError, + setResult, + exitState, + onManageComplete, + targetMarketplace, + action +}: Props): React.ReactNode { + const [marketplaceStates, setMarketplaceStates] = useState([]); + const [loading, setLoading] = useState(true); + const [selectedIndex, setSelectedIndex] = useState(0); + const [isProcessing, setIsProcessing] = useState(false); + const [processError, setProcessError] = useState(null); + const [successMessage, setSuccessMessage] = useState(null); + const [progressMessage, setProgressMessage] = useState(null); + const [internalView, setInternalView] = useState('list'); + const [selectedMarketplace, setSelectedMarketplace] = useState(null); + const [detailsMenuIndex, setDetailsMenuIndex] = useState(0); + const hasAttemptedAutoAction = useRef(false); + + // Load marketplaces and their installed plugins + useEffect(() => { + async function loadMarketplaces() { + try { + const config = await loadKnownMarketplacesConfig(); + const { + enabled, + disabled + } = await loadAllPlugins(); + const allPlugins = [...enabled, ...disabled]; + + // Load marketplaces with graceful degradation + const { + marketplaces, + failures + } = await loadMarketplacesWithGracefulDegradation(config); + const states: MarketplaceState[] = []; + for (const { + name, + config: entry, + data: marketplace + } of marketplaces) { + // Get all plugins installed from this marketplace + const installedFromMarketplace = allPlugins.filter(plugin => plugin.source.endsWith(`@${name}`)); + states.push({ + name, + source: getMarketplaceSourceDisplay(entry.source), + lastUpdated: entry.lastUpdated, + pluginCount: marketplace?.plugins.length, + installedPlugins: installedFromMarketplace, + pendingUpdate: false, + pendingRemove: false, + autoUpdate: isMarketplaceAutoUpdate(name, entry) + }); + } + + // Sort: claude-plugin-directory first, then alphabetically + states.sort((a, b) => { + if (a.name === 'claude-plugin-directory') return -1; + if (b.name === 'claude-plugin-directory') return 1; + return a.name.localeCompare(b.name); + }); + setMarketplaceStates(states); + + // Handle marketplace loading errors/warnings + const successCount = count(marketplaces, m => m.data !== null); + const errorResult = formatMarketplaceLoadingErrors(failures, successCount); + if (errorResult) { + if (errorResult.type === 'warning') { + setProcessError(errorResult.message); + } else { + throw new Error(errorResult.message); + } + } + + // Auto-execute if target and action provided + if (targetMarketplace && !hasAttemptedAutoAction.current && !error) { + hasAttemptedAutoAction.current = true; + const targetIndex = states.findIndex(s => s.name === targetMarketplace); + if (targetIndex >= 0) { + const targetState = states[targetIndex]; + if (action) { + // Mark the action as pending and execute + setSelectedIndex(targetIndex + 1); // +1 because "Add Marketplace" is at index 0 + const newStates = [...states]; + if (action === 'update') { + newStates[targetIndex]!.pendingUpdate = true; + } else if (action === 'remove') { + newStates[targetIndex]!.pendingRemove = true; + } + setMarketplaceStates(newStates); + // Apply the change immediately + setTimeout(applyChanges, 100, newStates); + } else if (targetState) { + // No action - just show the details view for this marketplace + setSelectedIndex(targetIndex + 1); // +1 because "Add Marketplace" is at index 0 + setSelectedMarketplace(targetState); + setInternalView('details'); + } + } else if (setError) { + setError(`Marketplace not found: ${targetMarketplace}`); + } + } + } catch (err) { + if (setError) { + setError(err instanceof Error ? err.message : 'Failed to load marketplaces'); + } + setProcessError(err instanceof Error ? err.message : 'Failed to load marketplaces'); + } finally { + setLoading(false); + } + } + void loadMarketplaces(); + // eslint-disable-next-line react-hooks/exhaustive-deps + // biome-ignore lint/correctness/useExhaustiveDependencies: intentional + }, [targetMarketplace, action, error]); + + // Check if there are any pending changes + const hasPendingChanges = () => { + return marketplaceStates.some(state => state.pendingUpdate || state.pendingRemove); + }; + + // Get count of pending operations + const getPendingCounts = () => { + const updateCount = count(marketplaceStates, s => s.pendingUpdate); + const removeCount = count(marketplaceStates, s => s.pendingRemove); + return { + updateCount, + removeCount + }; + }; + + // Apply all pending changes + const applyChanges = async (states?: MarketplaceState[]) => { + const statesToProcess = states || marketplaceStates; + const wasInDetailsView = internalView === 'details'; + setIsProcessing(true); + setProcessError(null); + setSuccessMessage(null); + setProgressMessage(null); + try { + const settings = getSettingsForSource('userSettings'); + let updatedCount = 0; + let removedCount = 0; + const refreshedMarketplaces = new Set(); + for (const state of statesToProcess) { + // Handle remove + if (state.pendingRemove) { + // First uninstall all plugins from this marketplace + if (state.installedPlugins && state.installedPlugins.length > 0) { + const newEnabledPlugins = { + ...settings?.enabledPlugins + }; + for (const plugin of state.installedPlugins) { + const pluginId = createPluginId(plugin.name, state.name); + // Mark as disabled/uninstalled + newEnabledPlugins[pluginId] = false; + } + updateSettingsForSource('userSettings', { + enabledPlugins: newEnabledPlugins + }); + } + + // Then remove the marketplace + await removeMarketplaceSource(state.name); + removedCount++; + logEvent('tengu_marketplace_removed', { + marketplace_name: state.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + plugins_uninstalled: state.installedPlugins?.length || 0 + }); + continue; + } + + // Handle update + if (state.pendingUpdate) { + // Refresh individual marketplace for efficiency with progress reporting + await refreshMarketplace(state.name, (message: string) => { + setProgressMessage(message); + }); + updatedCount++; + refreshedMarketplaces.add(state.name.toLowerCase()); + logEvent('tengu_marketplace_updated', { + marketplace_name: state.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS + }); + } + } + + // After marketplace clones are refreshed, bump installed plugins from + // those marketplaces to the new version. Without this, the loader's + // cache-on-miss (copyPluginToVersionedCache) creates the new version + // dir on the next loadAllPlugins() call, but installed_plugins.json + // stays on the old version — so cleanupOrphanedPluginVersionsInBackground + // stamps the NEW dir with .orphaned_at on the next startup. See #29512. + // updatePluginOp (called inside the helper) is what actually writes + // installed_plugins.json via updateInstallationPathOnDisk. + let updatedPluginCount = 0; + if (refreshedMarketplaces.size > 0) { + const updatedPluginIds = await updatePluginsForMarketplaces(refreshedMarketplaces); + updatedPluginCount = updatedPluginIds.length; + } + + // Clear caches after changes + clearAllCaches(); + + // Call completion callback + if (onManageComplete) { + await onManageComplete(); + } + + // Reload marketplace data to show updated timestamps + const config = await loadKnownMarketplacesConfig(); + const { + enabled, + disabled + } = await loadAllPlugins(); + const allPlugins = [...enabled, ...disabled]; + const { + marketplaces + } = await loadMarketplacesWithGracefulDegradation(config); + const newStates: MarketplaceState[] = []; + for (const { + name, + config: entry, + data: marketplace + } of marketplaces) { + const installedFromMarketplace = allPlugins.filter(plugin => plugin.source.endsWith(`@${name}`)); + newStates.push({ + name, + source: getMarketplaceSourceDisplay(entry.source), + lastUpdated: entry.lastUpdated, + pluginCount: marketplace?.plugins.length, + installedPlugins: installedFromMarketplace, + pendingUpdate: false, + pendingRemove: false, + autoUpdate: isMarketplaceAutoUpdate(name, entry) + }); + } + + // Sort: claude-plugin-directory first, then alphabetically + newStates.sort((a, b) => { + if (a.name === 'claude-plugin-directory') return -1; + if (b.name === 'claude-plugin-directory') return 1; + return a.name.localeCompare(b.name); + }); + setMarketplaceStates(newStates); + + // Update selected marketplace reference with fresh data + if (wasInDetailsView && selectedMarketplace) { + const updatedMarketplace = newStates.find(s => s.name === selectedMarketplace.name); + if (updatedMarketplace) { + setSelectedMarketplace(updatedMarketplace); + } + } + + // Build success message + const actions: string[] = []; + if (updatedCount > 0) { + const pluginPart = updatedPluginCount > 0 ? ` (${updatedPluginCount} ${plural(updatedPluginCount, 'plugin')} bumped)` : ''; + actions.push(`Updated ${updatedCount} ${plural(updatedCount, 'marketplace')}${pluginPart}`); + } + if (removedCount > 0) { + actions.push(`Removed ${removedCount} ${plural(removedCount, 'marketplace')}`); + } + if (actions.length > 0) { + const successMsg = `${figures.tick} ${actions.join(', ')}`; + // If we were in details view, stay there and show success + if (wasInDetailsView) { + setSuccessMessage(successMsg); + } else { + // Otherwise show result and exit to menu + setResult(successMsg); + setTimeout(setViewState, 2000, { + type: 'menu' as const + }); + } + } else if (!wasInDetailsView) { + setViewState({ + type: 'menu' + }); + } + } catch (err) { + const errorMsg = errorMessage(err); + setProcessError(errorMsg); + if (setError) { + setError(errorMsg); + } + } finally { + setIsProcessing(false); + setProgressMessage(null); + } + }; + + // Handle confirming marketplace removal + const confirmRemove = async () => { + if (!selectedMarketplace) return; + + // Mark for removal and apply + const newStates = marketplaceStates.map(state => state.name === selectedMarketplace.name ? { + ...state, + pendingRemove: true + } : state); + setMarketplaceStates(newStates); + await applyChanges(newStates); + }; + + // Build menu options for details view + const buildDetailsMenuOptions = (marketplace: MarketplaceState | null): Array<{ + label: string; + secondaryLabel?: string; + value: string; + }> => { + if (!marketplace) return []; + const options: Array<{ + label: string; + secondaryLabel?: string; + value: string; + }> = [{ + label: `Browse plugins (${marketplace.pluginCount ?? 0})`, + value: 'browse' + }, { + label: 'Update marketplace', + secondaryLabel: marketplace.lastUpdated ? `(last updated ${new Date(marketplace.lastUpdated).toLocaleDateString()})` : undefined, + value: 'update' + }]; + + // Only show auto-update toggle if auto-updater is not globally disabled + if (!shouldSkipPluginAutoupdate()) { + options.push({ + label: marketplace.autoUpdate ? 'Disable auto-update' : 'Enable auto-update', + value: 'toggle-auto-update' + }); + } + options.push({ + label: 'Remove marketplace', + value: 'remove' + }); + return options; + }; + + // Handle toggling auto-update for a marketplace + const handleToggleAutoUpdate = async (marketplace: MarketplaceState) => { + const newAutoUpdate = !marketplace.autoUpdate; + try { + await setMarketplaceAutoUpdate(marketplace.name, newAutoUpdate); + + // Update local state + setMarketplaceStates(prev => prev.map(state => state.name === marketplace.name ? { + ...state, + autoUpdate: newAutoUpdate + } : state)); + + // Update selected marketplace reference + setSelectedMarketplace(prev => prev ? { + ...prev, + autoUpdate: newAutoUpdate + } : prev); + } catch (err) { + setProcessError(err instanceof Error ? err.message : 'Failed to update setting'); + } + }; + + // Escape in details or confirm-remove view - go back to list + useKeybinding('confirm:no', () => { + setInternalView('list'); + setDetailsMenuIndex(0); + }, { + context: 'Confirmation', + isActive: !isProcessing && (internalView === 'details' || internalView === 'confirm-remove') + }); + + // Escape in list view with pending changes - clear pending changes + useKeybinding('confirm:no', () => { + setMarketplaceStates(prev => prev.map(state => ({ + ...state, + pendingUpdate: false, + pendingRemove: false + }))); + setSelectedIndex(0); + }, { + context: 'Confirmation', + isActive: !isProcessing && internalView === 'list' && hasPendingChanges() + }); + + // Escape in list view without pending changes - exit to parent menu + useKeybinding('confirm:no', () => { + setViewState({ + type: 'menu' + }); + }, { + context: 'Confirmation', + isActive: !isProcessing && internalView === 'list' && !hasPendingChanges() + }); + + // List view — navigation (up/down/enter via configurable keybindings) + useKeybindings({ + 'select:previous': () => setSelectedIndex(prev => Math.max(0, prev - 1)), + 'select:next': () => { + const totalItems = marketplaceStates.length + 1; + setSelectedIndex(prev => Math.min(totalItems - 1, prev + 1)); + }, + 'select:accept': () => { + const marketplaceIndex = selectedIndex - 1; + if (selectedIndex === 0) { + setViewState({ + type: 'add-marketplace' + }); + } else if (hasPendingChanges()) { + void applyChanges(); + } else { + const marketplace = marketplaceStates[marketplaceIndex]; + if (marketplace) { + setSelectedMarketplace(marketplace); + setInternalView('details'); + setDetailsMenuIndex(0); + } + } + } + }, { + context: 'Select', + isActive: !isProcessing && internalView === 'list' + }); + + // List view — marketplace-specific actions (u/r shortcuts) + useInput(input => { + const marketplaceIndex = selectedIndex - 1; + if ((input === 'u' || input === 'U') && marketplaceIndex >= 0) { + setMarketplaceStates(prev => prev.map((state, idx) => idx === marketplaceIndex ? { + ...state, + pendingUpdate: !state.pendingUpdate, + pendingRemove: state.pendingUpdate ? state.pendingRemove : false + } : state)); + } else if ((input === 'r' || input === 'R') && marketplaceIndex >= 0) { + const marketplace = marketplaceStates[marketplaceIndex]; + if (marketplace) { + setSelectedMarketplace(marketplace); + setInternalView('confirm-remove'); + } + } + }, { + isActive: !isProcessing && internalView === 'list' + }); + + // Details view — navigation + useKeybindings({ + 'select:previous': () => setDetailsMenuIndex(prev => Math.max(0, prev - 1)), + 'select:next': () => { + const menuOptions = buildDetailsMenuOptions(selectedMarketplace); + setDetailsMenuIndex(prev => Math.min(menuOptions.length - 1, prev + 1)); + }, + 'select:accept': () => { + if (!selectedMarketplace) return; + const menuOptions = buildDetailsMenuOptions(selectedMarketplace); + const selectedOption = menuOptions[detailsMenuIndex]; + if (selectedOption?.value === 'browse') { + setViewState({ + type: 'browse-marketplace', + targetMarketplace: selectedMarketplace.name + }); + } else if (selectedOption?.value === 'update') { + const newStates = marketplaceStates.map(state => state.name === selectedMarketplace.name ? { + ...state, + pendingUpdate: true + } : state); + setMarketplaceStates(newStates); + void applyChanges(newStates); + } else if (selectedOption?.value === 'toggle-auto-update') { + void handleToggleAutoUpdate(selectedMarketplace); + } else if (selectedOption?.value === 'remove') { + setInternalView('confirm-remove'); + } + } + }, { + context: 'Select', + isActive: !isProcessing && internalView === 'details' + }); + + // Confirm-remove view — y/n input + useInput(input => { + if (input === 'y' || input === 'Y') { + void confirmRemove(); + } else if (input === 'n' || input === 'N') { + setInternalView('list'); + setSelectedMarketplace(null); + } + }, { + isActive: !isProcessing && internalView === 'confirm-remove' + }); + if (loading) { + return Loading marketplaces…; + } + if (marketplaceStates.length === 0) { + return + + Manage marketplaces + + + {/* Add Marketplace option */} + + {figures.pointer} + + + Add Marketplace + + + + + + {exitState.pending ? <>Press {exitState.keyName} again to go back : + + + } + + + ; + } + + // Show confirmation dialog + if (internalView === 'confirm-remove' && selectedMarketplace) { + const pluginCount = selectedMarketplace.installedPlugins?.length || 0; + return + + Remove marketplace {selectedMarketplace.name}? + + + {pluginCount > 0 && + + This will also uninstall {pluginCount}{' '} + {plural(pluginCount, 'plugin')} from this marketplace: + + } + {selectedMarketplace.installedPlugins && selectedMarketplace.installedPlugins.length > 0 && + {selectedMarketplace.installedPlugins.map(plugin => + • {plugin.name} + )} + } + + + Press y to confirm or n to + cancel + + + + ; + } + + // Show marketplace details + if (internalView === 'details' && selectedMarketplace) { + // Check if this marketplace is currently being processed + // Check pendingUpdate first so we show updating state immediately when user presses Enter + const isUpdating = selectedMarketplace.pendingUpdate || isProcessing; + const menuOptions = buildDetailsMenuOptions(selectedMarketplace); + return + {selectedMarketplace.name} + {selectedMarketplace.source} + + + {selectedMarketplace.pluginCount || 0} available{' '} + {plural(selectedMarketplace.pluginCount || 0, 'plugin')} + + + + {/* Installed plugins section */} + {selectedMarketplace.installedPlugins && selectedMarketplace.installedPlugins.length > 0 && + + Installed plugins ({selectedMarketplace.installedPlugins.length} + ): + + + {selectedMarketplace.installedPlugins.map(plugin => + {figures.bullet} + + {plugin.name} + {plugin.manifest.description} + + )} + + } + + {/* Processing indicator */} + {isUpdating && + Updating marketplace… + {progressMessage && {progressMessage}} + } + + {/* Success message */} + {!isUpdating && successMessage && + {successMessage} + } + + {/* Error message */} + {!isUpdating && processError && + {processError} + } + + {/* Menu options */} + {!isUpdating && + {menuOptions.map((option, idx) => { + if (!option) return null; + const isSelected = idx === detailsMenuIndex; + return + + {isSelected ? figures.pointer : ' '} {option.label} + + {option.secondaryLabel && {option.secondaryLabel}} + ; + })} + } + + {/* Show explanatory text at the bottom when auto-update is enabled */} + {!isUpdating && !shouldSkipPluginAutoupdate() && selectedMarketplace.autoUpdate && + + Auto-update enabled. Claude Code will automatically update this + marketplace and its installed plugins. + + } + + + + {isUpdating ? <>Please wait… : + + + } + + + ; + } + + // Show marketplace list + const { + updateCount, + removeCount + } = getPendingCounts(); + return + + Manage marketplaces + + + {/* Add Marketplace option */} + + + {selectedIndex === 0 ? figures.pointer : ' '} + + + + Add Marketplace + + + + {/* Marketplace list */} + + {marketplaceStates.map((state, idx) => { + const isSelected = idx + 1 === selectedIndex; // +1 because Add Marketplace is at index 0 + + // Build status indicators + const indicators: string[] = []; + if (state.pendingUpdate) indicators.push('UPDATE'); + if (state.pendingRemove) indicators.push('REMOVE'); + return + + {isSelected ? figures.pointer : ' '}{' '} + {state.pendingRemove ? figures.cross : figures.bullet} + + + + + {state.name === 'claude-plugins-official' && ✻ } + {state.name} + {state.name === 'claude-plugins-official' && ✻} + + {indicators.length > 0 && [{indicators.join(', ')}]} + + {state.source} + + {state.pluginCount !== undefined && <>{state.pluginCount} available} + {state.installedPlugins && state.installedPlugins.length > 0 && <> • {state.installedPlugins.length} installed} + {state.lastUpdated && <> + {' '} + • Updated{' '} + {new Date(state.lastUpdated).toLocaleDateString()} + } + + + ; + })} + + + {/* Pending changes summary */} + {hasPendingChanges() && + + Pending changes:{' '} + Enter to apply + + {updateCount > 0 && + • Update {updateCount} {plural(updateCount, 'marketplace')} + } + {removeCount > 0 && + • Remove {removeCount} {plural(removeCount, 'marketplace')} + } + } + + {/* Processing indicator */} + {isProcessing && + Processing changes… + } + + {/* Error display */} + {processError && + {processError} + } + + + ; +} +type ManageMarketplacesKeyHintsProps = { + exitState: Props['exitState']; + hasPendingActions: boolean; +}; +function ManageMarketplacesKeyHints(t0) { + const $ = _c(18); + const { + exitState, + hasPendingActions + } = t0; + if (exitState.pending) { + let t1; + if ($[0] !== exitState.keyName) { + t1 = Press {exitState.keyName} again to go back; + $[0] = exitState.keyName; + $[1] = t1; + } else { + t1 = $[1]; + } + return t1; + } + let t1; + if ($[2] !== hasPendingActions) { + t1 = hasPendingActions && ; + $[2] = hasPendingActions; + $[3] = t1; + } else { + t1 = $[3]; + } + let t2; + if ($[4] !== hasPendingActions) { + t2 = !hasPendingActions && ; + $[4] = hasPendingActions; + $[5] = t2; + } else { + t2 = $[5]; + } + let t3; + if ($[6] !== hasPendingActions) { + t3 = !hasPendingActions && ; + $[6] = hasPendingActions; + $[7] = t3; + } else { + t3 = $[7]; + } + let t4; + if ($[8] !== hasPendingActions) { + t4 = !hasPendingActions && ; + $[8] = hasPendingActions; + $[9] = t4; + } else { + t4 = $[9]; + } + const t5 = hasPendingActions ? "cancel" : "go back"; + let t6; + if ($[10] !== t5) { + t6 = ; + $[10] = t5; + $[11] = t6; + } else { + t6 = $[11]; + } + let t7; + if ($[12] !== t1 || $[13] !== t2 || $[14] !== t3 || $[15] !== t4 || $[16] !== t6) { + t7 = {t1}{t2}{t3}{t4}{t6}; + $[12] = t1; + $[13] = t2; + $[14] = t3; + $[15] = t4; + $[16] = t6; + $[17] = t7; + } else { + t7 = $[17]; + } + return t7; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useEffect","useRef","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","ConfigurableShortcutHint","Byline","KeyboardShortcutHint","Box","Text","useInput","useKeybinding","useKeybindings","LoadedPlugin","count","shouldSkipPluginAutoupdate","errorMessage","clearAllCaches","createPluginId","formatMarketplaceLoadingErrors","getMarketplaceSourceDisplay","loadMarketplacesWithGracefulDegradation","loadKnownMarketplacesConfig","refreshMarketplace","removeMarketplaceSource","setMarketplaceAutoUpdate","updatePluginsForMarketplaces","loadAllPlugins","isMarketplaceAutoUpdate","getSettingsForSource","updateSettingsForSource","plural","ViewState","Props","setViewState","state","error","setError","setResult","result","exitState","pending","keyName","onManageComplete","Promise","targetMarketplace","action","MarketplaceState","name","source","lastUpdated","pluginCount","installedPlugins","pendingUpdate","pendingRemove","autoUpdate","InternalViewState","ManageMarketplaces","ReactNode","marketplaceStates","setMarketplaceStates","loading","setLoading","selectedIndex","setSelectedIndex","isProcessing","setIsProcessing","processError","setProcessError","successMessage","setSuccessMessage","progressMessage","setProgressMessage","internalView","setInternalView","selectedMarketplace","setSelectedMarketplace","detailsMenuIndex","setDetailsMenuIndex","hasAttemptedAutoAction","loadMarketplaces","config","enabled","disabled","allPlugins","marketplaces","failures","states","entry","data","marketplace","installedFromMarketplace","filter","plugin","endsWith","push","plugins","length","sort","a","b","localeCompare","successCount","m","errorResult","type","message","Error","current","targetIndex","findIndex","s","targetState","newStates","setTimeout","applyChanges","err","hasPendingChanges","some","getPendingCounts","updateCount","removeCount","statesToProcess","wasInDetailsView","settings","updatedCount","removedCount","refreshedMarketplaces","Set","newEnabledPlugins","enabledPlugins","pluginId","marketplace_name","plugins_uninstalled","add","toLowerCase","updatedPluginCount","size","updatedPluginIds","updatedMarketplace","find","actions","pluginPart","successMsg","tick","join","const","errorMsg","confirmRemove","map","buildDetailsMenuOptions","Array","label","secondaryLabel","value","options","Date","toLocaleDateString","undefined","handleToggleAutoUpdate","newAutoUpdate","prev","context","isActive","select:previous","Math","max","select:next","totalItems","min","select:accept","marketplaceIndex","input","idx","menuOptions","selectedOption","pointer","isUpdating","bullet","manifest","description","option","isSelected","indicators","cross","ManageMarketplacesKeyHintsProps","hasPendingActions","ManageMarketplacesKeyHints","t0","$","_c","t1","t2","t3","t4","t5","t6","t7"],"sources":["ManageMarketplaces.tsx"],"sourcesContent":["import figures from 'figures'\nimport * 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'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for marketplace-specific u/r shortcuts and y/n confirmation not in keybinding schema\nimport { Box, Text, useInput } from '../../ink.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport type { LoadedPlugin } from '../../types/plugin.js'\nimport { count } from '../../utils/array.js'\nimport { shouldSkipPluginAutoupdate } from '../../utils/config.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport {\n  createPluginId,\n  formatMarketplaceLoadingErrors,\n  getMarketplaceSourceDisplay,\n  loadMarketplacesWithGracefulDegradation,\n} from '../../utils/plugins/marketplaceHelpers.js'\nimport {\n  loadKnownMarketplacesConfig,\n  refreshMarketplace,\n  removeMarketplaceSource,\n  setMarketplaceAutoUpdate,\n} from '../../utils/plugins/marketplaceManager.js'\nimport { updatePluginsForMarketplaces } from '../../utils/plugins/pluginAutoupdate.js'\nimport { loadAllPlugins } from '../../utils/plugins/pluginLoader.js'\nimport { isMarketplaceAutoUpdate } from '../../utils/plugins/schemas.js'\nimport {\n  getSettingsForSource,\n  updateSettingsForSource,\n} from '../../utils/settings/settings.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport type { ViewState } from './types.js'\n\ntype Props = {\n  setViewState: (state: ViewState) => void\n  error?: string | null\n  setError?: (error: string | null) => void\n  setResult: (result: string | null) => void\n  exitState: {\n    pending: boolean\n    keyName: 'Ctrl-C' | 'Ctrl-D' | null\n  }\n  onManageComplete?: () => void | Promise<void>\n  targetMarketplace?: string\n  action?: 'update' | 'remove'\n}\n\ntype MarketplaceState = {\n  name: string\n  source: string\n  lastUpdated?: string\n  pluginCount?: number\n  installedPlugins?: LoadedPlugin[]\n  pendingUpdate?: boolean\n  pendingRemove?: boolean\n  autoUpdate?: boolean\n}\n\ntype InternalViewState = 'list' | 'details' | 'confirm-remove'\n\nexport function ManageMarketplaces({\n  setViewState,\n  error,\n  setError,\n  setResult,\n  exitState,\n  onManageComplete,\n  targetMarketplace,\n  action,\n}: Props): React.ReactNode {\n  const [marketplaceStates, setMarketplaceStates] = useState<\n    MarketplaceState[]\n  >([])\n  const [loading, setLoading] = useState(true)\n  const [selectedIndex, setSelectedIndex] = useState(0)\n  const [isProcessing, setIsProcessing] = useState(false)\n  const [processError, setProcessError] = useState<string | null>(null)\n  const [successMessage, setSuccessMessage] = useState<string | null>(null)\n  const [progressMessage, setProgressMessage] = useState<string | null>(null)\n  const [internalView, setInternalView] = useState<InternalViewState>('list')\n  const [selectedMarketplace, setSelectedMarketplace] =\n    useState<MarketplaceState | null>(null)\n  const [detailsMenuIndex, setDetailsMenuIndex] = useState(0)\n  const hasAttemptedAutoAction = useRef(false)\n\n  // Load marketplaces and their installed plugins\n  useEffect(() => {\n    async function loadMarketplaces() {\n      try {\n        const config = await loadKnownMarketplacesConfig()\n        const { enabled, disabled } = await loadAllPlugins()\n        const allPlugins = [...enabled, ...disabled]\n\n        // Load marketplaces with graceful degradation\n        const { marketplaces, failures } =\n          await loadMarketplacesWithGracefulDegradation(config)\n\n        const states: MarketplaceState[] = []\n        for (const { name, config: entry, data: marketplace } of marketplaces) {\n          // Get all plugins installed from this marketplace\n          const installedFromMarketplace = allPlugins.filter(plugin =>\n            plugin.source.endsWith(`@${name}`),\n          )\n\n          states.push({\n            name,\n            source: getMarketplaceSourceDisplay(entry.source),\n            lastUpdated: entry.lastUpdated,\n            pluginCount: marketplace?.plugins.length,\n            installedPlugins: installedFromMarketplace,\n            pendingUpdate: false,\n            pendingRemove: false,\n            autoUpdate: isMarketplaceAutoUpdate(name, entry),\n          })\n        }\n\n        // Sort: claude-plugin-directory first, then alphabetically\n        states.sort((a, b) => {\n          if (a.name === 'claude-plugin-directory') return -1\n          if (b.name === 'claude-plugin-directory') return 1\n          return a.name.localeCompare(b.name)\n        })\n        setMarketplaceStates(states)\n\n        // Handle marketplace loading errors/warnings\n        const successCount = count(marketplaces, m => m.data !== null)\n        const errorResult = formatMarketplaceLoadingErrors(\n          failures,\n          successCount,\n        )\n        if (errorResult) {\n          if (errorResult.type === 'warning') {\n            setProcessError(errorResult.message)\n          } else {\n            throw new Error(errorResult.message)\n          }\n        }\n\n        // Auto-execute if target and action provided\n        if (targetMarketplace && !hasAttemptedAutoAction.current && !error) {\n          hasAttemptedAutoAction.current = true\n          const targetIndex = states.findIndex(\n            s => s.name === targetMarketplace,\n          )\n          if (targetIndex >= 0) {\n            const targetState = states[targetIndex]\n            if (action) {\n              // Mark the action as pending and execute\n              setSelectedIndex(targetIndex + 1) // +1 because \"Add Marketplace\" is at index 0\n              const newStates = [...states]\n              if (action === 'update') {\n                newStates[targetIndex]!.pendingUpdate = true\n              } else if (action === 'remove') {\n                newStates[targetIndex]!.pendingRemove = true\n              }\n              setMarketplaceStates(newStates)\n              // Apply the change immediately\n              setTimeout(applyChanges, 100, newStates)\n            } else if (targetState) {\n              // No action - just show the details view for this marketplace\n              setSelectedIndex(targetIndex + 1) // +1 because \"Add Marketplace\" is at index 0\n              setSelectedMarketplace(targetState)\n              setInternalView('details')\n            }\n          } else if (setError) {\n            setError(`Marketplace not found: ${targetMarketplace}`)\n          }\n        }\n      } catch (err) {\n        if (setError) {\n          setError(\n            err instanceof Error ? err.message : 'Failed to load marketplaces',\n          )\n        }\n        setProcessError(\n          err instanceof Error ? err.message : 'Failed to load marketplaces',\n        )\n      } finally {\n        setLoading(false)\n      }\n    }\n    void loadMarketplaces()\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  }, [targetMarketplace, action, error])\n\n  // Check if there are any pending changes\n  const hasPendingChanges = () => {\n    return marketplaceStates.some(\n      state => state.pendingUpdate || state.pendingRemove,\n    )\n  }\n\n  // Get count of pending operations\n  const getPendingCounts = () => {\n    const updateCount = count(marketplaceStates, s => s.pendingUpdate)\n    const removeCount = count(marketplaceStates, s => s.pendingRemove)\n    return { updateCount, removeCount }\n  }\n\n  // Apply all pending changes\n  const applyChanges = async (states?: MarketplaceState[]) => {\n    const statesToProcess = states || marketplaceStates\n    const wasInDetailsView = internalView === 'details'\n    setIsProcessing(true)\n    setProcessError(null)\n    setSuccessMessage(null)\n    setProgressMessage(null)\n\n    try {\n      const settings = getSettingsForSource('userSettings')\n      let updatedCount = 0\n      let removedCount = 0\n      const refreshedMarketplaces = new Set<string>()\n\n      for (const state of statesToProcess) {\n        // Handle remove\n        if (state.pendingRemove) {\n          // First uninstall all plugins from this marketplace\n          if (state.installedPlugins && state.installedPlugins.length > 0) {\n            const newEnabledPlugins = { ...settings?.enabledPlugins }\n            for (const plugin of state.installedPlugins) {\n              const pluginId = createPluginId(plugin.name, state.name)\n              // Mark as disabled/uninstalled\n              newEnabledPlugins[pluginId] = false\n            }\n            updateSettingsForSource('userSettings', {\n              enabledPlugins: newEnabledPlugins,\n            })\n          }\n\n          // Then remove the marketplace\n          await removeMarketplaceSource(state.name)\n          removedCount++\n\n          logEvent('tengu_marketplace_removed', {\n            marketplace_name:\n              state.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            plugins_uninstalled: state.installedPlugins?.length || 0,\n          })\n          continue\n        }\n\n        // Handle update\n        if (state.pendingUpdate) {\n          // Refresh individual marketplace for efficiency with progress reporting\n          await refreshMarketplace(state.name, (message: string) => {\n            setProgressMessage(message)\n          })\n          updatedCount++\n          refreshedMarketplaces.add(state.name.toLowerCase())\n\n          logEvent('tengu_marketplace_updated', {\n            marketplace_name:\n              state.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n        }\n      }\n\n      // After marketplace clones are refreshed, bump installed plugins from\n      // those marketplaces to the new version. Without this, the loader's\n      // cache-on-miss (copyPluginToVersionedCache) creates the new version\n      // dir on the next loadAllPlugins() call, but installed_plugins.json\n      // stays on the old version — so cleanupOrphanedPluginVersionsInBackground\n      // stamps the NEW dir with .orphaned_at on the next startup. See #29512.\n      // updatePluginOp (called inside the helper) is what actually writes\n      // installed_plugins.json via updateInstallationPathOnDisk.\n      let updatedPluginCount = 0\n      if (refreshedMarketplaces.size > 0) {\n        const updatedPluginIds = await updatePluginsForMarketplaces(\n          refreshedMarketplaces,\n        )\n        updatedPluginCount = updatedPluginIds.length\n      }\n\n      // Clear caches after changes\n      clearAllCaches()\n\n      // Call completion callback\n      if (onManageComplete) {\n        await onManageComplete()\n      }\n\n      // Reload marketplace data to show updated timestamps\n      const config = await loadKnownMarketplacesConfig()\n      const { enabled, disabled } = await loadAllPlugins()\n      const allPlugins = [...enabled, ...disabled]\n\n      const { marketplaces } =\n        await loadMarketplacesWithGracefulDegradation(config)\n\n      const newStates: MarketplaceState[] = []\n      for (const { name, config: entry, data: marketplace } of marketplaces) {\n        const installedFromMarketplace = allPlugins.filter(plugin =>\n          plugin.source.endsWith(`@${name}`),\n        )\n\n        newStates.push({\n          name,\n          source: getMarketplaceSourceDisplay(entry.source),\n          lastUpdated: entry.lastUpdated,\n          pluginCount: marketplace?.plugins.length,\n          installedPlugins: installedFromMarketplace,\n          pendingUpdate: false,\n          pendingRemove: false,\n          autoUpdate: isMarketplaceAutoUpdate(name, entry),\n        })\n      }\n\n      // Sort: claude-plugin-directory first, then alphabetically\n      newStates.sort((a, b) => {\n        if (a.name === 'claude-plugin-directory') return -1\n        if (b.name === 'claude-plugin-directory') return 1\n        return a.name.localeCompare(b.name)\n      })\n      setMarketplaceStates(newStates)\n\n      // Update selected marketplace reference with fresh data\n      if (wasInDetailsView && selectedMarketplace) {\n        const updatedMarketplace = newStates.find(\n          s => s.name === selectedMarketplace.name,\n        )\n        if (updatedMarketplace) {\n          setSelectedMarketplace(updatedMarketplace)\n        }\n      }\n\n      // Build success message\n      const actions: string[] = []\n      if (updatedCount > 0) {\n        const pluginPart =\n          updatedPluginCount > 0\n            ? ` (${updatedPluginCount} ${plural(updatedPluginCount, 'plugin')} bumped)`\n            : ''\n        actions.push(\n          `Updated ${updatedCount} ${plural(updatedCount, 'marketplace')}${pluginPart}`,\n        )\n      }\n      if (removedCount > 0) {\n        actions.push(\n          `Removed ${removedCount} ${plural(removedCount, 'marketplace')}`,\n        )\n      }\n\n      if (actions.length > 0) {\n        const successMsg = `${figures.tick} ${actions.join(', ')}`\n        // If we were in details view, stay there and show success\n        if (wasInDetailsView) {\n          setSuccessMessage(successMsg)\n        } else {\n          // Otherwise show result and exit to menu\n          setResult(successMsg)\n          setTimeout(setViewState, 2000, { type: 'menu' as const })\n        }\n      } else if (!wasInDetailsView) {\n        setViewState({ type: 'menu' })\n      }\n    } catch (err) {\n      const errorMsg = errorMessage(err)\n      setProcessError(errorMsg)\n      if (setError) {\n        setError(errorMsg)\n      }\n    } finally {\n      setIsProcessing(false)\n      setProgressMessage(null)\n    }\n  }\n\n  // Handle confirming marketplace removal\n  const confirmRemove = async () => {\n    if (!selectedMarketplace) return\n\n    // Mark for removal and apply\n    const newStates = marketplaceStates.map(state =>\n      state.name === selectedMarketplace.name\n        ? { ...state, pendingRemove: true }\n        : state,\n    )\n    setMarketplaceStates(newStates)\n    await applyChanges(newStates)\n  }\n\n  // Build menu options for details view\n  const buildDetailsMenuOptions = (\n    marketplace: MarketplaceState | null,\n  ): Array<{ label: string; secondaryLabel?: string; value: string }> => {\n    if (!marketplace) return []\n\n    const options: Array<{\n      label: string\n      secondaryLabel?: string\n      value: string\n    }> = [\n      {\n        label: `Browse plugins (${marketplace.pluginCount ?? 0})`,\n        value: 'browse',\n      },\n      {\n        label: 'Update marketplace',\n        secondaryLabel: marketplace.lastUpdated\n          ? `(last updated ${new Date(marketplace.lastUpdated).toLocaleDateString()})`\n          : undefined,\n        value: 'update',\n      },\n    ]\n\n    // Only show auto-update toggle if auto-updater is not globally disabled\n    if (!shouldSkipPluginAutoupdate()) {\n      options.push({\n        label: marketplace.autoUpdate\n          ? 'Disable auto-update'\n          : 'Enable auto-update',\n        value: 'toggle-auto-update',\n      })\n    }\n\n    options.push({ label: 'Remove marketplace', value: 'remove' })\n\n    return options\n  }\n\n  // Handle toggling auto-update for a marketplace\n  const handleToggleAutoUpdate = async (marketplace: MarketplaceState) => {\n    const newAutoUpdate = !marketplace.autoUpdate\n    try {\n      await setMarketplaceAutoUpdate(marketplace.name, newAutoUpdate)\n\n      // Update local state\n      setMarketplaceStates(prev =>\n        prev.map(state =>\n          state.name === marketplace.name\n            ? { ...state, autoUpdate: newAutoUpdate }\n            : state,\n        ),\n      )\n\n      // Update selected marketplace reference\n      setSelectedMarketplace(prev =>\n        prev ? { ...prev, autoUpdate: newAutoUpdate } : prev,\n      )\n    } catch (err) {\n      setProcessError(\n        err instanceof Error ? err.message : 'Failed to update setting',\n      )\n    }\n  }\n\n  // Escape in details or confirm-remove view - go back to list\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setInternalView('list')\n      setDetailsMenuIndex(0)\n    },\n    {\n      context: 'Confirmation',\n      isActive:\n        !isProcessing &&\n        (internalView === 'details' || internalView === 'confirm-remove'),\n    },\n  )\n\n  // Escape in list view with pending changes - clear pending changes\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setMarketplaceStates(prev =>\n        prev.map(state => ({\n          ...state,\n          pendingUpdate: false,\n          pendingRemove: false,\n        })),\n      )\n      setSelectedIndex(0)\n    },\n    {\n      context: 'Confirmation',\n      isActive: !isProcessing && internalView === 'list' && hasPendingChanges(),\n    },\n  )\n\n  // Escape in list view without pending changes - exit to parent menu\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setViewState({ type: 'menu' })\n    },\n    {\n      context: 'Confirmation',\n      isActive:\n        !isProcessing && internalView === 'list' && !hasPendingChanges(),\n    },\n  )\n\n  // List view — navigation (up/down/enter via configurable keybindings)\n  useKeybindings(\n    {\n      'select:previous': () => setSelectedIndex(prev => Math.max(0, prev - 1)),\n      'select:next': () => {\n        const totalItems = marketplaceStates.length + 1\n        setSelectedIndex(prev => Math.min(totalItems - 1, prev + 1))\n      },\n      'select:accept': () => {\n        const marketplaceIndex = selectedIndex - 1\n        if (selectedIndex === 0) {\n          setViewState({ type: 'add-marketplace' })\n        } else if (hasPendingChanges()) {\n          void applyChanges()\n        } else {\n          const marketplace = marketplaceStates[marketplaceIndex]\n          if (marketplace) {\n            setSelectedMarketplace(marketplace)\n            setInternalView('details')\n            setDetailsMenuIndex(0)\n          }\n        }\n      },\n    },\n    { context: 'Select', isActive: !isProcessing && internalView === 'list' },\n  )\n\n  // List view — marketplace-specific actions (u/r shortcuts)\n  useInput(\n    input => {\n      const marketplaceIndex = selectedIndex - 1\n      if ((input === 'u' || input === 'U') && marketplaceIndex >= 0) {\n        setMarketplaceStates(prev =>\n          prev.map((state, idx) =>\n            idx === marketplaceIndex\n              ? {\n                  ...state,\n                  pendingUpdate: !state.pendingUpdate,\n                  pendingRemove: state.pendingUpdate\n                    ? state.pendingRemove\n                    : false,\n                }\n              : state,\n          ),\n        )\n      } else if ((input === 'r' || input === 'R') && marketplaceIndex >= 0) {\n        const marketplace = marketplaceStates[marketplaceIndex]\n        if (marketplace) {\n          setSelectedMarketplace(marketplace)\n          setInternalView('confirm-remove')\n        }\n      }\n    },\n    { isActive: !isProcessing && internalView === 'list' },\n  )\n\n  // Details view — navigation\n  useKeybindings(\n    {\n      'select:previous': () =>\n        setDetailsMenuIndex(prev => Math.max(0, prev - 1)),\n      'select:next': () => {\n        const menuOptions = buildDetailsMenuOptions(selectedMarketplace)\n        setDetailsMenuIndex(prev => Math.min(menuOptions.length - 1, prev + 1))\n      },\n      'select:accept': () => {\n        if (!selectedMarketplace) return\n        const menuOptions = buildDetailsMenuOptions(selectedMarketplace)\n        const selectedOption = menuOptions[detailsMenuIndex]\n        if (selectedOption?.value === 'browse') {\n          setViewState({\n            type: 'browse-marketplace',\n            targetMarketplace: selectedMarketplace.name,\n          })\n        } else if (selectedOption?.value === 'update') {\n          const newStates = marketplaceStates.map(state =>\n            state.name === selectedMarketplace.name\n              ? { ...state, pendingUpdate: true }\n              : state,\n          )\n          setMarketplaceStates(newStates)\n          void applyChanges(newStates)\n        } else if (selectedOption?.value === 'toggle-auto-update') {\n          void handleToggleAutoUpdate(selectedMarketplace)\n        } else if (selectedOption?.value === 'remove') {\n          setInternalView('confirm-remove')\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive: !isProcessing && internalView === 'details',\n    },\n  )\n\n  // Confirm-remove view — y/n input\n  useInput(\n    input => {\n      if (input === 'y' || input === 'Y') {\n        void confirmRemove()\n      } else if (input === 'n' || input === 'N') {\n        setInternalView('list')\n        setSelectedMarketplace(null)\n      }\n    },\n    { isActive: !isProcessing && internalView === 'confirm-remove' },\n  )\n\n  if (loading) {\n    return <Text>Loading marketplaces…</Text>\n  }\n\n  if (marketplaceStates.length === 0) {\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Manage marketplaces</Text>\n        </Box>\n\n        {/* Add Marketplace option */}\n        <Box flexDirection=\"row\" gap={1}>\n          <Text color=\"suggestion\">{figures.pointer} +</Text>\n          <Text bold color=\"suggestion\">\n            Add Marketplace\n          </Text>\n        </Box>\n\n        <Box marginLeft={3}>\n          <Text dimColor italic>\n            {exitState.pending ? (\n              <>Press {exitState.keyName} again to go back</>\n            ) : (\n              <Byline>\n                <ConfigurableShortcutHint\n                  action=\"select:accept\"\n                  context=\"Select\"\n                  fallback=\"Enter\"\n                  description=\"select\"\n                />\n                <ConfigurableShortcutHint\n                  action=\"confirm:no\"\n                  context=\"Confirmation\"\n                  fallback=\"Esc\"\n                  description=\"go back\"\n                />\n              </Byline>\n            )}\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Show confirmation dialog\n  if (internalView === 'confirm-remove' && selectedMarketplace) {\n    const pluginCount = selectedMarketplace.installedPlugins?.length || 0\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold color=\"warning\">\n          Remove marketplace <Text italic>{selectedMarketplace.name}</Text>?\n        </Text>\n        <Box flexDirection=\"column\">\n          {pluginCount > 0 && (\n            <Box marginTop={1}>\n              <Text color=\"warning\">\n                This will also uninstall {pluginCount}{' '}\n                {plural(pluginCount, 'plugin')} from this marketplace:\n              </Text>\n            </Box>\n          )}\n          {selectedMarketplace.installedPlugins &&\n            selectedMarketplace.installedPlugins.length > 0 && (\n              <Box flexDirection=\"column\" marginTop={1} marginLeft={2}>\n                {selectedMarketplace.installedPlugins.map(plugin => (\n                  <Text key={plugin.name} dimColor>\n                    • {plugin.name}\n                  </Text>\n                ))}\n              </Box>\n            )}\n          <Box marginTop={1}>\n            <Text>\n              Press <Text bold>y</Text> to confirm or <Text bold>n</Text> to\n              cancel\n            </Text>\n          </Box>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Show marketplace details\n  if (internalView === 'details' && selectedMarketplace) {\n    // Check if this marketplace is currently being processed\n    // Check pendingUpdate first so we show updating state immediately when user presses Enter\n    const isUpdating = selectedMarketplace.pendingUpdate || isProcessing\n\n    const menuOptions = buildDetailsMenuOptions(selectedMarketplace)\n\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>{selectedMarketplace.name}</Text>\n        <Text dimColor>{selectedMarketplace.source}</Text>\n        <Box marginTop={1}>\n          <Text>\n            {selectedMarketplace.pluginCount || 0} available{' '}\n            {plural(selectedMarketplace.pluginCount || 0, 'plugin')}\n          </Text>\n        </Box>\n\n        {/* Installed plugins section */}\n        {selectedMarketplace.installedPlugins &&\n          selectedMarketplace.installedPlugins.length > 0 && (\n            <Box flexDirection=\"column\" marginTop={1}>\n              <Text bold>\n                Installed plugins ({selectedMarketplace.installedPlugins.length}\n                ):\n              </Text>\n              <Box flexDirection=\"column\" marginLeft={1}>\n                {selectedMarketplace.installedPlugins.map(plugin => (\n                  <Box key={plugin.name} flexDirection=\"row\" gap={1}>\n                    <Text>{figures.bullet}</Text>\n                    <Box flexDirection=\"column\">\n                      <Text>{plugin.name}</Text>\n                      <Text dimColor>{plugin.manifest.description}</Text>\n                    </Box>\n                  </Box>\n                ))}\n              </Box>\n            </Box>\n          )}\n\n        {/* Processing indicator */}\n        {isUpdating && (\n          <Box marginTop={1} flexDirection=\"column\">\n            <Text color=\"claude\">Updating marketplace…</Text>\n            {progressMessage && <Text dimColor>{progressMessage}</Text>}\n          </Box>\n        )}\n\n        {/* Success message */}\n        {!isUpdating && successMessage && (\n          <Box marginTop={1}>\n            <Text color=\"claude\">{successMessage}</Text>\n          </Box>\n        )}\n\n        {/* Error message */}\n        {!isUpdating && processError && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{processError}</Text>\n          </Box>\n        )}\n\n        {/* Menu options */}\n        {!isUpdating && (\n          <Box flexDirection=\"column\" marginTop={1}>\n            {menuOptions.map((option, idx) => {\n              if (!option) return null\n              const isSelected = idx === detailsMenuIndex\n              return (\n                <Box key={option.value}>\n                  <Text color={isSelected ? 'suggestion' : undefined}>\n                    {isSelected ? figures.pointer : ' '} {option.label}\n                  </Text>\n                  {option.secondaryLabel && (\n                    <Text dimColor> {option.secondaryLabel}</Text>\n                  )}\n                </Box>\n              )\n            })}\n          </Box>\n        )}\n\n        {/* Show explanatory text at the bottom when auto-update is enabled */}\n        {!isUpdating &&\n          !shouldSkipPluginAutoupdate() &&\n          selectedMarketplace.autoUpdate && (\n            <Box marginTop={1}>\n              <Text dimColor>\n                Auto-update enabled. Claude Code will automatically update this\n                marketplace and its installed plugins.\n              </Text>\n            </Box>\n          )}\n\n        <Box marginLeft={3}>\n          <Text dimColor italic>\n            {isUpdating ? (\n              <>Please wait…</>\n            ) : (\n              <Byline>\n                <ConfigurableShortcutHint\n                  action=\"select:accept\"\n                  context=\"Select\"\n                  fallback=\"Enter\"\n                  description=\"select\"\n                />\n                <ConfigurableShortcutHint\n                  action=\"confirm:no\"\n                  context=\"Confirmation\"\n                  fallback=\"Esc\"\n                  description=\"go back\"\n                />\n              </Byline>\n            )}\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Show marketplace list\n  const { updateCount, removeCount } = getPendingCounts()\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box marginBottom={1}>\n        <Text bold>Manage marketplaces</Text>\n      </Box>\n\n      {/* Add Marketplace option */}\n      <Box flexDirection=\"row\" gap={1} marginBottom={1}>\n        <Text color={selectedIndex === 0 ? 'suggestion' : undefined}>\n          {selectedIndex === 0 ? figures.pointer : ' '} +\n        </Text>\n        <Text bold color={selectedIndex === 0 ? 'suggestion' : undefined}>\n          Add Marketplace\n        </Text>\n      </Box>\n\n      {/* Marketplace list */}\n      <Box flexDirection=\"column\">\n        {marketplaceStates.map((state, idx) => {\n          const isSelected = idx + 1 === selectedIndex // +1 because Add Marketplace is at index 0\n\n          // Build status indicators\n          const indicators: string[] = []\n          if (state.pendingUpdate) indicators.push('UPDATE')\n          if (state.pendingRemove) indicators.push('REMOVE')\n\n          return (\n            <Box key={state.name} flexDirection=\"row\" gap={1} marginBottom={1}>\n              <Text color={isSelected ? 'suggestion' : undefined}>\n                {isSelected ? figures.pointer : ' '}{' '}\n                {state.pendingRemove ? figures.cross : figures.bullet}\n              </Text>\n              <Box flexDirection=\"column\" flexGrow={1}>\n                <Box flexDirection=\"row\" gap={1}>\n                  <Text\n                    bold\n                    strikethrough={state.pendingRemove}\n                    dimColor={state.pendingRemove}\n                  >\n                    {state.name === 'claude-plugins-official' && (\n                      <Text color=\"claude\">✻ </Text>\n                    )}\n                    {state.name}\n                    {state.name === 'claude-plugins-official' && (\n                      <Text color=\"claude\"> ✻</Text>\n                    )}\n                  </Text>\n                  {indicators.length > 0 && (\n                    <Text color=\"warning\">[{indicators.join(', ')}]</Text>\n                  )}\n                </Box>\n                <Text dimColor>{state.source}</Text>\n                <Text dimColor>\n                  {state.pluginCount !== undefined && (\n                    <>{state.pluginCount} available</>\n                  )}\n                  {state.installedPlugins &&\n                    state.installedPlugins.length > 0 && (\n                      <> • {state.installedPlugins.length} installed</>\n                    )}\n                  {state.lastUpdated && (\n                    <>\n                      {' '}\n                      • Updated{' '}\n                      {new Date(state.lastUpdated).toLocaleDateString()}\n                    </>\n                  )}\n                </Text>\n              </Box>\n            </Box>\n          )\n        })}\n      </Box>\n\n      {/* Pending changes summary */}\n      {hasPendingChanges() && (\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text>\n            <Text bold>Pending changes:</Text>{' '}\n            <Text dimColor>Enter to apply</Text>\n          </Text>\n          {updateCount > 0 && (\n            <Text>\n              • Update {updateCount} {plural(updateCount, 'marketplace')}\n            </Text>\n          )}\n          {removeCount > 0 && (\n            <Text color=\"warning\">\n              • Remove {removeCount} {plural(removeCount, 'marketplace')}\n            </Text>\n          )}\n        </Box>\n      )}\n\n      {/* Processing indicator */}\n      {isProcessing && (\n        <Box marginTop={1}>\n          <Text color=\"claude\">Processing changes…</Text>\n        </Box>\n      )}\n\n      {/* Error display */}\n      {processError && (\n        <Box marginTop={1}>\n          <Text color=\"error\">{processError}</Text>\n        </Box>\n      )}\n\n      <ManageMarketplacesKeyHints\n        exitState={exitState}\n        hasPendingActions={hasPendingChanges()}\n      />\n    </Box>\n  )\n}\n\ntype ManageMarketplacesKeyHintsProps = {\n  exitState: Props['exitState']\n  hasPendingActions: boolean\n}\n\nfunction ManageMarketplacesKeyHints({\n  exitState,\n  hasPendingActions,\n}: ManageMarketplacesKeyHintsProps): React.ReactNode {\n  if (exitState.pending) {\n    return (\n      <Box marginTop={1}>\n        <Text dimColor italic>\n          Press {exitState.keyName} again to go back\n        </Text>\n      </Box>\n    )\n  }\n\n  return (\n    <Box marginTop={1}>\n      <Text dimColor italic>\n        <Byline>\n          {hasPendingActions && (\n            <ConfigurableShortcutHint\n              action=\"select:accept\"\n              context=\"Select\"\n              fallback=\"Enter\"\n              description=\"apply changes\"\n            />\n          )}\n          {!hasPendingActions && (\n            <ConfigurableShortcutHint\n              action=\"select:accept\"\n              context=\"Select\"\n              fallback=\"Enter\"\n              description=\"select\"\n            />\n          )}\n          {!hasPendingActions && (\n            <KeyboardShortcutHint shortcut=\"u\" action=\"update\" />\n          )}\n          {!hasPendingActions && (\n            <KeyboardShortcutHint shortcut=\"r\" action=\"remove\" />\n          )}\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description={hasPendingActions ? 'cancel' : 'go back'}\n          />\n        </Byline>\n      </Text>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/ManagePlugins.tsx b/src/commands/plugin/ManagePlugins.tsx new file mode 100644 index 0000000000000000000000000000000000000000..64d9a342888ed45f7ae114142e0fa8bdc71e6139 --- /dev/null +++ b/src/commands/plugin/ManagePlugins.tsx @@ -0,0 +1,2215 @@ +import figures from 'figures'; +import type { Dirent } from 'fs'; +import * as fs from 'fs/promises'; +import * as path from 'path'; +import * as React from 'react'; +import { useCallback, useEffect, useMemo, useRef, useState } from 'react'; +import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'; +import { Byline } from '../../components/design-system/Byline.js'; +import { MCPRemoteServerMenu } from '../../components/mcp/MCPRemoteServerMenu.js'; +import { MCPStdioServerMenu } from '../../components/mcp/MCPStdioServerMenu.js'; +import { MCPToolDetailView } from '../../components/mcp/MCPToolDetailView.js'; +import { MCPToolListView } from '../../components/mcp/MCPToolListView.js'; +import type { ClaudeAIServerInfo, HTTPServerInfo, SSEServerInfo, StdioServerInfo } from '../../components/mcp/types.js'; +import { SearchBox } from '../../components/SearchBox.js'; +import { useSearchInput } from '../../hooks/useSearchInput.js'; +import { useTerminalSize } from '../../hooks/useTerminalSize.js'; +// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input +import { Box, Text, useInput, useTerminalFocus } from '../../ink.js'; +import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js'; +import { getBuiltinPluginDefinition } from '../../plugins/builtinPlugins.js'; +import { useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js'; +import type { MCPServerConnection, McpClaudeAIProxyServerConfig, McpHTTPServerConfig, McpSSEServerConfig, McpStdioServerConfig } from '../../services/mcp/types.js'; +import { filterToolsByServer } from '../../services/mcp/utils.js'; +import { disablePluginOp, enablePluginOp, getPluginInstallationFromV2, isInstallableScope, isPluginEnabledAtProjectScope, uninstallPluginOp, updatePluginOp } from '../../services/plugins/pluginOperations.js'; +import { useAppState } from '../../state/AppState.js'; +import type { Tool } from '../../Tool.js'; +import type { LoadedPlugin, PluginError } from '../../types/plugin.js'; +import { count } from '../../utils/array.js'; +import { openBrowser } from '../../utils/browser.js'; +import { logForDebugging } from '../../utils/debug.js'; +import { errorMessage, toError } from '../../utils/errors.js'; +import { logError } from '../../utils/log.js'; +import { clearAllCaches } from '../../utils/plugins/cacheUtils.js'; +import { loadInstalledPluginsV2 } from '../../utils/plugins/installedPluginsManager.js'; +import { getMarketplace } from '../../utils/plugins/marketplaceManager.js'; +import { isMcpbSource, loadMcpbFile, type McpbNeedsConfigResult, type UserConfigValues } from '../../utils/plugins/mcpbHandler.js'; +import { getPluginDataDirSize, pluginDataDirPath } from '../../utils/plugins/pluginDirectories.js'; +import { getFlaggedPlugins, markFlaggedPluginsSeen, removeFlaggedPlugin } from '../../utils/plugins/pluginFlagging.js'; +import { type PersistablePluginScope, parsePluginIdentifier } from '../../utils/plugins/pluginIdentifier.js'; +import { loadAllPlugins } from '../../utils/plugins/pluginLoader.js'; +import { loadPluginOptions, type PluginOptionSchema, savePluginOptions } from '../../utils/plugins/pluginOptionsStorage.js'; +import { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js'; +import { getPluginEditableScopes } from '../../utils/plugins/pluginStartupCheck.js'; +import { getSettings_DEPRECATED, getSettingsForSource, updateSettingsForSource } from '../../utils/settings/settings.js'; +import { jsonParse } from '../../utils/slowOperations.js'; +import { plural } from '../../utils/stringUtils.js'; +import { formatErrorMessage, getErrorGuidance } from './PluginErrors.js'; +import { PluginOptionsDialog } from './PluginOptionsDialog.js'; +import { PluginOptionsFlow } from './PluginOptionsFlow.js'; +import type { ViewState as ParentViewState } from './types.js'; +import { UnifiedInstalledCell } from './UnifiedInstalledCell.js'; +import type { UnifiedInstalledItem } from './unifiedTypes.js'; +import { usePagination } from './usePagination.js'; +type Props = { + setViewState: (state: ParentViewState) => void; + setResult: (result: string | null) => void; + onManageComplete?: () => void | Promise; + onSearchModeChange?: (isActive: boolean) => void; + targetPlugin?: string; + targetMarketplace?: string; + action?: 'enable' | 'disable' | 'uninstall'; +}; +type FlaggedPluginInfo = { + id: string; + name: string; + marketplace: string; + reason: string; + text: string; + flaggedAt: string; +}; +type FailedPluginInfo = { + id: string; + name: string; + marketplace: string; + errors: PluginError[]; + scope: PersistablePluginScope; +}; +type ViewState = 'plugin-list' | 'plugin-details' | 'configuring' | { + type: 'plugin-options'; +} | { + type: 'configuring-options'; + schema: PluginOptionSchema; +} | 'confirm-project-uninstall' | { + type: 'confirm-data-cleanup'; + size: { + bytes: number; + human: string; + }; +} | { + type: 'flagged-detail'; + plugin: FlaggedPluginInfo; +} | { + type: 'failed-plugin-details'; + plugin: FailedPluginInfo; +} | { + type: 'mcp-detail'; + client: MCPServerConnection; +} | { + type: 'mcp-tools'; + client: MCPServerConnection; +} | { + type: 'mcp-tool-detail'; + client: MCPServerConnection; + tool: Tool; +}; +type MarketplaceInfo = { + name: string; + installedPlugins: LoadedPlugin[]; + enabledCount?: number; + disabledCount?: number; +}; +type PluginState = { + plugin: LoadedPlugin; + marketplace: string; + scope?: 'user' | 'project' | 'local' | 'managed' | 'builtin'; + pendingEnable?: boolean; // Toggle enable/disable + pendingUpdate?: boolean; // Marked for update +}; + +/** + * Get list of base file names (without .md extension) from a directory + * @param dirPath The directory path to list files from + * @returns Array of base file names without .md extension + * @example + * // Given directory contains: agent-sdk-verifier-py.md, agent-sdk-verifier-ts.md, README.txt + * await getBaseFileNames('/path/to/agents') + * // Returns: ['agent-sdk-verifier-py', 'agent-sdk-verifier-ts'] + */ +async function getBaseFileNames(dirPath: string): Promise { + try { + const entries = await fs.readdir(dirPath, { + withFileTypes: true + }); + return entries.filter((entry: Dirent) => entry.isFile() && entry.name.endsWith('.md')).map((entry: Dirent) => { + // Remove .md extension specifically + const baseName = path.basename(entry.name, '.md'); + return baseName; + }); + } catch (error) { + const errorMsg = errorMessage(error); + logForDebugging(`Failed to read plugin components from ${dirPath}: ${errorMsg}`, { + level: 'error' + }); + logError(toError(error)); + // Return empty array to allow graceful degradation - plugin details can still be shown + return []; + } +} + +/** + * Get list of skill directory names from a skills directory + * Skills are directories containing a SKILL.md file + * @param dirPath The skills directory path to scan + * @returns Array of skill directory names that contain SKILL.md + * @example + * // Given directory contains: my-skill/SKILL.md, another-skill/SKILL.md, README.txt + * await getSkillDirNames('/path/to/skills') + * // Returns: ['my-skill', 'another-skill'] + */ +async function getSkillDirNames(dirPath: string): Promise { + try { + const entries = await fs.readdir(dirPath, { + withFileTypes: true + }); + const skillNames: string[] = []; + for (const entry of entries) { + // Check if it's a directory or symlink (symlinks may point to skill directories) + if (entry.isDirectory() || entry.isSymbolicLink()) { + // Check if this directory contains a SKILL.md file + const skillFilePath = path.join(dirPath, entry.name, 'SKILL.md'); + try { + const st = await fs.stat(skillFilePath); + if (st.isFile()) { + skillNames.push(entry.name); + } + } catch { + // No SKILL.md file in this directory, skip it + } + } + } + return skillNames; + } catch (error) { + const errorMsg = errorMessage(error); + logForDebugging(`Failed to read skill directories from ${dirPath}: ${errorMsg}`, { + level: 'error' + }); + logError(toError(error)); + // Return empty array to allow graceful degradation - plugin details can still be shown + return []; + } +} + +// Component to display installed plugin components +function PluginComponentsDisplay({ + plugin, + marketplace +}: { + plugin: LoadedPlugin; + marketplace: string; +}): React.ReactNode { + const [components, setComponents] = useState<{ + commands?: string | string[] | Record | null; + agents?: string | string[] | Record | null; + skills?: string | string[] | Record | null; + hooks?: unknown; + mcpServers?: unknown; + } | null>(null); + const [loading, setLoading] = useState(true); + const [error, setError] = useState(null); + useEffect(() => { + async function loadComponents() { + try { + // Built-in plugins don't have a marketplace entry — read from the + // registered definition directly. + if (marketplace === 'builtin') { + const builtinDef = getBuiltinPluginDefinition(plugin.name); + if (builtinDef) { + const skillNames = builtinDef.skills?.map(s => s.name) ?? []; + const hookEvents = builtinDef.hooks ? Object.keys(builtinDef.hooks) : []; + const mcpServerNames = builtinDef.mcpServers ? Object.keys(builtinDef.mcpServers) : []; + setComponents({ + commands: null, + agents: null, + skills: skillNames.length > 0 ? skillNames : null, + hooks: hookEvents.length > 0 ? hookEvents : null, + mcpServers: mcpServerNames.length > 0 ? mcpServerNames : null + }); + } else { + setError(`Built-in plugin ${plugin.name} not found`); + } + setLoading(false); + return; + } + const marketplaceData = await getMarketplace(marketplace); + // Find the plugin entry in the array + const pluginEntry = marketplaceData.plugins.find(p => p.name === plugin.name); + if (pluginEntry) { + // Combine commands from both sources + const commandPathList = []; + if (plugin.commandsPath) { + commandPathList.push(plugin.commandsPath); + } + if (plugin.commandsPaths) { + commandPathList.push(...plugin.commandsPaths); + } + + // Get base file names from all command paths + const commandList: string[] = []; + for (const commandPath of commandPathList) { + if (typeof commandPath === 'string') { + // commandPath is already a full path + const baseNames = await getBaseFileNames(commandPath); + commandList.push(...baseNames); + } + } + + // Combine agents from both sources + const agentPathList = []; + if (plugin.agentsPath) { + agentPathList.push(plugin.agentsPath); + } + if (plugin.agentsPaths) { + agentPathList.push(...plugin.agentsPaths); + } + + // Get base file names from all agent paths + const agentList: string[] = []; + for (const agentPath of agentPathList) { + if (typeof agentPath === 'string') { + // agentPath is already a full path + const baseNames_0 = await getBaseFileNames(agentPath); + agentList.push(...baseNames_0); + } + } + + // Combine skills from both sources + const skillPathList = []; + if (plugin.skillsPath) { + skillPathList.push(plugin.skillsPath); + } + if (plugin.skillsPaths) { + skillPathList.push(...plugin.skillsPaths); + } + + // Get skill directory names from all skill paths + // Skills are directories containing SKILL.md files + const skillList: string[] = []; + for (const skillPath of skillPathList) { + if (typeof skillPath === 'string') { + // skillPath is already a full path to a skills directory + const skillDirNames = await getSkillDirNames(skillPath); + skillList.push(...skillDirNames); + } + } + + // Combine hooks from both sources + const hooksList = []; + if (plugin.hooksConfig) { + hooksList.push(Object.keys(plugin.hooksConfig)); + } + if (pluginEntry.hooks) { + hooksList.push(pluginEntry.hooks); + } + + // Combine MCP servers from both sources + const mcpServersList = []; + if (plugin.mcpServers) { + mcpServersList.push(Object.keys(plugin.mcpServers)); + } + if (pluginEntry.mcpServers) { + mcpServersList.push(pluginEntry.mcpServers); + } + setComponents({ + commands: commandList.length > 0 ? commandList : null, + agents: agentList.length > 0 ? agentList : null, + skills: skillList.length > 0 ? skillList : null, + hooks: hooksList.length > 0 ? hooksList : null, + mcpServers: mcpServersList.length > 0 ? mcpServersList : null + }); + } else { + setError(`Plugin ${plugin.name} not found in marketplace`); + } + } catch (err) { + setError(err instanceof Error ? err.message : 'Failed to load components'); + } finally { + setLoading(false); + } + } + void loadComponents(); + }, [plugin.name, plugin.commandsPath, plugin.commandsPaths, plugin.agentsPath, plugin.agentsPaths, plugin.skillsPath, plugin.skillsPaths, plugin.hooksConfig, plugin.mcpServers, marketplace]); + if (loading) { + return null; // Don't show loading state for cleaner UI + } + if (error) { + return + Components: + Error: {error} + ; + } + if (!components) { + return null; // No components info available + } + const hasComponents = components.commands || components.agents || components.skills || components.hooks || components.mcpServers; + if (!hasComponents) { + return null; // No components defined + } + return + Installed components: + {components.commands ? + • Commands:{' '} + {typeof components.commands === 'string' ? components.commands : Array.isArray(components.commands) ? components.commands.join(', ') : Object.keys(components.commands).join(', ')} + : null} + {components.agents ? + • Agents:{' '} + {typeof components.agents === 'string' ? components.agents : Array.isArray(components.agents) ? components.agents.join(', ') : Object.keys(components.agents).join(', ')} + : null} + {components.skills ? + • Skills:{' '} + {typeof components.skills === 'string' ? components.skills : Array.isArray(components.skills) ? components.skills.join(', ') : Object.keys(components.skills).join(', ')} + : null} + {components.hooks ? + • Hooks:{' '} + {typeof components.hooks === 'string' ? components.hooks : Array.isArray(components.hooks) ? components.hooks.map(String).join(', ') : typeof components.hooks === 'object' && components.hooks !== null ? Object.keys(components.hooks).join(', ') : String(components.hooks)} + : null} + {components.mcpServers ? + • MCP Servers:{' '} + {typeof components.mcpServers === 'string' ? components.mcpServers : Array.isArray(components.mcpServers) ? components.mcpServers.map(String).join(', ') : typeof components.mcpServers === 'object' && components.mcpServers !== null ? Object.keys(components.mcpServers).join(', ') : String(components.mcpServers)} + : null} + ; +} + +/** + * Check if a plugin is from a local source and cannot be remotely updated + * @returns Error message if local, null if remote/updatable + */ +async function checkIfLocalPlugin(pluginName: string, marketplaceName: string): Promise { + const marketplace = await getMarketplace(marketplaceName); + const entry = marketplace?.plugins.find(p => p.name === pluginName); + if (entry && typeof entry.source === 'string') { + return `Local plugins cannot be updated remotely. To update, modify the source at: ${entry.source}`; + } + return null; +} + +/** + * Filter out plugins that are force-disabled by org policy (policySettings). + * These are blocked by the organization and cannot be re-enabled by the user. + * Checks policySettings directly rather than installation scope, since managed + * settings don't create installation records with scope 'managed'. + */ +export function filterManagedDisabledPlugins(plugins: LoadedPlugin[]): LoadedPlugin[] { + return plugins.filter(plugin => { + const marketplace = plugin.source.split('@')[1] || 'local'; + return !isPluginBlockedByPolicy(`${plugin.name}@${marketplace}`); + }); +} +export function ManagePlugins({ + setViewState: setParentViewState, + setResult, + onManageComplete, + onSearchModeChange, + targetPlugin, + targetMarketplace, + action +}: Props): React.ReactNode { + // App state for MCP access + const mcpClients = useAppState(s => s.mcp.clients); + const mcpTools = useAppState(s_0 => s_0.mcp.tools); + const pluginErrors = useAppState(s_1 => s_1.plugins.errors); + const flaggedPlugins = getFlaggedPlugins(); + + // Search state + const [isSearchMode, setIsSearchModeRaw] = useState(false); + const setIsSearchMode = useCallback((active: boolean) => { + setIsSearchModeRaw(active); + onSearchModeChange?.(active); + }, [onSearchModeChange]); + const isTerminalFocused = useTerminalFocus(); + const { + columns: terminalWidth + } = useTerminalSize(); + + // View state + const [viewState, setViewState] = useState('plugin-list'); + const { + query: searchQuery, + setQuery: setSearchQuery, + cursorOffset: searchCursorOffset + } = useSearchInput({ + isActive: viewState === 'plugin-list' && isSearchMode, + onExit: () => { + setIsSearchMode(false); + } + }); + const [selectedPlugin, setSelectedPlugin] = useState(null); + + // Data state + const [marketplaces, setMarketplaces] = useState([]); + const [pluginStates, setPluginStates] = useState([]); + const [loading, setLoading] = useState(true); + const [pendingToggles, setPendingToggles] = useState>(new Map()); + + // Guard to prevent auto-navigation from re-triggering after the user + // navigates away (targetPlugin is never cleared by the parent). + const hasAutoNavigated = useRef(false); + // Auto-action (enable/disable/uninstall) to fire after auto-navigation lands. + // Ref, not state: it's consumed by a one-shot effect that already re-runs on + // viewState/selectedPlugin, so a render-triggering state var would be redundant. + const pendingAutoActionRef = useRef<'enable' | 'disable' | 'uninstall' | undefined>(undefined); + + // MCP toggle hook + const toggleMcpServer = useMcpToggleEnabled(); + + // Handle escape to go back - viewState-dependent navigation + const handleBack = React.useCallback(() => { + if (viewState === 'plugin-details') { + setViewState('plugin-list'); + setSelectedPlugin(null); + setProcessError(null); + } else if (typeof viewState === 'object' && viewState.type === 'failed-plugin-details') { + setViewState('plugin-list'); + setProcessError(null); + } else if (viewState === 'configuring') { + setViewState('plugin-details'); + setConfigNeeded(null); + } else if (typeof viewState === 'object' && (viewState.type === 'plugin-options' || viewState.type === 'configuring-options')) { + // Cancel mid-sequence — plugin is already enabled, just bail to list. + // User can configure later via the Configure options menu if they want. + setViewState('plugin-list'); + setSelectedPlugin(null); + setResult('Plugin enabled. Configuration skipped — run /reload-plugins to apply.'); + if (onManageComplete) { + void onManageComplete(); + } + } else if (typeof viewState === 'object' && viewState.type === 'flagged-detail') { + setViewState('plugin-list'); + setProcessError(null); + } else if (typeof viewState === 'object' && viewState.type === 'mcp-detail') { + setViewState('plugin-list'); + setProcessError(null); + } else if (typeof viewState === 'object' && viewState.type === 'mcp-tools') { + setViewState({ + type: 'mcp-detail', + client: viewState.client + }); + } else if (typeof viewState === 'object' && viewState.type === 'mcp-tool-detail') { + setViewState({ + type: 'mcp-tools', + client: viewState.client + }); + } else { + if (pendingToggles.size > 0) { + setResult('Run /reload-plugins to apply plugin changes.'); + return; + } + setParentViewState({ + type: 'menu' + }); + } + }, [viewState, setParentViewState, pendingToggles, setResult]); + + // Escape when not in search mode - go back. + // Excludes confirm-project-uninstall (has its own confirm:no handler in + // Confirmation context — letting this fire would create competing handlers) + // and confirm-data-cleanup (uses raw useInput where n and escape are + // DIFFERENT actions: keep-data vs cancel). + useKeybinding('confirm:no', handleBack, { + context: 'Confirmation', + isActive: (viewState !== 'plugin-list' || !isSearchMode) && viewState !== 'confirm-project-uninstall' && !(typeof viewState === 'object' && viewState.type === 'confirm-data-cleanup') + }); + + // Helper to get MCP status + const getMcpStatus = (client: MCPServerConnection): 'connected' | 'disabled' | 'pending' | 'needs-auth' | 'failed' => { + if (client.type === 'connected') return 'connected'; + if (client.type === 'disabled') return 'disabled'; + if (client.type === 'pending') return 'pending'; + if (client.type === 'needs-auth') return 'needs-auth'; + return 'failed'; + }; + + // Derive unified items from plugins and MCP servers + const unifiedItems = useMemo(() => { + const mergedSettings = getSettings_DEPRECATED(); + + // Build map of plugin name -> child MCPs + // Plugin MCPs have names like "plugin:pluginName:serverName" + const pluginMcpMap = new Map>(); + for (const client_0 of mcpClients) { + if (client_0.name.startsWith('plugin:')) { + const parts = client_0.name.split(':'); + if (parts.length >= 3) { + const pluginName = parts[1]!; + const serverName = parts.slice(2).join(':'); + const existing = pluginMcpMap.get(pluginName) || []; + existing.push({ + displayName: serverName, + client: client_0 + }); + pluginMcpMap.set(pluginName, existing); + } + } + } + + // Build plugin items (unsorted for now) + type PluginWithChildren = { + item: UnifiedInstalledItem & { + type: 'plugin'; + }; + originalScope: 'user' | 'project' | 'local' | 'managed' | 'builtin'; + childMcps: Array<{ + displayName: string; + client: MCPServerConnection; + }>; + }; + const pluginsWithChildren: PluginWithChildren[] = []; + for (const state of pluginStates) { + const pluginId = `${state.plugin.name}@${state.marketplace}`; + const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false; + const errors = pluginErrors.filter(e => 'plugin' in e && e.plugin === state.plugin.name || e.source === pluginId || e.source.startsWith(`${state.plugin.name}@`)); + + // Built-in plugins use 'builtin' scope; others look up from V2 data. + const originalScope = state.plugin.isBuiltin ? 'builtin' : state.scope || 'user'; + pluginsWithChildren.push({ + item: { + type: 'plugin', + id: pluginId, + name: state.plugin.name, + description: state.plugin.manifest.description, + marketplace: state.marketplace, + scope: originalScope, + isEnabled, + errorCount: errors.length, + errors, + plugin: state.plugin, + pendingEnable: state.pendingEnable, + pendingUpdate: state.pendingUpdate, + pendingToggle: pendingToggles.get(pluginId) + }, + originalScope, + childMcps: pluginMcpMap.get(state.plugin.name) || [] + }); + } + + // Find orphan errors (errors for plugins that failed to load entirely) + const matchedPluginIds = new Set(pluginsWithChildren.map(({ + item + }) => item.id)); + const matchedPluginNames = new Set(pluginsWithChildren.map(({ + item: item_0 + }) => item_0.name)); + const orphanErrorsBySource = new Map(); + for (const error of pluginErrors) { + if (matchedPluginIds.has(error.source) || 'plugin' in error && typeof error.plugin === 'string' && matchedPluginNames.has(error.plugin)) { + continue; + } + const existing_0 = orphanErrorsBySource.get(error.source) || []; + existing_0.push(error); + orphanErrorsBySource.set(error.source, existing_0); + } + const pluginScopes = getPluginEditableScopes(); + const failedPluginItems: UnifiedInstalledItem[] = []; + for (const [pluginId_0, errors_0] of orphanErrorsBySource) { + // Skip plugins that are already shown in the flagged section + if (pluginId_0 in flaggedPlugins) continue; + const parsed = parsePluginIdentifier(pluginId_0); + const pluginName_0 = parsed.name || pluginId_0; + const marketplace = parsed.marketplace || 'unknown'; + const rawScope = pluginScopes.get(pluginId_0); + // 'flag' is session-only (from --plugin-dir / flagSettings) and undefined + // means the plugin isn't in any settings source. Default both to 'user' + // since UnifiedInstalledItem doesn't have a 'flag' scope variant. + const scope = rawScope === 'flag' || rawScope === undefined ? 'user' : rawScope; + failedPluginItems.push({ + type: 'failed-plugin', + id: pluginId_0, + name: pluginName_0, + marketplace, + scope, + errorCount: errors_0.length, + errors: errors_0 + }); + } + + // Build standalone MCP items + const standaloneMcps: UnifiedInstalledItem[] = []; + for (const client_1 of mcpClients) { + if (client_1.name === 'ide') continue; + if (client_1.name.startsWith('plugin:')) continue; + standaloneMcps.push({ + type: 'mcp', + id: `mcp:${client_1.name}`, + name: client_1.name, + description: undefined, + scope: client_1.config.scope, + status: getMcpStatus(client_1), + client: client_1 + }); + } + + // Define scope order for display + const scopeOrder: Record = { + flagged: -1, + project: 0, + local: 1, + user: 2, + enterprise: 3, + managed: 4, + dynamic: 5, + builtin: 6 + }; + + // Build final list by merging plugins (with their child MCPs) and standalone MCPs + // Group by scope to avoid duplicate scope headers + const unified: UnifiedInstalledItem[] = []; + + // Create a map of scope -> items for proper merging + const itemsByScope = new Map(); + + // Add plugins with their child MCPs + for (const { + item: item_1, + originalScope: originalScope_0, + childMcps + } of pluginsWithChildren) { + const scope_0 = item_1.scope; + if (!itemsByScope.has(scope_0)) { + itemsByScope.set(scope_0, []); + } + itemsByScope.get(scope_0)!.push(item_1); + // Add child MCPs right after the plugin, indented (use original scope, not 'flagged'). + // Built-in plugins map to 'user' for display since MCP ConfigScope doesn't include 'builtin'. + for (const { + displayName, + client: client_2 + } of childMcps) { + const displayScope = originalScope_0 === 'builtin' ? 'user' : originalScope_0; + if (!itemsByScope.has(displayScope)) { + itemsByScope.set(displayScope, []); + } + itemsByScope.get(displayScope)!.push({ + type: 'mcp', + id: `mcp:${client_2.name}`, + name: displayName, + description: undefined, + scope: displayScope, + status: getMcpStatus(client_2), + client: client_2, + indented: true + }); + } + } + + // Add standalone MCPs to their respective scope groups + for (const mcp of standaloneMcps) { + const scope_1 = mcp.scope; + if (!itemsByScope.has(scope_1)) { + itemsByScope.set(scope_1, []); + } + itemsByScope.get(scope_1)!.push(mcp); + } + + // Add failed plugins to their respective scope groups + for (const failedPlugin of failedPluginItems) { + const scope_2 = failedPlugin.scope; + if (!itemsByScope.has(scope_2)) { + itemsByScope.set(scope_2, []); + } + itemsByScope.get(scope_2)!.push(failedPlugin); + } + + // Add flagged (delisted) plugins from user settings. + // Reason/text are looked up from the cached security messages file. + for (const [pluginId_1, entry] of Object.entries(flaggedPlugins)) { + const parsed_0 = parsePluginIdentifier(pluginId_1); + const pluginName_1 = parsed_0.name || pluginId_1; + const marketplace_0 = parsed_0.marketplace || 'unknown'; + if (!itemsByScope.has('flagged')) { + itemsByScope.set('flagged', []); + } + itemsByScope.get('flagged')!.push({ + type: 'flagged-plugin', + id: pluginId_1, + name: pluginName_1, + marketplace: marketplace_0, + scope: 'flagged', + reason: 'delisted', + text: 'Removed from marketplace', + flaggedAt: entry.flaggedAt + }); + } + + // Sort scopes and build final list + const sortedScopes = [...itemsByScope.keys()].sort((a, b) => (scopeOrder[a] ?? 99) - (scopeOrder[b] ?? 99)); + for (const scope_3 of sortedScopes) { + const items = itemsByScope.get(scope_3)!; + + // Separate items into plugin groups (with their child MCPs) and standalone MCPs + // This preserves parent-child relationships that would be broken by naive sorting + const pluginGroups: UnifiedInstalledItem[][] = []; + const standaloneMcpsInScope: UnifiedInstalledItem[] = []; + let i = 0; + while (i < items.length) { + const item_2 = items[i]!; + if (item_2.type === 'plugin' || item_2.type === 'failed-plugin' || item_2.type === 'flagged-plugin') { + // Collect the plugin and its child MCPs as a group + const group: UnifiedInstalledItem[] = [item_2]; + i++; + // Look ahead for indented child MCPs + let nextItem = items[i]; + while (nextItem?.type === 'mcp' && nextItem.indented) { + group.push(nextItem); + i++; + nextItem = items[i]; + } + pluginGroups.push(group); + } else if (item_2.type === 'mcp' && !item_2.indented) { + // Standalone MCP (not a child of a plugin) + standaloneMcpsInScope.push(item_2); + i++; + } else { + // Skip orphaned indented MCPs (shouldn't happen) + i++; + } + } + + // Sort plugin groups by the plugin name (first item in each group) + pluginGroups.sort((a_0, b_0) => a_0[0]!.name.localeCompare(b_0[0]!.name)); + + // Sort standalone MCPs by name + standaloneMcpsInScope.sort((a_1, b_1) => a_1.name.localeCompare(b_1.name)); + + // Build final list: plugins (with their children) first, then standalone MCPs + for (const group_0 of pluginGroups) { + unified.push(...group_0); + } + unified.push(...standaloneMcpsInScope); + } + return unified; + }, [pluginStates, mcpClients, pluginErrors, pendingToggles, flaggedPlugins]); + + // Mark flagged plugins as seen when the Installed view renders them. + // After 48 hours from seenAt, they auto-clear on next load. + const flaggedIds = useMemo(() => unifiedItems.filter(item_3 => item_3.type === 'flagged-plugin').map(item_4 => item_4.id), [unifiedItems]); + useEffect(() => { + if (flaggedIds.length > 0) { + void markFlaggedPluginsSeen(flaggedIds); + } + }, [flaggedIds]); + + // Filter items based on search query (matches name or description) + const filteredItems = useMemo(() => { + if (!searchQuery) return unifiedItems; + const lowerQuery = searchQuery.toLowerCase(); + return unifiedItems.filter(item_5 => item_5.name.toLowerCase().includes(lowerQuery) || 'description' in item_5 && item_5.description?.toLowerCase().includes(lowerQuery)); + }, [unifiedItems, searchQuery]); + + // Selection state + const [selectedIndex, setSelectedIndex] = useState(0); + + // Pagination for unified list (continuous scrolling) + const pagination = usePagination({ + totalItems: filteredItems.length, + selectedIndex, + maxVisible: 8 + }); + + // Details view state + const [detailsMenuIndex, setDetailsMenuIndex] = useState(0); + const [isProcessing, setIsProcessing] = useState(false); + const [processError, setProcessError] = useState(null); + + // Configuration state + const [configNeeded, setConfigNeeded] = useState(null); + const [_isLoadingConfig, setIsLoadingConfig] = useState(false); + const [selectedPluginHasMcpb, setSelectedPluginHasMcpb] = useState(false); + + // Detect if selected plugin has MCPB + // Reads raw marketplace.json to work with old cached marketplaces + useEffect(() => { + if (!selectedPlugin) { + setSelectedPluginHasMcpb(false); + return; + } + async function detectMcpb() { + // Check plugin manifest first + const mcpServersSpec = selectedPlugin!.plugin.manifest.mcpServers; + let hasMcpb = false; + if (mcpServersSpec) { + hasMcpb = typeof mcpServersSpec === 'string' && isMcpbSource(mcpServersSpec) || Array.isArray(mcpServersSpec) && mcpServersSpec.some(s_2 => typeof s_2 === 'string' && isMcpbSource(s_2)); + } + + // If not in manifest, read raw marketplace.json directly (bypassing schema validation) + // This works even with old cached marketplaces from before MCPB support + if (!hasMcpb) { + try { + const marketplaceDir = path.join(selectedPlugin!.plugin.path, '..'); + const marketplaceJsonPath = path.join(marketplaceDir, '.claude-plugin', 'marketplace.json'); + const content = await fs.readFile(marketplaceJsonPath, 'utf-8'); + const marketplace_1 = jsonParse(content); + const entry_0 = marketplace_1.plugins?.find((p: { + name: string; + }) => p.name === selectedPlugin!.plugin.name); + if (entry_0?.mcpServers) { + const spec = entry_0.mcpServers; + hasMcpb = typeof spec === 'string' && isMcpbSource(spec) || Array.isArray(spec) && spec.some((s_3: unknown) => typeof s_3 === 'string' && isMcpbSource(s_3)); + } + } catch (err) { + logForDebugging(`Failed to read raw marketplace.json: ${err}`); + } + } + setSelectedPluginHasMcpb(hasMcpb); + } + void detectMcpb(); + }, [selectedPlugin]); + + // Load installed plugins grouped by marketplace + useEffect(() => { + async function loadInstalledPlugins() { + setLoading(true); + try { + const { + enabled, + disabled + } = await loadAllPlugins(); + const mergedSettings = getSettings_DEPRECATED(); // Use merged settings to respect all layers + + const allPlugins = filterManagedDisabledPlugins([...enabled, ...disabled]); + + // Group plugins by marketplace + const pluginsByMarketplace: Record = {}; + for (const plugin of allPlugins) { + const marketplace = plugin.source.split('@')[1] || 'local'; + if (!pluginsByMarketplace[marketplace]) { + pluginsByMarketplace[marketplace] = []; + } + pluginsByMarketplace[marketplace]!.push(plugin); + } + + // Create marketplace info array with enabled/disabled counts + const marketplaceInfos: MarketplaceInfo[] = []; + for (const [name, plugins] of Object.entries(pluginsByMarketplace)) { + const enabledCount = count(plugins, p => { + const pluginId = `${p.name}@${name}`; + return mergedSettings?.enabledPlugins?.[pluginId] !== false; + }); + const disabledCount = plugins.length - enabledCount; + marketplaceInfos.push({ + name, + installedPlugins: plugins, + enabledCount, + disabledCount + }); + } + + // Sort marketplaces: claude-plugin-directory first, then alphabetically + marketplaceInfos.sort((a, b) => { + if (a.name === 'claude-plugin-directory') return -1; + if (b.name === 'claude-plugin-directory') return 1; + return a.name.localeCompare(b.name); + }); + setMarketplaces(marketplaceInfos); + + // Build flat list of all plugin states + const allStates: PluginState[] = []; + for (const marketplace of marketplaceInfos) { + for (const plugin of marketplace.installedPlugins) { + const pluginId = `${plugin.name}@${marketplace.name}`; + // Built-in plugins don't have V2 install entries — skip the lookup. + const scope = plugin.isBuiltin ? 'builtin' : getPluginInstallationFromV2(pluginId).scope; + allStates.push({ + plugin, + marketplace: marketplace.name, + scope, + pendingEnable: undefined, + pendingUpdate: false + }); + } + } + setPluginStates(allStates); + setSelectedIndex(0); + } finally { + setLoading(false); + } + } + void loadInstalledPlugins(); + }, []); + + // Auto-navigate to target plugin if specified (once only) + useEffect(() => { + if (hasAutoNavigated.current) return; + if (targetPlugin && marketplaces.length > 0 && !loading) { + // targetPlugin may be `name` or `name@marketplace` (parseArgs passes the + // raw arg through). Parse it so p.name matching works either way. + const { + name: targetName, + marketplace: targetMktFromId + } = parsePluginIdentifier(targetPlugin); + const effectiveTargetMarketplace = targetMarketplace ?? targetMktFromId; + + // Use targetMarketplace if provided, otherwise search all + const marketplacesToSearch = effectiveTargetMarketplace ? marketplaces.filter(m => m.name === effectiveTargetMarketplace) : marketplaces; + + // First check successfully loaded plugins + for (const marketplace_2 of marketplacesToSearch) { + const plugin = marketplace_2.installedPlugins.find(p_0 => p_0.name === targetName); + if (plugin) { + // Get scope from V2 data for proper operation handling + const pluginId_2 = `${plugin.name}@${marketplace_2.name}`; + const { + scope: scope_4 + } = getPluginInstallationFromV2(pluginId_2); + const pluginState: PluginState = { + plugin, + marketplace: marketplace_2.name, + scope: scope_4, + pendingEnable: undefined, + pendingUpdate: false + }; + setSelectedPlugin(pluginState); + setViewState('plugin-details'); + pendingAutoActionRef.current = action; + hasAutoNavigated.current = true; + return; + } + } + + // Fall back to failed plugins (those with errors but not loaded) + const failedItem = unifiedItems.find(item_6 => item_6.type === 'failed-plugin' && item_6.name === targetName); + if (failedItem && failedItem.type === 'failed-plugin') { + setViewState({ + type: 'failed-plugin-details', + plugin: { + id: failedItem.id, + name: failedItem.name, + marketplace: failedItem.marketplace, + errors: failedItem.errors, + scope: failedItem.scope + } + }); + hasAutoNavigated.current = true; + } + + // No match in loaded OR failed plugins — close the dialog with a + // message rather than silently landing on the plugin list. Only do + // this when an action was requested (e.g. /plugin uninstall X); + // plain navigation (/plugin manage) should still just show the list. + if (!hasAutoNavigated.current && action) { + hasAutoNavigated.current = true; + setResult(`Plugin "${targetPlugin}" is not installed in this project`); + } + } + }, [targetPlugin, targetMarketplace, marketplaces, loading, unifiedItems, action, setResult]); + + // Handle single plugin operations from details view + const handleSingleOperation = async (operation: 'enable' | 'disable' | 'update' | 'uninstall') => { + if (!selectedPlugin) return; + const pluginScope = selectedPlugin.scope || 'user'; + const isBuiltin = pluginScope === 'builtin'; + + // Built-in plugins can only be enabled/disabled, not updated/uninstalled. + if (isBuiltin && (operation === 'update' || operation === 'uninstall')) { + setProcessError('Built-in plugins cannot be updated or uninstalled.'); + return; + } + + // Managed scope plugins can only be updated, not enabled/disabled/uninstalled + if (!isBuiltin && !isInstallableScope(pluginScope) && operation !== 'update') { + setProcessError('This plugin is managed by your organization. Contact your admin to disable it.'); + return; + } + setIsProcessing(true); + setProcessError(null); + try { + const pluginId_3 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + let reverseDependents: string[] | undefined; + + // enable/disable omit scope — pluginScope is the install scope from + // installed_plugins.json (where files are cached), which can diverge + // from the settings scope (where enablement lives). Passing it trips + // the cross-scope guard. Auto-detect finds the right scope. #38084 + switch (operation) { + case 'enable': + { + const enableResult = await enablePluginOp(pluginId_3); + if (!enableResult.success) { + throw new Error(enableResult.message); + } + break; + } + case 'disable': + { + const disableResult = await disablePluginOp(pluginId_3); + if (!disableResult.success) { + throw new Error(disableResult.message); + } + reverseDependents = disableResult.reverseDependents; + break; + } + case 'uninstall': + { + if (isBuiltin) break; // guarded above; narrows pluginScope + if (!isInstallableScope(pluginScope)) break; + // If the plugin is enabled in .claude/settings.json (shared with the + // team), divert to a confirmation dialog that offers to disable in + // settings.local.json instead. Check the settings file directly — + // `pluginScope` (from installed_plugins.json) can be 'user' even when + // the plugin is ALSO project-enabled, and uninstalling the user-scope + // install would leave the project enablement active. + if (isPluginEnabledAtProjectScope(pluginId_3)) { + setIsProcessing(false); + setViewState('confirm-project-uninstall'); + return; + } + // If the plugin has persistent data (${CLAUDE_PLUGIN_DATA}) AND this + // is the last scope, prompt before deleting it. For multi-scope + // installs, the op's isLastScope check won't delete regardless of + // the user's y/n — showing the dialog would mislead ("y" → nothing + // happens). Length check mirrors pluginOperations.ts:513. + const installs = loadInstalledPluginsV2().plugins[pluginId_3]; + const isLastScope = !installs || installs.length <= 1; + const dataSize = isLastScope ? await getPluginDataDirSize(pluginId_3) : null; + if (dataSize) { + setIsProcessing(false); + setViewState({ + type: 'confirm-data-cleanup', + size: dataSize + }); + return; + } + const result_0 = await uninstallPluginOp(pluginId_3, pluginScope); + if (!result_0.success) { + throw new Error(result_0.message); + } + reverseDependents = result_0.reverseDependents; + break; + } + case 'update': + { + if (isBuiltin) break; // guarded above; narrows pluginScope + const result = await updatePluginOp(pluginId_3, pluginScope); + if (!result.success) { + throw new Error(result.message); + } + // If already up to date, show message and exit + if (result.alreadyUpToDate) { + setResult(`${selectedPlugin.plugin.name} is already at the latest version (${result.newVersion}).`); + if (onManageComplete) { + await onManageComplete(); + } + setParentViewState({ + type: 'menu' + }); + return; + } + // Success - will show standard message below + break; + } + } + + // Operations (enable, disable, uninstall, update) now use centralized functions + // that handle their own settings updates, so we only need to clear caches here + clearAllCaches(); + + // Prompt for manifest.userConfig + channel userConfig if the plugin ends + // up enabled. Re-read settings rather than keying on `operation === + // 'enable'`: install enables on install, so the menu shows "Disable" + // first. PluginOptionsFlow itself checks getUnconfiguredOptions — if + // nothing needs filling, it calls onDone('skipped') immediately. + const pluginIdNow = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + const settingsAfter = getSettings_DEPRECATED(); + const enabledAfter = settingsAfter?.enabledPlugins?.[pluginIdNow] !== false; + if (enabledAfter) { + setIsProcessing(false); + setViewState({ + type: 'plugin-options' + }); + return; + } + const operationName = operation === 'enable' ? 'Enabled' : operation === 'disable' ? 'Disabled' : operation === 'update' ? 'Updated' : 'Uninstalled'; + + // Single-line warning — notification timeout is ~8s, multi-line would scroll off. + // The persistent record is in the Errors tab (dependency-unsatisfied after reload). + const depWarn = reverseDependents && reverseDependents.length > 0 ? ` · required by ${reverseDependents.join(', ')}` : ''; + const message = `✓ ${operationName} ${selectedPlugin.plugin.name}${depWarn}. Run /reload-plugins to apply.`; + setResult(message); + if (onManageComplete) { + await onManageComplete(); + } + setParentViewState({ + type: 'menu' + }); + } catch (error_0) { + setIsProcessing(false); + const errorMessage = error_0 instanceof Error ? error_0.message : String(error_0); + setProcessError(`Failed to ${operation}: ${errorMessage}`); + logError(toError(error_0)); + } + }; + + // Latest-ref: lets the auto-action effect call the current closure without + // adding handleSingleOperation (recreated every render) to its deps. + const handleSingleOperationRef = useRef(handleSingleOperation); + handleSingleOperationRef.current = handleSingleOperation; + + // Auto-execute the action prop (/plugin uninstall X, /plugin enable X, etc.) + // once auto-navigation has landed on plugin-details. + useEffect(() => { + if (viewState === 'plugin-details' && selectedPlugin && pendingAutoActionRef.current) { + const pending = pendingAutoActionRef.current; + pendingAutoActionRef.current = undefined; + void handleSingleOperationRef.current(pending); + } + }, [viewState, selectedPlugin]); + + // Handle toggle enable/disable + const handleToggle = React.useCallback(() => { + if (selectedIndex >= filteredItems.length) return; + const item_7 = filteredItems[selectedIndex]; + if (item_7?.type === 'flagged-plugin') return; + if (item_7?.type === 'plugin') { + const pluginId_4 = `${item_7.plugin.name}@${item_7.marketplace}`; + const mergedSettings_0 = getSettings_DEPRECATED(); + const currentPending = pendingToggles.get(pluginId_4); + const isEnabled_0 = mergedSettings_0?.enabledPlugins?.[pluginId_4] !== false; + const pluginScope_0 = item_7.scope; + const isBuiltin_0 = pluginScope_0 === 'builtin'; + if (isBuiltin_0 || isInstallableScope(pluginScope_0)) { + const newPending = new Map(pendingToggles); + // Omit scope — see handleSingleOperation's enable/disable comment. + if (currentPending) { + // Cancel: reverse the operation back to the original state + newPending.delete(pluginId_4); + void (async () => { + try { + if (currentPending === 'will-disable') { + await enablePluginOp(pluginId_4); + } else { + await disablePluginOp(pluginId_4); + } + clearAllCaches(); + } catch (err_0) { + logError(err_0); + } + })(); + } else { + newPending.set(pluginId_4, isEnabled_0 ? 'will-disable' : 'will-enable'); + void (async () => { + try { + if (isEnabled_0) { + await disablePluginOp(pluginId_4); + } else { + await enablePluginOp(pluginId_4); + } + clearAllCaches(); + } catch (err_1) { + logError(err_1); + } + })(); + } + setPendingToggles(newPending); + } + } else if (item_7?.type === 'mcp') { + void toggleMcpServer(item_7.client.name); + } + }, [selectedIndex, filteredItems, pendingToggles, pluginStates, toggleMcpServer]); + + // Handle accept (Enter) in plugin-list + const handleAccept = React.useCallback(() => { + if (selectedIndex >= filteredItems.length) return; + const item_8 = filteredItems[selectedIndex]; + if (item_8?.type === 'plugin') { + const state_0 = pluginStates.find(s_4 => s_4.plugin.name === item_8.plugin.name && s_4.marketplace === item_8.marketplace); + if (state_0) { + setSelectedPlugin(state_0); + setViewState('plugin-details'); + setDetailsMenuIndex(0); + setProcessError(null); + } + } else if (item_8?.type === 'flagged-plugin') { + setViewState({ + type: 'flagged-detail', + plugin: { + id: item_8.id, + name: item_8.name, + marketplace: item_8.marketplace, + reason: item_8.reason, + text: item_8.text, + flaggedAt: item_8.flaggedAt + } + }); + setProcessError(null); + } else if (item_8?.type === 'failed-plugin') { + setViewState({ + type: 'failed-plugin-details', + plugin: { + id: item_8.id, + name: item_8.name, + marketplace: item_8.marketplace, + errors: item_8.errors, + scope: item_8.scope + } + }); + setDetailsMenuIndex(0); + setProcessError(null); + } else if (item_8?.type === 'mcp') { + setViewState({ + type: 'mcp-detail', + client: item_8.client + }); + setProcessError(null); + } + }, [selectedIndex, filteredItems, pluginStates]); + + // Plugin-list navigation (non-search mode) + useKeybindings({ + 'select:previous': () => { + if (selectedIndex === 0) { + setIsSearchMode(true); + } else { + pagination.handleSelectionChange(selectedIndex - 1, setSelectedIndex); + } + }, + 'select:next': () => { + if (selectedIndex < filteredItems.length - 1) { + pagination.handleSelectionChange(selectedIndex + 1, setSelectedIndex); + } + }, + 'select:accept': handleAccept + }, { + context: 'Select', + isActive: viewState === 'plugin-list' && !isSearchMode + }); + useKeybindings({ + 'plugin:toggle': handleToggle + }, { + context: 'Plugin', + isActive: viewState === 'plugin-list' && !isSearchMode + }); + + // Handle dismiss action in flagged-detail view + const handleFlaggedDismiss = React.useCallback(() => { + if (typeof viewState !== 'object' || viewState.type !== 'flagged-detail') return; + void removeFlaggedPlugin(viewState.plugin.id); + setViewState('plugin-list'); + }, [viewState]); + useKeybindings({ + 'select:accept': handleFlaggedDismiss + }, { + context: 'Select', + isActive: typeof viewState === 'object' && viewState.type === 'flagged-detail' + }); + + // Build details menu items (needed for navigation) + const detailsMenuItems = React.useMemo(() => { + if (viewState !== 'plugin-details' || !selectedPlugin) return []; + const mergedSettings_1 = getSettings_DEPRECATED(); + const pluginId_5 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + const isEnabled_1 = mergedSettings_1?.enabledPlugins?.[pluginId_5] !== false; + const isBuiltin_1 = selectedPlugin.marketplace === 'builtin'; + const menuItems: Array<{ + label: string; + action: () => void; + }> = []; + menuItems.push({ + label: isEnabled_1 ? 'Disable plugin' : 'Enable plugin', + action: () => void handleSingleOperation(isEnabled_1 ? 'disable' : 'enable') + }); + + // Update/Uninstall options — not available for built-in plugins + if (!isBuiltin_1) { + menuItems.push({ + label: selectedPlugin.pendingUpdate ? 'Unmark for update' : 'Mark for update', + action: async () => { + try { + const localError = await checkIfLocalPlugin(selectedPlugin.plugin.name, selectedPlugin.marketplace); + if (localError) { + setProcessError(localError); + return; + } + const newStates = [...pluginStates]; + const index = newStates.findIndex(s_5 => s_5.plugin.name === selectedPlugin.plugin.name && s_5.marketplace === selectedPlugin.marketplace); + if (index !== -1) { + newStates[index]!.pendingUpdate = !selectedPlugin.pendingUpdate; + setPluginStates(newStates); + setSelectedPlugin({ + ...selectedPlugin, + pendingUpdate: !selectedPlugin.pendingUpdate + }); + } + } catch (error_1) { + setProcessError(error_1 instanceof Error ? error_1.message : 'Failed to check plugin update availability'); + } + } + }); + if (selectedPluginHasMcpb) { + menuItems.push({ + label: 'Configure', + action: async () => { + setIsLoadingConfig(true); + try { + const mcpServersSpec_0 = selectedPlugin.plugin.manifest.mcpServers; + let mcpbPath: string | null = null; + if (typeof mcpServersSpec_0 === 'string' && isMcpbSource(mcpServersSpec_0)) { + mcpbPath = mcpServersSpec_0; + } else if (Array.isArray(mcpServersSpec_0)) { + for (const spec_0 of mcpServersSpec_0) { + if (typeof spec_0 === 'string' && isMcpbSource(spec_0)) { + mcpbPath = spec_0; + break; + } + } + } + if (!mcpbPath) { + setProcessError('No MCPB file found in plugin'); + setIsLoadingConfig(false); + return; + } + const pluginId_6 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + const result_1 = await loadMcpbFile(mcpbPath, selectedPlugin.plugin.path, pluginId_6, undefined, undefined, true); + if ('status' in result_1 && result_1.status === 'needs-config') { + setConfigNeeded(result_1); + setViewState('configuring'); + } else { + setProcessError('Failed to load MCPB for configuration'); + } + } catch (err_2) { + const errorMsg = errorMessage(err_2); + setProcessError(`Failed to load configuration: ${errorMsg}`); + } finally { + setIsLoadingConfig(false); + } + } + }); + } + if (selectedPlugin.plugin.manifest.userConfig && Object.keys(selectedPlugin.plugin.manifest.userConfig).length > 0) { + menuItems.push({ + label: 'Configure options', + action: () => { + setViewState({ + type: 'configuring-options', + schema: selectedPlugin.plugin.manifest.userConfig! + }); + } + }); + } + menuItems.push({ + label: 'Update now', + action: () => void handleSingleOperation('update') + }); + menuItems.push({ + label: 'Uninstall', + action: () => void handleSingleOperation('uninstall') + }); + } + if (selectedPlugin.plugin.manifest.homepage) { + menuItems.push({ + label: 'Open homepage', + action: () => void openBrowser(selectedPlugin.plugin.manifest.homepage!) + }); + } + if (selectedPlugin.plugin.manifest.repository) { + menuItems.push({ + // Generic label — manifest.repository can be GitLab, Bitbucket, + // Azure DevOps, etc. (gh-31598). pluginDetailsHelpers.tsx:74 keeps + // 'View on GitHub' because that path has an explicit isGitHub check. + label: 'View repository', + action: () => void openBrowser(selectedPlugin.plugin.manifest.repository!) + }); + } + menuItems.push({ + label: 'Back to plugin list', + action: () => { + setViewState('plugin-list'); + setSelectedPlugin(null); + setProcessError(null); + } + }); + return menuItems; + }, [viewState, selectedPlugin, selectedPluginHasMcpb, pluginStates]); + + // Plugin-details navigation + useKeybindings({ + 'select:previous': () => { + if (detailsMenuIndex > 0) { + setDetailsMenuIndex(detailsMenuIndex - 1); + } + }, + 'select:next': () => { + if (detailsMenuIndex < detailsMenuItems.length - 1) { + setDetailsMenuIndex(detailsMenuIndex + 1); + } + }, + 'select:accept': () => { + if (detailsMenuItems[detailsMenuIndex]) { + detailsMenuItems[detailsMenuIndex]!.action(); + } + } + }, { + context: 'Select', + isActive: viewState === 'plugin-details' && !!selectedPlugin + }); + + // Failed-plugin-details: only "Uninstall" option, handle Enter + useKeybindings({ + 'select:accept': () => { + if (typeof viewState === 'object' && viewState.type === 'failed-plugin-details') { + void (async () => { + setIsProcessing(true); + setProcessError(null); + const pluginId_7 = viewState.plugin.id; + const pluginScope_1 = viewState.plugin.scope; + // Pass scope to uninstallPluginOp so it can find the correct V2 + // installation record and clean up on-disk files. Fall back to + // default scope if not installable (e.g. 'managed', though that + // case is guarded by isActive below). deleteDataDir=false: this + // is a recovery path for a plugin that failed to load — it may + // be reinstallable, so don't nuke ${CLAUDE_PLUGIN_DATA} silently. + // The normal uninstall path prompts; this one preserves. + const result_2 = isInstallableScope(pluginScope_1) ? await uninstallPluginOp(pluginId_7, pluginScope_1, false) : await uninstallPluginOp(pluginId_7, 'user', false); + let success = result_2.success; + if (!success) { + // Plugin was never installed (only in enabledPlugins settings). + // Remove directly from all editable settings sources. + const editableSources = ['userSettings' as const, 'projectSettings' as const, 'localSettings' as const]; + for (const source of editableSources) { + const settings = getSettingsForSource(source); + if (settings?.enabledPlugins?.[pluginId_7] !== undefined) { + updateSettingsForSource(source, { + enabledPlugins: { + ...settings.enabledPlugins, + [pluginId_7]: undefined + } + }); + success = true; + } + } + // Clear memoized caches so next loadAllPlugins() picks up settings changes + clearAllCaches(); + } + if (success) { + if (onManageComplete) { + await onManageComplete(); + } + setIsProcessing(false); + // Return to list (don't setResult — that closes the whole dialog) + setViewState('plugin-list'); + } else { + setIsProcessing(false); + setProcessError(result_2.message); + } + })(); + } + } + }, { + context: 'Select', + isActive: typeof viewState === 'object' && viewState.type === 'failed-plugin-details' && viewState.plugin.scope !== 'managed' + }); + + // Confirm-project-uninstall: y/enter disables in settings.local.json, n/escape cancels + useKeybindings({ + 'confirm:yes': () => { + if (!selectedPlugin) return; + setIsProcessing(true); + setProcessError(null); + const pluginId_8 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + // Write `false` directly — disablePluginOp's cross-scope guard would + // reject this (plugin isn't in localSettings yet; the override IS the + // point). + const { + error: error_2 + } = updateSettingsForSource('localSettings', { + enabledPlugins: { + ...getSettingsForSource('localSettings')?.enabledPlugins, + [pluginId_8]: false + } + }); + if (error_2) { + setIsProcessing(false); + setProcessError(`Failed to write settings: ${error_2.message}`); + return; + } + clearAllCaches(); + setResult(`✓ Disabled ${selectedPlugin.plugin.name} in .claude/settings.local.json. Run /reload-plugins to apply.`); + if (onManageComplete) void onManageComplete(); + setParentViewState({ + type: 'menu' + }); + }, + 'confirm:no': () => { + setViewState('plugin-details'); + setProcessError(null); + } + }, { + context: 'Confirmation', + isActive: viewState === 'confirm-project-uninstall' && !!selectedPlugin && !isProcessing + }); + + // Confirm-data-cleanup: y uninstalls + deletes data dir, n uninstalls + keeps, + // esc cancels. Raw useInput because: (1) the Confirmation context maps + // enter→confirm:yes, which would make Enter delete the data directory — a + // destructive default the UI text ("y to delete · n to keep") doesn't + // advertise; (2) unlike confirm-project-uninstall (which uses useKeybindings + // where n and escape both map to confirm:no), here n and escape are DIFFERENT + // actions (keep-data vs cancel), so this deliberately stays on raw useInput. + // eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw y/n/esc; Enter must not trigger destructive delete + useInput((input, key) => { + if (!selectedPlugin) return; + const pluginId_9 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + const pluginScope_2 = selectedPlugin.scope; + // Dialog is only reachable from the uninstall case (which guards on + // isBuiltin), but TS can't track that across viewState transitions. + if (!pluginScope_2 || pluginScope_2 === 'builtin' || !isInstallableScope(pluginScope_2)) return; + const doUninstall = async (deleteDataDir: boolean) => { + setIsProcessing(true); + setProcessError(null); + try { + const result_3 = await uninstallPluginOp(pluginId_9, pluginScope_2, deleteDataDir); + if (!result_3.success) throw new Error(result_3.message); + clearAllCaches(); + const suffix = deleteDataDir ? '' : ' · data preserved'; + setResult(`${figures.tick} ${result_3.message}${suffix}`); + if (onManageComplete) void onManageComplete(); + setParentViewState({ + type: 'menu' + }); + } catch (e_0) { + setIsProcessing(false); + setProcessError(e_0 instanceof Error ? e_0.message : String(e_0)); + } + }; + if (input === 'y' || input === 'Y') { + void doUninstall(true); + } else if (input === 'n' || input === 'N') { + void doUninstall(false); + } else if (key.escape) { + setViewState('plugin-details'); + setProcessError(null); + } + }, { + isActive: typeof viewState === 'object' && viewState.type === 'confirm-data-cleanup' && !!selectedPlugin && !isProcessing + }); + + // Reset selection when search query changes + React.useEffect(() => { + setSelectedIndex(0); + }, [searchQuery]); + + // Handle input for entering search mode (text input handled by useSearchInput hook) + // eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input + useInput((input_0, key_0) => { + const keyIsNotCtrlOrMeta = !key_0.ctrl && !key_0.meta; + if (isSearchMode) { + // Text input is handled by useSearchInput hook + return; + } + + // Enter search mode with '/' or any printable character (except navigation keys) + if (input_0 === '/' && keyIsNotCtrlOrMeta) { + setIsSearchMode(true); + setSearchQuery(''); + setSelectedIndex(0); + } else if (keyIsNotCtrlOrMeta && input_0.length > 0 && !/^\s+$/.test(input_0) && input_0 !== 'j' && input_0 !== 'k' && input_0 !== ' ') { + setIsSearchMode(true); + setSearchQuery(input_0); + setSelectedIndex(0); + } + }, { + isActive: viewState === 'plugin-list' + }); + + // Loading state + if (loading) { + return Loading installed plugins…; + } + + // No plugins or MCPs installed + if (unifiedItems.length === 0) { + return + + Manage plugins + + No plugins or MCP servers installed. + + Esc to go back + + ; + } + if (typeof viewState === 'object' && viewState.type === 'plugin-options' && selectedPlugin) { + const pluginId_10 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + function finish(msg: string): void { + setResult(msg); + // Plugin is enabled regardless of whether config was saved or + // skipped — onManageComplete → markPluginsChanged → the + // persistent "run /reload-plugins" notice. + if (onManageComplete) { + void onManageComplete(); + } + setParentViewState({ + type: 'menu' + }); + } + return { + switch (outcome) { + case 'configured': + finish(`✓ Enabled and configured ${selectedPlugin.plugin.name}. Run /reload-plugins to apply.`); + break; + case 'skipped': + finish(`✓ Enabled ${selectedPlugin.plugin.name}. Run /reload-plugins to apply.`); + break; + case 'error': + finish(`Failed to save configuration: ${detail}`); + break; + } + }} />; + } + + // Configure options (from the Manage menu) + if (typeof viewState === 'object' && viewState.type === 'configuring-options' && selectedPlugin) { + const pluginId_11 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + return { + try { + savePluginOptions(pluginId_11, values, viewState.schema); + clearAllCaches(); + setResult('Configuration saved. Run /reload-plugins for changes to take effect.'); + } catch (err_3) { + setProcessError(`Failed to save configuration: ${errorMessage(err_3)}`); + } + setViewState('plugin-details'); + }} onCancel={() => setViewState('plugin-details')} />; + } + + // Configuration view + if (viewState === 'configuring' && configNeeded && selectedPlugin) { + const pluginId_12 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + async function handleSave(config: UserConfigValues) { + if (!configNeeded || !selectedPlugin) return; + try { + // Find MCPB path again + const mcpServersSpec_1 = selectedPlugin.plugin.manifest.mcpServers; + let mcpbPath_0: string | null = null; + if (typeof mcpServersSpec_1 === 'string' && isMcpbSource(mcpServersSpec_1)) { + mcpbPath_0 = mcpServersSpec_1; + } else if (Array.isArray(mcpServersSpec_1)) { + for (const spec_1 of mcpServersSpec_1) { + if (typeof spec_1 === 'string' && isMcpbSource(spec_1)) { + mcpbPath_0 = spec_1; + break; + } + } + } + if (!mcpbPath_0) { + setProcessError('No MCPB file found'); + setViewState('plugin-details'); + return; + } + + // Reload with provided config + await loadMcpbFile(mcpbPath_0, selectedPlugin.plugin.path, pluginId_12, undefined, config); + + // Success - go back to details + setProcessError(null); + setConfigNeeded(null); + setViewState('plugin-details'); + setResult('Configuration saved. Run /reload-plugins for changes to take effect.'); + } catch (err_4) { + const errorMsg_0 = errorMessage(err_4); + setProcessError(`Failed to save configuration: ${errorMsg_0}`); + setViewState('plugin-details'); + } + } + function handleCancel() { + setConfigNeeded(null); + setViewState('plugin-details'); + } + return ; + } + + // Flagged plugin detail view + if (typeof viewState === 'object' && viewState.type === 'flagged-detail') { + const fp = viewState.plugin; + return + + + {fp.name} @ {fp.marketplace} + + + + + Status: + Removed + + + + + Removed from marketplace · reason: {fp.reason} + + {fp.text} + + Flagged on {new Date(fp.flaggedAt).toLocaleDateString()} + + + + + + {figures.pointer} + Dismiss + + + + + + + + ; + } + + // Confirm-project-uninstall: warn about shared .claude/settings.json, + // offer to disable in settings.local.json instead. + if (viewState === 'confirm-project-uninstall' && selectedPlugin) { + return + + {selectedPlugin.plugin.name} is enabled in .claude/settings.json + (shared with your team) + + + Disable it just for you in .claude/settings.local.json? + + This has the same effect as uninstalling, without affecting other + contributors. + + + {processError && + {processError} + } + + {isProcessing ? Disabling… : + + + } + + ; + } + + // Confirm-data-cleanup: prompt before deleting ${CLAUDE_PLUGIN_DATA} dir + if (typeof viewState === 'object' && viewState.type === 'confirm-data-cleanup' && selectedPlugin) { + return + + {selectedPlugin.plugin.name} has {viewState.size.human} of persistent + data + + + Delete it along with the plugin? + + {pluginDataDirPath(`${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`)} + + + {processError && + {processError} + } + + {isProcessing ? Uninstalling… : + y to delete · n to keep ·{' '} + esc to cancel + } + + ; + } + + // Plugin details view + if (viewState === 'plugin-details' && selectedPlugin) { + const mergedSettings_2 = getSettings_DEPRECATED(); // Use merged settings to respect all layers + const pluginId_13 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`; + const isEnabled_2 = mergedSettings_2?.enabledPlugins?.[pluginId_13] !== false; + + // Compute plugin errors section + const filteredPluginErrors = pluginErrors.filter(e_1 => 'plugin' in e_1 && e_1.plugin === selectedPlugin.plugin.name || e_1.source === pluginId_13 || e_1.source.startsWith(`${selectedPlugin.plugin.name}@`)); + const pluginErrorsSection = filteredPluginErrors.length === 0 ? null : + + {filteredPluginErrors.length}{' '} + {plural(filteredPluginErrors.length, 'error')}: + + {filteredPluginErrors.map((error_3, i_0) => { + const guidance = getErrorGuidance(error_3); + return + {formatErrorMessage(error_3)} + {guidance && + {figures.arrowRight} {guidance} + } + ; + })} + ; + return + + + {selectedPlugin.plugin.name} @ {selectedPlugin.marketplace} + + + + {/* Scope */} + + Scope: + {selectedPlugin.scope || 'user'} + + + {/* Plugin details */} + {selectedPlugin.plugin.manifest.version && + Version: + {selectedPlugin.plugin.manifest.version} + } + + {selectedPlugin.plugin.manifest.description && + {selectedPlugin.plugin.manifest.description} + } + + {selectedPlugin.plugin.manifest.author && + Author: + {selectedPlugin.plugin.manifest.author.name} + } + + {/* Current status */} + + Status: + + {isEnabled_2 ? 'Enabled' : 'Disabled'} + + {selectedPlugin.pendingUpdate && · Marked for update} + + + {/* Installed components */} + + + {/* Plugin errors */} + {pluginErrorsSection} + + {/* Menu */} + + {detailsMenuItems.map((item_9, index_0) => { + const isSelected = index_0 === detailsMenuIndex; + return + {isSelected && {figures.pointer} } + {!isSelected && {' '}} + + {item_9.label} + + ; + })} + + + {/* Processing state */} + {isProcessing && + Processing… + } + + {/* Error message */} + {processError && + {processError} + } + + + + + + + + + + + ; + } + + // Failed plugin detail view + if (typeof viewState === 'object' && viewState.type === 'failed-plugin-details') { + const failedPlugin_0 = viewState.plugin; + const firstError = failedPlugin_0.errors[0]; + const errorMessage_0 = firstError ? formatErrorMessage(firstError) : 'Failed to load'; + return + + {failedPlugin_0.name} + @ {failedPlugin_0.marketplace} + ({failedPlugin_0.scope}) + + {errorMessage_0} + + {failedPlugin_0.scope === 'managed' ? + + Managed by your organization — contact your admin + + : + {figures.pointer} + Remove + } + + {isProcessing && Processing…} + {processError && {processError}} + + + + + {failedPlugin_0.scope !== 'managed' && } + + + + + ; + } + + // MCP detail view + if (typeof viewState === 'object' && viewState.type === 'mcp-detail') { + const client_3 = viewState.client; + const serverToolsCount = filterToolsByServer(mcpTools, client_3.name).length; + + // Common handlers for MCP menus + const handleMcpViewTools = () => { + setViewState({ + type: 'mcp-tools', + client: client_3 + }); + }; + const handleMcpCancel = () => { + setViewState('plugin-list'); + }; + const handleMcpComplete = (result_4?: string) => { + if (result_4) { + setResult(result_4); + } + setViewState('plugin-list'); + }; + + // Transform MCPServerConnection to appropriate ServerInfo type + const scope_5 = client_3.config.scope; + const configType = client_3.config.type; + if (configType === 'stdio') { + const server: StdioServerInfo = { + name: client_3.name, + client: client_3, + scope: scope_5, + transport: 'stdio', + config: client_3.config as McpStdioServerConfig + }; + return ; + } else if (configType === 'sse') { + const server_0: SSEServerInfo = { + name: client_3.name, + client: client_3, + scope: scope_5, + transport: 'sse', + isAuthenticated: undefined, + config: client_3.config as McpSSEServerConfig + }; + return ; + } else if (configType === 'http') { + const server_1: HTTPServerInfo = { + name: client_3.name, + client: client_3, + scope: scope_5, + transport: 'http', + isAuthenticated: undefined, + config: client_3.config as McpHTTPServerConfig + }; + return ; + } else if (configType === 'claudeai-proxy') { + const server_2: ClaudeAIServerInfo = { + name: client_3.name, + client: client_3, + scope: scope_5, + transport: 'claudeai-proxy', + isAuthenticated: undefined, + config: client_3.config as McpClaudeAIProxyServerConfig + }; + return ; + } + + // Fallback - shouldn't happen but handle gracefully + setViewState('plugin-list'); + return null; + } + + // MCP tools view + if (typeof viewState === 'object' && viewState.type === 'mcp-tools') { + const client_4 = viewState.client; + const scope_6 = client_4.config.scope; + const configType_0 = client_4.config.type; + + // Build ServerInfo for MCPToolListView + let server_3: StdioServerInfo | SSEServerInfo | HTTPServerInfo | ClaudeAIServerInfo; + if (configType_0 === 'stdio') { + server_3 = { + name: client_4.name, + client: client_4, + scope: scope_6, + transport: 'stdio', + config: client_4.config as McpStdioServerConfig + }; + } else if (configType_0 === 'sse') { + server_3 = { + name: client_4.name, + client: client_4, + scope: scope_6, + transport: 'sse', + isAuthenticated: undefined, + config: client_4.config as McpSSEServerConfig + }; + } else if (configType_0 === 'http') { + server_3 = { + name: client_4.name, + client: client_4, + scope: scope_6, + transport: 'http', + isAuthenticated: undefined, + config: client_4.config as McpHTTPServerConfig + }; + } else { + server_3 = { + name: client_4.name, + client: client_4, + scope: scope_6, + transport: 'claudeai-proxy', + isAuthenticated: undefined, + config: client_4.config as McpClaudeAIProxyServerConfig + }; + } + return { + setViewState({ + type: 'mcp-tool-detail', + client: client_4, + tool + }); + }} onBack={() => setViewState({ + type: 'mcp-detail', + client: client_4 + })} />; + } + + // MCP tool detail view + if (typeof viewState === 'object' && viewState.type === 'mcp-tool-detail') { + const { + client: client_5, + tool: tool_0 + } = viewState; + const scope_7 = client_5.config.scope; + const configType_1 = client_5.config.type; + + // Build ServerInfo for MCPToolDetailView + let server_4: StdioServerInfo | SSEServerInfo | HTTPServerInfo | ClaudeAIServerInfo; + if (configType_1 === 'stdio') { + server_4 = { + name: client_5.name, + client: client_5, + scope: scope_7, + transport: 'stdio', + config: client_5.config as McpStdioServerConfig + }; + } else if (configType_1 === 'sse') { + server_4 = { + name: client_5.name, + client: client_5, + scope: scope_7, + transport: 'sse', + isAuthenticated: undefined, + config: client_5.config as McpSSEServerConfig + }; + } else if (configType_1 === 'http') { + server_4 = { + name: client_5.name, + client: client_5, + scope: scope_7, + transport: 'http', + isAuthenticated: undefined, + config: client_5.config as McpHTTPServerConfig + }; + } else { + server_4 = { + name: client_5.name, + client: client_5, + scope: scope_7, + transport: 'claudeai-proxy', + isAuthenticated: undefined, + config: client_5.config as McpClaudeAIProxyServerConfig + }; + } + return setViewState({ + type: 'mcp-tools', + client: client_5 + })} />; + } + + // Plugin list view (main management interface) + const visibleItems = pagination.getVisibleItems(filteredItems); + return + {/* Search box */} + + + + + {/* No search results */} + {filteredItems.length === 0 && searchQuery && + No items match "{searchQuery}" + } + + {/* Scroll up indicator */} + {pagination.scrollPosition.canScrollUp && + {figures.arrowUp} more above + } + + {/* Unified list of plugins and MCPs grouped by scope */} + {visibleItems.map((item_10, visibleIndex) => { + const actualIndex = pagination.toActualIndex(visibleIndex); + const isSelected_0 = actualIndex === selectedIndex && !isSearchMode; + + // Check if we need to show a scope header + const prevItem = visibleIndex > 0 ? visibleItems[visibleIndex - 1] : null; + const showScopeHeader = !prevItem || prevItem.scope !== item_10.scope; + + // Get scope label + const getScopeLabel = (scope_8: string): string => { + switch (scope_8) { + case 'flagged': + return 'Flagged'; + case 'project': + return 'Project'; + case 'local': + return 'Local'; + case 'user': + return 'User'; + case 'enterprise': + return 'Enterprise'; + case 'managed': + return 'Managed'; + case 'builtin': + return 'Built-in'; + case 'dynamic': + return 'Built-in'; + default: + return scope_8; + } + }; + return + {showScopeHeader && 0 ? 1 : 0} paddingLeft={2}> + + {getScopeLabel(item_10.scope)} + + } + + ; + })} + + {/* Scroll down indicator */} + {pagination.scrollPosition.canScrollDown && + {figures.arrowDown} more below + } + + {/* Help text */} + + + + type to search + + + + + + + + {/* Reload disclaimer for plugin changes */} + {pendingToggles.size > 0 && + + Run /reload-plugins to apply changes + + } + ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","Dirent","fs","path","React","useCallback","useEffect","useMemo","useRef","useState","ConfigurableShortcutHint","Byline","MCPRemoteServerMenu","MCPStdioServerMenu","MCPToolDetailView","MCPToolListView","ClaudeAIServerInfo","HTTPServerInfo","SSEServerInfo","StdioServerInfo","SearchBox","useSearchInput","useTerminalSize","Box","Text","useInput","useTerminalFocus","useKeybinding","useKeybindings","getBuiltinPluginDefinition","useMcpToggleEnabled","MCPServerConnection","McpClaudeAIProxyServerConfig","McpHTTPServerConfig","McpSSEServerConfig","McpStdioServerConfig","filterToolsByServer","disablePluginOp","enablePluginOp","getPluginInstallationFromV2","isInstallableScope","isPluginEnabledAtProjectScope","uninstallPluginOp","updatePluginOp","useAppState","Tool","LoadedPlugin","PluginError","count","openBrowser","logForDebugging","errorMessage","toError","logError","clearAllCaches","loadInstalledPluginsV2","getMarketplace","isMcpbSource","loadMcpbFile","McpbNeedsConfigResult","UserConfigValues","getPluginDataDirSize","pluginDataDirPath","getFlaggedPlugins","markFlaggedPluginsSeen","removeFlaggedPlugin","PersistablePluginScope","parsePluginIdentifier","loadAllPlugins","loadPluginOptions","PluginOptionSchema","savePluginOptions","isPluginBlockedByPolicy","getPluginEditableScopes","getSettings_DEPRECATED","getSettingsForSource","updateSettingsForSource","jsonParse","plural","formatErrorMessage","getErrorGuidance","PluginOptionsDialog","PluginOptionsFlow","ViewState","ParentViewState","UnifiedInstalledCell","UnifiedInstalledItem","usePagination","Props","setViewState","state","setResult","result","onManageComplete","Promise","onSearchModeChange","isActive","targetPlugin","targetMarketplace","action","FlaggedPluginInfo","id","name","marketplace","reason","text","flaggedAt","FailedPluginInfo","errors","scope","type","schema","size","bytes","human","plugin","client","tool","MarketplaceInfo","installedPlugins","enabledCount","disabledCount","PluginState","pendingEnable","pendingUpdate","getBaseFileNames","dirPath","entries","readdir","withFileTypes","filter","entry","isFile","endsWith","map","baseName","basename","error","errorMsg","level","getSkillDirNames","skillNames","isDirectory","isSymbolicLink","skillFilePath","join","st","stat","push","PluginComponentsDisplay","ReactNode","components","setComponents","commands","Record","agents","skills","hooks","mcpServers","loading","setLoading","setError","loadComponents","builtinDef","s","hookEvents","Object","keys","mcpServerNames","length","marketplaceData","pluginEntry","plugins","find","p","commandPathList","commandsPath","commandsPaths","commandList","commandPath","baseNames","agentPathList","agentsPath","agentsPaths","agentList","agentPath","skillPathList","skillsPath","skillsPaths","skillList","skillPath","skillDirNames","hooksList","hooksConfig","mcpServersList","err","Error","message","hasComponents","Array","isArray","String","checkIfLocalPlugin","pluginName","marketplaceName","source","filterManagedDisabledPlugins","split","ManagePlugins","setParentViewState","mcpClients","mcp","clients","mcpTools","tools","pluginErrors","flaggedPlugins","isSearchMode","setIsSearchModeRaw","setIsSearchMode","active","isTerminalFocused","columns","terminalWidth","viewState","query","searchQuery","setQuery","setSearchQuery","cursorOffset","searchCursorOffset","onExit","selectedPlugin","setSelectedPlugin","marketplaces","setMarketplaces","pluginStates","setPluginStates","pendingToggles","setPendingToggles","Map","hasAutoNavigated","pendingAutoActionRef","undefined","toggleMcpServer","handleBack","setProcessError","setConfigNeeded","context","getMcpStatus","unifiedItems","mergedSettings","pluginMcpMap","displayName","startsWith","parts","serverName","slice","existing","get","set","PluginWithChildren","item","originalScope","childMcps","pluginsWithChildren","pluginId","isEnabled","enabledPlugins","e","isBuiltin","description","manifest","errorCount","pendingToggle","matchedPluginIds","Set","matchedPluginNames","orphanErrorsBySource","has","pluginScopes","failedPluginItems","parsed","rawScope","standaloneMcps","config","status","scopeOrder","flagged","project","local","user","enterprise","managed","dynamic","builtin","unified","itemsByScope","displayScope","indented","failedPlugin","sortedScopes","sort","a","b","items","pluginGroups","standaloneMcpsInScope","i","group","nextItem","localeCompare","flaggedIds","filteredItems","lowerQuery","toLowerCase","includes","selectedIndex","setSelectedIndex","pagination","totalItems","maxVisible","detailsMenuIndex","setDetailsMenuIndex","isProcessing","setIsProcessing","processError","configNeeded","_isLoadingConfig","setIsLoadingConfig","selectedPluginHasMcpb","setSelectedPluginHasMcpb","detectMcpb","mcpServersSpec","hasMcpb","some","marketplaceDir","marketplaceJsonPath","content","readFile","spec","loadInstalledPlugins","enabled","disabled","allPlugins","pluginsByMarketplace","marketplaceInfos","allStates","current","targetName","targetMktFromId","effectiveTargetMarketplace","marketplacesToSearch","m","pluginState","failedItem","handleSingleOperation","operation","pluginScope","reverseDependents","enableResult","success","disableResult","installs","isLastScope","dataSize","alreadyUpToDate","newVersion","pluginIdNow","settingsAfter","enabledAfter","operationName","depWarn","handleSingleOperationRef","pending","handleToggle","currentPending","newPending","delete","handleAccept","select:previous","handleSelectionChange","select:next","handleFlaggedDismiss","detailsMenuItems","menuItems","label","localError","newStates","index","findIndex","mcpbPath","userConfig","homepage","repository","select:accept","editableSources","const","settings","confirm:yes","confirm:no","input","key","doUninstall","deleteDataDir","suffix","tick","escape","keyIsNotCtrlOrMeta","ctrl","meta","test","finish","msg","outcome","detail","values","handleSave","handleCancel","configSchema","existingConfig","fp","Date","toLocaleDateString","pointer","filteredPluginErrors","pluginErrorsSection","guidance","arrowRight","version","author","isSelected","firstError","serverToolsCount","handleMcpViewTools","handleMcpCancel","handleMcpComplete","configType","server","transport","isAuthenticated","visibleItems","getVisibleItems","scrollPosition","canScrollUp","arrowUp","visibleIndex","actualIndex","toActualIndex","prevItem","showScopeHeader","getScopeLabel","canScrollDown","arrowDown"],"sources":["ManagePlugins.tsx"],"sourcesContent":["import figures from 'figures'\nimport type { Dirent } from 'fs'\nimport * as fs from 'fs/promises'\nimport * as path from 'path'\nimport * as React from 'react'\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { MCPRemoteServerMenu } from '../../components/mcp/MCPRemoteServerMenu.js'\nimport { MCPStdioServerMenu } from '../../components/mcp/MCPStdioServerMenu.js'\nimport { MCPToolDetailView } from '../../components/mcp/MCPToolDetailView.js'\nimport { MCPToolListView } from '../../components/mcp/MCPToolListView.js'\nimport type {\n  ClaudeAIServerInfo,\n  HTTPServerInfo,\n  SSEServerInfo,\n  StdioServerInfo,\n} from '../../components/mcp/types.js'\nimport { SearchBox } from '../../components/SearchBox.js'\nimport { useSearchInput } from '../../hooks/useSearchInput.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input\nimport { Box, Text, useInput, useTerminalFocus } from '../../ink.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport { getBuiltinPluginDefinition } from '../../plugins/builtinPlugins.js'\nimport { useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js'\nimport type {\n  MCPServerConnection,\n  McpClaudeAIProxyServerConfig,\n  McpHTTPServerConfig,\n  McpSSEServerConfig,\n  McpStdioServerConfig,\n} from '../../services/mcp/types.js'\nimport { filterToolsByServer } from '../../services/mcp/utils.js'\nimport {\n  disablePluginOp,\n  enablePluginOp,\n  getPluginInstallationFromV2,\n  isInstallableScope,\n  isPluginEnabledAtProjectScope,\n  uninstallPluginOp,\n  updatePluginOp,\n} from '../../services/plugins/pluginOperations.js'\nimport { useAppState } from '../../state/AppState.js'\nimport type { Tool } from '../../Tool.js'\nimport type { LoadedPlugin, PluginError } from '../../types/plugin.js'\nimport { count } from '../../utils/array.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { errorMessage, toError } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport { loadInstalledPluginsV2 } from '../../utils/plugins/installedPluginsManager.js'\nimport { getMarketplace } from '../../utils/plugins/marketplaceManager.js'\nimport {\n  isMcpbSource,\n  loadMcpbFile,\n  type McpbNeedsConfigResult,\n  type UserConfigValues,\n} from '../../utils/plugins/mcpbHandler.js'\nimport {\n  getPluginDataDirSize,\n  pluginDataDirPath,\n} from '../../utils/plugins/pluginDirectories.js'\nimport {\n  getFlaggedPlugins,\n  markFlaggedPluginsSeen,\n  removeFlaggedPlugin,\n} from '../../utils/plugins/pluginFlagging.js'\nimport {\n  type PersistablePluginScope,\n  parsePluginIdentifier,\n} from '../../utils/plugins/pluginIdentifier.js'\nimport { loadAllPlugins } from '../../utils/plugins/pluginLoader.js'\nimport {\n  loadPluginOptions,\n  type PluginOptionSchema,\n  savePluginOptions,\n} from '../../utils/plugins/pluginOptionsStorage.js'\nimport { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js'\nimport { getPluginEditableScopes } from '../../utils/plugins/pluginStartupCheck.js'\nimport {\n  getSettings_DEPRECATED,\n  getSettingsForSource,\n  updateSettingsForSource,\n} from '../../utils/settings/settings.js'\nimport { jsonParse } from '../../utils/slowOperations.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport { formatErrorMessage, getErrorGuidance } from './PluginErrors.js'\nimport { PluginOptionsDialog } from './PluginOptionsDialog.js'\nimport { PluginOptionsFlow } from './PluginOptionsFlow.js'\nimport type { ViewState as ParentViewState } from './types.js'\nimport { UnifiedInstalledCell } from './UnifiedInstalledCell.js'\nimport type { UnifiedInstalledItem } from './unifiedTypes.js'\nimport { usePagination } from './usePagination.js'\n\ntype Props = {\n  setViewState: (state: ParentViewState) => void\n  setResult: (result: string | null) => void\n  onManageComplete?: () => void | Promise<void>\n  onSearchModeChange?: (isActive: boolean) => void\n  targetPlugin?: string\n  targetMarketplace?: string\n  action?: 'enable' | 'disable' | 'uninstall'\n}\n\ntype FlaggedPluginInfo = {\n  id: string\n  name: string\n  marketplace: string\n  reason: string\n  text: string\n  flaggedAt: string\n}\n\ntype FailedPluginInfo = {\n  id: string\n  name: string\n  marketplace: string\n  errors: PluginError[]\n  scope: PersistablePluginScope\n}\n\ntype ViewState =\n  | 'plugin-list'\n  | 'plugin-details'\n  | 'configuring'\n  | { type: 'plugin-options' }\n  | { type: 'configuring-options'; schema: PluginOptionSchema }\n  | 'confirm-project-uninstall'\n  | { type: 'confirm-data-cleanup'; size: { bytes: number; human: string } }\n  | { type: 'flagged-detail'; plugin: FlaggedPluginInfo }\n  | { type: 'failed-plugin-details'; plugin: FailedPluginInfo }\n  | { type: 'mcp-detail'; client: MCPServerConnection }\n  | { type: 'mcp-tools'; client: MCPServerConnection }\n  | { type: 'mcp-tool-detail'; client: MCPServerConnection; tool: Tool }\n\ntype MarketplaceInfo = {\n  name: string\n  installedPlugins: LoadedPlugin[]\n  enabledCount?: number\n  disabledCount?: number\n}\n\ntype PluginState = {\n  plugin: LoadedPlugin\n  marketplace: string\n  scope?: 'user' | 'project' | 'local' | 'managed' | 'builtin'\n  pendingEnable?: boolean // Toggle enable/disable\n  pendingUpdate?: boolean // Marked for update\n}\n\n/**\n * Get list of base file names (without .md extension) from a directory\n * @param dirPath The directory path to list files from\n * @returns Array of base file names without .md extension\n * @example\n * // Given directory contains: agent-sdk-verifier-py.md, agent-sdk-verifier-ts.md, README.txt\n * await getBaseFileNames('/path/to/agents')\n * // Returns: ['agent-sdk-verifier-py', 'agent-sdk-verifier-ts']\n */\nasync function getBaseFileNames(dirPath: string): Promise<string[]> {\n  try {\n    const entries = await fs.readdir(dirPath, { withFileTypes: true })\n    return entries\n      .filter((entry: Dirent) => entry.isFile() && entry.name.endsWith('.md'))\n      .map((entry: Dirent) => {\n        // Remove .md extension specifically\n        const baseName = path.basename(entry.name, '.md')\n        return baseName\n      })\n  } catch (error) {\n    const errorMsg = errorMessage(error)\n    logForDebugging(\n      `Failed to read plugin components from ${dirPath}: ${errorMsg}`,\n      { level: 'error' },\n    )\n    logError(toError(error))\n    // Return empty array to allow graceful degradation - plugin details can still be shown\n    return []\n  }\n}\n\n/**\n * Get list of skill directory names from a skills directory\n * Skills are directories containing a SKILL.md file\n * @param dirPath The skills directory path to scan\n * @returns Array of skill directory names that contain SKILL.md\n * @example\n * // Given directory contains: my-skill/SKILL.md, another-skill/SKILL.md, README.txt\n * await getSkillDirNames('/path/to/skills')\n * // Returns: ['my-skill', 'another-skill']\n */\nasync function getSkillDirNames(dirPath: string): Promise<string[]> {\n  try {\n    const entries = await fs.readdir(dirPath, { withFileTypes: true })\n    const skillNames: string[] = []\n\n    for (const entry of entries) {\n      // Check if it's a directory or symlink (symlinks may point to skill directories)\n      if (entry.isDirectory() || entry.isSymbolicLink()) {\n        // Check if this directory contains a SKILL.md file\n        const skillFilePath = path.join(dirPath, entry.name, 'SKILL.md')\n        try {\n          const st = await fs.stat(skillFilePath)\n          if (st.isFile()) {\n            skillNames.push(entry.name)\n          }\n        } catch {\n          // No SKILL.md file in this directory, skip it\n        }\n      }\n    }\n\n    return skillNames\n  } catch (error) {\n    const errorMsg = errorMessage(error)\n    logForDebugging(\n      `Failed to read skill directories from ${dirPath}: ${errorMsg}`,\n      { level: 'error' },\n    )\n    logError(toError(error))\n    // Return empty array to allow graceful degradation - plugin details can still be shown\n    return []\n  }\n}\n\n// Component to display installed plugin components\nfunction PluginComponentsDisplay({\n  plugin,\n  marketplace,\n}: {\n  plugin: LoadedPlugin\n  marketplace: string\n}): React.ReactNode {\n  const [components, setComponents] = useState<{\n    commands?: string | string[] | Record<string, unknown> | null\n    agents?: string | string[] | Record<string, unknown> | null\n    skills?: string | string[] | Record<string, unknown> | null\n    hooks?: unknown\n    mcpServers?: unknown\n  } | null>(null)\n  const [loading, setLoading] = useState(true)\n  const [error, setError] = useState<string | null>(null)\n\n  useEffect(() => {\n    async function loadComponents() {\n      try {\n        // Built-in plugins don't have a marketplace entry — read from the\n        // registered definition directly.\n        if (marketplace === 'builtin') {\n          const builtinDef = getBuiltinPluginDefinition(plugin.name)\n          if (builtinDef) {\n            const skillNames = builtinDef.skills?.map(s => s.name) ?? []\n            const hookEvents = builtinDef.hooks\n              ? Object.keys(builtinDef.hooks)\n              : []\n            const mcpServerNames = builtinDef.mcpServers\n              ? Object.keys(builtinDef.mcpServers)\n              : []\n            setComponents({\n              commands: null,\n              agents: null,\n              skills: skillNames.length > 0 ? skillNames : null,\n              hooks: hookEvents.length > 0 ? hookEvents : null,\n              mcpServers: mcpServerNames.length > 0 ? mcpServerNames : null,\n            })\n          } else {\n            setError(`Built-in plugin ${plugin.name} not found`)\n          }\n          setLoading(false)\n          return\n        }\n\n        const marketplaceData = await getMarketplace(marketplace)\n        // Find the plugin entry in the array\n        const pluginEntry = marketplaceData.plugins.find(\n          p => p.name === plugin.name,\n        )\n        if (pluginEntry) {\n          // Combine commands from both sources\n          const commandPathList = []\n          if (plugin.commandsPath) {\n            commandPathList.push(plugin.commandsPath)\n          }\n          if (plugin.commandsPaths) {\n            commandPathList.push(...plugin.commandsPaths)\n          }\n\n          // Get base file names from all command paths\n          const commandList: string[] = []\n          for (const commandPath of commandPathList) {\n            if (typeof commandPath === 'string') {\n              // commandPath is already a full path\n              const baseNames = await getBaseFileNames(commandPath)\n              commandList.push(...baseNames)\n            }\n          }\n\n          // Combine agents from both sources\n          const agentPathList = []\n          if (plugin.agentsPath) {\n            agentPathList.push(plugin.agentsPath)\n          }\n          if (plugin.agentsPaths) {\n            agentPathList.push(...plugin.agentsPaths)\n          }\n\n          // Get base file names from all agent paths\n          const agentList: string[] = []\n          for (const agentPath of agentPathList) {\n            if (typeof agentPath === 'string') {\n              // agentPath is already a full path\n              const baseNames = await getBaseFileNames(agentPath)\n              agentList.push(...baseNames)\n            }\n          }\n\n          // Combine skills from both sources\n          const skillPathList = []\n          if (plugin.skillsPath) {\n            skillPathList.push(plugin.skillsPath)\n          }\n          if (plugin.skillsPaths) {\n            skillPathList.push(...plugin.skillsPaths)\n          }\n\n          // Get skill directory names from all skill paths\n          // Skills are directories containing SKILL.md files\n          const skillList: string[] = []\n          for (const skillPath of skillPathList) {\n            if (typeof skillPath === 'string') {\n              // skillPath is already a full path to a skills directory\n              const skillDirNames = await getSkillDirNames(skillPath)\n              skillList.push(...skillDirNames)\n            }\n          }\n\n          // Combine hooks from both sources\n          const hooksList = []\n          if (plugin.hooksConfig) {\n            hooksList.push(Object.keys(plugin.hooksConfig))\n          }\n          if (pluginEntry.hooks) {\n            hooksList.push(pluginEntry.hooks)\n          }\n\n          // Combine MCP servers from both sources\n          const mcpServersList = []\n          if (plugin.mcpServers) {\n            mcpServersList.push(Object.keys(plugin.mcpServers))\n          }\n          if (pluginEntry.mcpServers) {\n            mcpServersList.push(pluginEntry.mcpServers)\n          }\n\n          setComponents({\n            commands: commandList.length > 0 ? commandList : null,\n            agents: agentList.length > 0 ? agentList : null,\n            skills: skillList.length > 0 ? skillList : null,\n            hooks: hooksList.length > 0 ? hooksList : null,\n            mcpServers: mcpServersList.length > 0 ? mcpServersList : null,\n          })\n        } else {\n          setError(`Plugin ${plugin.name} not found in marketplace`)\n        }\n      } catch (err) {\n        setError(\n          err instanceof Error ? err.message : 'Failed to load components',\n        )\n      } finally {\n        setLoading(false)\n      }\n    }\n    void loadComponents()\n  }, [\n    plugin.name,\n    plugin.commandsPath,\n    plugin.commandsPaths,\n    plugin.agentsPath,\n    plugin.agentsPaths,\n    plugin.skillsPath,\n    plugin.skillsPaths,\n    plugin.hooksConfig,\n    plugin.mcpServers,\n    marketplace,\n  ])\n\n  if (loading) {\n    return null // Don't show loading state for cleaner UI\n  }\n\n  if (error) {\n    return (\n      <Box flexDirection=\"column\" marginBottom={1}>\n        <Text bold>Components:</Text>\n        <Text dimColor>Error: {error}</Text>\n      </Box>\n    )\n  }\n\n  if (!components) {\n    return null // No components info available\n  }\n\n  const hasComponents =\n    components.commands ||\n    components.agents ||\n    components.skills ||\n    components.hooks ||\n    components.mcpServers\n\n  if (!hasComponents) {\n    return null // No components defined\n  }\n\n  return (\n    <Box flexDirection=\"column\" marginBottom={1}>\n      <Text bold>Installed components:</Text>\n      {components.commands ? (\n        <Text dimColor>\n          • Commands:{' '}\n          {typeof components.commands === 'string'\n            ? components.commands\n            : Array.isArray(components.commands)\n              ? components.commands.join(', ')\n              : Object.keys(components.commands).join(', ')}\n        </Text>\n      ) : null}\n      {components.agents ? (\n        <Text dimColor>\n          • Agents:{' '}\n          {typeof components.agents === 'string'\n            ? components.agents\n            : Array.isArray(components.agents)\n              ? components.agents.join(', ')\n              : Object.keys(components.agents).join(', ')}\n        </Text>\n      ) : null}\n      {components.skills ? (\n        <Text dimColor>\n          • Skills:{' '}\n          {typeof components.skills === 'string'\n            ? components.skills\n            : Array.isArray(components.skills)\n              ? components.skills.join(', ')\n              : Object.keys(components.skills).join(', ')}\n        </Text>\n      ) : null}\n      {components.hooks ? (\n        <Text dimColor>\n          • Hooks:{' '}\n          {typeof components.hooks === 'string'\n            ? components.hooks\n            : Array.isArray(components.hooks)\n              ? components.hooks.map(String).join(', ')\n              : typeof components.hooks === 'object' &&\n                  components.hooks !== null\n                ? Object.keys(components.hooks).join(', ')\n                : String(components.hooks)}\n        </Text>\n      ) : null}\n      {components.mcpServers ? (\n        <Text dimColor>\n          • MCP Servers:{' '}\n          {typeof components.mcpServers === 'string'\n            ? components.mcpServers\n            : Array.isArray(components.mcpServers)\n              ? components.mcpServers.map(String).join(', ')\n              : typeof components.mcpServers === 'object' &&\n                  components.mcpServers !== null\n                ? Object.keys(components.mcpServers).join(', ')\n                : String(components.mcpServers)}\n        </Text>\n      ) : null}\n    </Box>\n  )\n}\n\n/**\n * Check if a plugin is from a local source and cannot be remotely updated\n * @returns Error message if local, null if remote/updatable\n */\nasync function checkIfLocalPlugin(\n  pluginName: string,\n  marketplaceName: string,\n): Promise<string | null> {\n  const marketplace = await getMarketplace(marketplaceName)\n  const entry = marketplace?.plugins.find(p => p.name === pluginName)\n\n  if (entry && typeof entry.source === 'string') {\n    return `Local plugins cannot be updated remotely. To update, modify the source at: ${entry.source}`\n  }\n\n  return null\n}\n\n/**\n * Filter out plugins that are force-disabled by org policy (policySettings).\n * These are blocked by the organization and cannot be re-enabled by the user.\n * Checks policySettings directly rather than installation scope, since managed\n * settings don't create installation records with scope 'managed'.\n */\nexport function filterManagedDisabledPlugins(\n  plugins: LoadedPlugin[],\n): LoadedPlugin[] {\n  return plugins.filter(plugin => {\n    const marketplace = plugin.source.split('@')[1] || 'local'\n    return !isPluginBlockedByPolicy(`${plugin.name}@${marketplace}`)\n  })\n}\n\nexport function ManagePlugins({\n  setViewState: setParentViewState,\n  setResult,\n  onManageComplete,\n  onSearchModeChange,\n  targetPlugin,\n  targetMarketplace,\n  action,\n}: Props): React.ReactNode {\n  // App state for MCP access\n  const mcpClients = useAppState(s => s.mcp.clients)\n  const mcpTools = useAppState(s => s.mcp.tools)\n  const pluginErrors = useAppState(s => s.plugins.errors)\n  const flaggedPlugins = getFlaggedPlugins()\n\n  // Search state\n  const [isSearchMode, setIsSearchModeRaw] = useState(false)\n  const setIsSearchMode = useCallback(\n    (active: boolean) => {\n      setIsSearchModeRaw(active)\n      onSearchModeChange?.(active)\n    },\n    [onSearchModeChange],\n  )\n  const isTerminalFocused = useTerminalFocus()\n  const { columns: terminalWidth } = useTerminalSize()\n\n  // View state\n  const [viewState, setViewState] = useState<ViewState>('plugin-list')\n\n  const {\n    query: searchQuery,\n    setQuery: setSearchQuery,\n    cursorOffset: searchCursorOffset,\n  } = useSearchInput({\n    isActive: viewState === 'plugin-list' && isSearchMode,\n    onExit: () => {\n      setIsSearchMode(false)\n    },\n  })\n  const [selectedPlugin, setSelectedPlugin] = useState<PluginState | null>(null)\n\n  // Data state\n  const [marketplaces, setMarketplaces] = useState<MarketplaceInfo[]>([])\n  const [pluginStates, setPluginStates] = useState<PluginState[]>([])\n  const [loading, setLoading] = useState(true)\n  const [pendingToggles, setPendingToggles] = useState<\n    Map<string, 'will-enable' | 'will-disable'>\n  >(new Map())\n\n  // Guard to prevent auto-navigation from re-triggering after the user\n  // navigates away (targetPlugin is never cleared by the parent).\n  const hasAutoNavigated = useRef(false)\n  // Auto-action (enable/disable/uninstall) to fire after auto-navigation lands.\n  // Ref, not state: it's consumed by a one-shot effect that already re-runs on\n  // viewState/selectedPlugin, so a render-triggering state var would be redundant.\n  const pendingAutoActionRef = useRef<\n    'enable' | 'disable' | 'uninstall' | undefined\n  >(undefined)\n\n  // MCP toggle hook\n  const toggleMcpServer = useMcpToggleEnabled()\n\n  // Handle escape to go back - viewState-dependent navigation\n  const handleBack = React.useCallback(() => {\n    if (viewState === 'plugin-details') {\n      setViewState('plugin-list')\n      setSelectedPlugin(null)\n      setProcessError(null)\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'failed-plugin-details'\n    ) {\n      setViewState('plugin-list')\n      setProcessError(null)\n    } else if (viewState === 'configuring') {\n      setViewState('plugin-details')\n      setConfigNeeded(null)\n    } else if (\n      typeof viewState === 'object' &&\n      (viewState.type === 'plugin-options' ||\n        viewState.type === 'configuring-options')\n    ) {\n      // Cancel mid-sequence — plugin is already enabled, just bail to list.\n      // User can configure later via the Configure options menu if they want.\n      setViewState('plugin-list')\n      setSelectedPlugin(null)\n      setResult(\n        'Plugin enabled. Configuration skipped — run /reload-plugins to apply.',\n      )\n      if (onManageComplete) {\n        void onManageComplete()\n      }\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'flagged-detail'\n    ) {\n      setViewState('plugin-list')\n      setProcessError(null)\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'mcp-detail'\n    ) {\n      setViewState('plugin-list')\n      setProcessError(null)\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'mcp-tools'\n    ) {\n      setViewState({ type: 'mcp-detail', client: viewState.client })\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'mcp-tool-detail'\n    ) {\n      setViewState({ type: 'mcp-tools', client: viewState.client })\n    } else {\n      if (pendingToggles.size > 0) {\n        setResult('Run /reload-plugins to apply plugin changes.')\n        return\n      }\n      setParentViewState({ type: 'menu' })\n    }\n  }, [viewState, setParentViewState, pendingToggles, setResult])\n\n  // Escape when not in search mode - go back.\n  // Excludes confirm-project-uninstall (has its own confirm:no handler in\n  // Confirmation context — letting this fire would create competing handlers)\n  // and confirm-data-cleanup (uses raw useInput where n and escape are\n  // DIFFERENT actions: keep-data vs cancel).\n  useKeybinding('confirm:no', handleBack, {\n    context: 'Confirmation',\n    isActive:\n      (viewState !== 'plugin-list' || !isSearchMode) &&\n      viewState !== 'confirm-project-uninstall' &&\n      !(\n        typeof viewState === 'object' &&\n        viewState.type === 'confirm-data-cleanup'\n      ),\n  })\n\n  // Helper to get MCP status\n  const getMcpStatus = (\n    client: MCPServerConnection,\n  ): 'connected' | 'disabled' | 'pending' | 'needs-auth' | 'failed' => {\n    if (client.type === 'connected') return 'connected'\n    if (client.type === 'disabled') return 'disabled'\n    if (client.type === 'pending') return 'pending'\n    if (client.type === 'needs-auth') return 'needs-auth'\n    return 'failed'\n  }\n\n  // Derive unified items from plugins and MCP servers\n  const unifiedItems = useMemo(() => {\n    const mergedSettings = getSettings_DEPRECATED()\n\n    // Build map of plugin name -> child MCPs\n    // Plugin MCPs have names like \"plugin:pluginName:serverName\"\n    const pluginMcpMap = new Map<\n      string,\n      Array<{ displayName: string; client: MCPServerConnection }>\n    >()\n    for (const client of mcpClients) {\n      if (client.name.startsWith('plugin:')) {\n        const parts = client.name.split(':')\n        if (parts.length >= 3) {\n          const pluginName = parts[1]!\n          const serverName = parts.slice(2).join(':')\n          const existing = pluginMcpMap.get(pluginName) || []\n          existing.push({ displayName: serverName, client })\n          pluginMcpMap.set(pluginName, existing)\n        }\n      }\n    }\n\n    // Build plugin items (unsorted for now)\n    type PluginWithChildren = {\n      item: UnifiedInstalledItem & { type: 'plugin' }\n      originalScope: 'user' | 'project' | 'local' | 'managed' | 'builtin'\n      childMcps: Array<{ displayName: string; client: MCPServerConnection }>\n    }\n    const pluginsWithChildren: PluginWithChildren[] = []\n\n    for (const state of pluginStates) {\n      const pluginId = `${state.plugin.name}@${state.marketplace}`\n      const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false\n      const errors = pluginErrors.filter(\n        e =>\n          ('plugin' in e && e.plugin === state.plugin.name) ||\n          e.source === pluginId ||\n          e.source.startsWith(`${state.plugin.name}@`),\n      )\n\n      // Built-in plugins use 'builtin' scope; others look up from V2 data.\n      const originalScope = state.plugin.isBuiltin\n        ? 'builtin'\n        : state.scope || 'user'\n\n      pluginsWithChildren.push({\n        item: {\n          type: 'plugin',\n          id: pluginId,\n          name: state.plugin.name,\n          description: state.plugin.manifest.description,\n          marketplace: state.marketplace,\n          scope: originalScope,\n          isEnabled,\n          errorCount: errors.length,\n          errors,\n          plugin: state.plugin,\n          pendingEnable: state.pendingEnable,\n          pendingUpdate: state.pendingUpdate,\n          pendingToggle: pendingToggles.get(pluginId),\n        },\n        originalScope,\n        childMcps: pluginMcpMap.get(state.plugin.name) || [],\n      })\n    }\n\n    // Find orphan errors (errors for plugins that failed to load entirely)\n    const matchedPluginIds = new Set(\n      pluginsWithChildren.map(({ item }) => item.id),\n    )\n    const matchedPluginNames = new Set(\n      pluginsWithChildren.map(({ item }) => item.name),\n    )\n    const orphanErrorsBySource = new Map<string, typeof pluginErrors>()\n    for (const error of pluginErrors) {\n      if (\n        matchedPluginIds.has(error.source) ||\n        ('plugin' in error &&\n          typeof error.plugin === 'string' &&\n          matchedPluginNames.has(error.plugin))\n      ) {\n        continue\n      }\n      const existing = orphanErrorsBySource.get(error.source) || []\n      existing.push(error)\n      orphanErrorsBySource.set(error.source, existing)\n    }\n    const pluginScopes = getPluginEditableScopes()\n    const failedPluginItems: UnifiedInstalledItem[] = []\n    for (const [pluginId, errors] of orphanErrorsBySource) {\n      // Skip plugins that are already shown in the flagged section\n      if (pluginId in flaggedPlugins) continue\n      const parsed = parsePluginIdentifier(pluginId)\n      const pluginName = parsed.name || pluginId\n      const marketplace = parsed.marketplace || 'unknown'\n      const rawScope = pluginScopes.get(pluginId)\n      // 'flag' is session-only (from --plugin-dir / flagSettings) and undefined\n      // means the plugin isn't in any settings source. Default both to 'user'\n      // since UnifiedInstalledItem doesn't have a 'flag' scope variant.\n      const scope =\n        rawScope === 'flag' || rawScope === undefined ? 'user' : rawScope\n      failedPluginItems.push({\n        type: 'failed-plugin',\n        id: pluginId,\n        name: pluginName,\n        marketplace,\n        scope,\n        errorCount: errors.length,\n        errors,\n      })\n    }\n\n    // Build standalone MCP items\n    const standaloneMcps: UnifiedInstalledItem[] = []\n    for (const client of mcpClients) {\n      if (client.name === 'ide') continue\n      if (client.name.startsWith('plugin:')) continue\n\n      standaloneMcps.push({\n        type: 'mcp',\n        id: `mcp:${client.name}`,\n        name: client.name,\n        description: undefined,\n        scope: client.config.scope,\n        status: getMcpStatus(client),\n        client,\n      })\n    }\n\n    // Define scope order for display\n    const scopeOrder: Record<string, number> = {\n      flagged: -1,\n      project: 0,\n      local: 1,\n      user: 2,\n      enterprise: 3,\n      managed: 4,\n      dynamic: 5,\n      builtin: 6,\n    }\n\n    // Build final list by merging plugins (with their child MCPs) and standalone MCPs\n    // Group by scope to avoid duplicate scope headers\n    const unified: UnifiedInstalledItem[] = []\n\n    // Create a map of scope -> items for proper merging\n    const itemsByScope = new Map<string, UnifiedInstalledItem[]>()\n\n    // Add plugins with their child MCPs\n    for (const { item, originalScope, childMcps } of pluginsWithChildren) {\n      const scope = item.scope\n      if (!itemsByScope.has(scope)) {\n        itemsByScope.set(scope, [])\n      }\n      itemsByScope.get(scope)!.push(item)\n      // Add child MCPs right after the plugin, indented (use original scope, not 'flagged').\n      // Built-in plugins map to 'user' for display since MCP ConfigScope doesn't include 'builtin'.\n      for (const { displayName, client } of childMcps) {\n        const displayScope =\n          originalScope === 'builtin' ? 'user' : originalScope\n        if (!itemsByScope.has(displayScope)) {\n          itemsByScope.set(displayScope, [])\n        }\n        itemsByScope.get(displayScope)!.push({\n          type: 'mcp',\n          id: `mcp:${client.name}`,\n          name: displayName,\n          description: undefined,\n          scope: displayScope,\n          status: getMcpStatus(client),\n          client,\n          indented: true,\n        })\n      }\n    }\n\n    // Add standalone MCPs to their respective scope groups\n    for (const mcp of standaloneMcps) {\n      const scope = mcp.scope\n      if (!itemsByScope.has(scope)) {\n        itemsByScope.set(scope, [])\n      }\n      itemsByScope.get(scope)!.push(mcp)\n    }\n\n    // Add failed plugins to their respective scope groups\n    for (const failedPlugin of failedPluginItems) {\n      const scope = failedPlugin.scope\n      if (!itemsByScope.has(scope)) {\n        itemsByScope.set(scope, [])\n      }\n      itemsByScope.get(scope)!.push(failedPlugin)\n    }\n\n    // Add flagged (delisted) plugins from user settings.\n    // Reason/text are looked up from the cached security messages file.\n    for (const [pluginId, entry] of Object.entries(flaggedPlugins)) {\n      const parsed = parsePluginIdentifier(pluginId)\n      const pluginName = parsed.name || pluginId\n      const marketplace = parsed.marketplace || 'unknown'\n      if (!itemsByScope.has('flagged')) {\n        itemsByScope.set('flagged', [])\n      }\n      itemsByScope.get('flagged')!.push({\n        type: 'flagged-plugin',\n        id: pluginId,\n        name: pluginName,\n        marketplace,\n        scope: 'flagged',\n        reason: 'delisted',\n        text: 'Removed from marketplace',\n        flaggedAt: entry.flaggedAt,\n      })\n    }\n\n    // Sort scopes and build final list\n    const sortedScopes = [...itemsByScope.keys()].sort(\n      (a, b) => (scopeOrder[a] ?? 99) - (scopeOrder[b] ?? 99),\n    )\n\n    for (const scope of sortedScopes) {\n      const items = itemsByScope.get(scope)!\n\n      // Separate items into plugin groups (with their child MCPs) and standalone MCPs\n      // This preserves parent-child relationships that would be broken by naive sorting\n      const pluginGroups: UnifiedInstalledItem[][] = []\n      const standaloneMcpsInScope: UnifiedInstalledItem[] = []\n\n      let i = 0\n      while (i < items.length) {\n        const item = items[i]!\n        if (\n          item.type === 'plugin' ||\n          item.type === 'failed-plugin' ||\n          item.type === 'flagged-plugin'\n        ) {\n          // Collect the plugin and its child MCPs as a group\n          const group: UnifiedInstalledItem[] = [item]\n          i++\n          // Look ahead for indented child MCPs\n          let nextItem = items[i]\n          while (nextItem?.type === 'mcp' && nextItem.indented) {\n            group.push(nextItem)\n            i++\n            nextItem = items[i]\n          }\n          pluginGroups.push(group)\n        } else if (item.type === 'mcp' && !item.indented) {\n          // Standalone MCP (not a child of a plugin)\n          standaloneMcpsInScope.push(item)\n          i++\n        } else {\n          // Skip orphaned indented MCPs (shouldn't happen)\n          i++\n        }\n      }\n\n      // Sort plugin groups by the plugin name (first item in each group)\n      pluginGroups.sort((a, b) => a[0]!.name.localeCompare(b[0]!.name))\n\n      // Sort standalone MCPs by name\n      standaloneMcpsInScope.sort((a, b) => a.name.localeCompare(b.name))\n\n      // Build final list: plugins (with their children) first, then standalone MCPs\n      for (const group of pluginGroups) {\n        unified.push(...group)\n      }\n      unified.push(...standaloneMcpsInScope)\n    }\n\n    return unified\n  }, [pluginStates, mcpClients, pluginErrors, pendingToggles, flaggedPlugins])\n\n  // Mark flagged plugins as seen when the Installed view renders them.\n  // After 48 hours from seenAt, they auto-clear on next load.\n  const flaggedIds = useMemo(\n    () =>\n      unifiedItems\n        .filter(item => item.type === 'flagged-plugin')\n        .map(item => item.id),\n    [unifiedItems],\n  )\n  useEffect(() => {\n    if (flaggedIds.length > 0) {\n      void markFlaggedPluginsSeen(flaggedIds)\n    }\n  }, [flaggedIds])\n\n  // Filter items based on search query (matches name or description)\n  const filteredItems = useMemo(() => {\n    if (!searchQuery) return unifiedItems\n    const lowerQuery = searchQuery.toLowerCase()\n    return unifiedItems.filter(\n      item =>\n        item.name.toLowerCase().includes(lowerQuery) ||\n        ('description' in item &&\n          item.description?.toLowerCase().includes(lowerQuery)),\n    )\n  }, [unifiedItems, searchQuery])\n\n  // Selection state\n  const [selectedIndex, setSelectedIndex] = useState(0)\n\n  // Pagination for unified list (continuous scrolling)\n  const pagination = usePagination<UnifiedInstalledItem>({\n    totalItems: filteredItems.length,\n    selectedIndex,\n    maxVisible: 8,\n  })\n\n  // Details view state\n  const [detailsMenuIndex, setDetailsMenuIndex] = useState(0)\n  const [isProcessing, setIsProcessing] = useState(false)\n  const [processError, setProcessError] = useState<string | null>(null)\n\n  // Configuration state\n  const [configNeeded, setConfigNeeded] =\n    useState<McpbNeedsConfigResult | null>(null)\n  const [_isLoadingConfig, setIsLoadingConfig] = useState(false)\n  const [selectedPluginHasMcpb, setSelectedPluginHasMcpb] = useState(false)\n\n  // Detect if selected plugin has MCPB\n  // Reads raw marketplace.json to work with old cached marketplaces\n  useEffect(() => {\n    if (!selectedPlugin) {\n      setSelectedPluginHasMcpb(false)\n      return\n    }\n\n    async function detectMcpb() {\n      // Check plugin manifest first\n      const mcpServersSpec = selectedPlugin!.plugin.manifest.mcpServers\n      let hasMcpb = false\n\n      if (mcpServersSpec) {\n        hasMcpb =\n          (typeof mcpServersSpec === 'string' &&\n            isMcpbSource(mcpServersSpec)) ||\n          (Array.isArray(mcpServersSpec) &&\n            mcpServersSpec.some(s => typeof s === 'string' && isMcpbSource(s)))\n      }\n\n      // If not in manifest, read raw marketplace.json directly (bypassing schema validation)\n      // This works even with old cached marketplaces from before MCPB support\n      if (!hasMcpb) {\n        try {\n          const marketplaceDir = path.join(selectedPlugin!.plugin.path, '..')\n          const marketplaceJsonPath = path.join(\n            marketplaceDir,\n            '.claude-plugin',\n            'marketplace.json',\n          )\n\n          const content = await fs.readFile(marketplaceJsonPath, 'utf-8')\n          const marketplace = jsonParse(content)\n\n          const entry = marketplace.plugins?.find(\n            (p: { name: string }) => p.name === selectedPlugin!.plugin.name,\n          )\n\n          if (entry?.mcpServers) {\n            const spec = entry.mcpServers\n            hasMcpb =\n              (typeof spec === 'string' && isMcpbSource(spec)) ||\n              (Array.isArray(spec) &&\n                spec.some(\n                  (s: unknown) => typeof s === 'string' && isMcpbSource(s),\n                ))\n          }\n        } catch (err) {\n          logForDebugging(`Failed to read raw marketplace.json: ${err}`)\n        }\n      }\n\n      setSelectedPluginHasMcpb(hasMcpb)\n    }\n\n    void detectMcpb()\n  }, [selectedPlugin])\n\n  // Load installed plugins grouped by marketplace\n  useEffect(() => {\n    async function loadInstalledPlugins() {\n      setLoading(true)\n      try {\n        const { enabled, disabled } = await loadAllPlugins()\n        const mergedSettings = getSettings_DEPRECATED() // Use merged settings to respect all layers\n\n        const allPlugins = filterManagedDisabledPlugins([\n          ...enabled,\n          ...disabled,\n        ])\n\n        // Group plugins by marketplace\n        const pluginsByMarketplace: Record<string, LoadedPlugin[]> = {}\n        for (const plugin of allPlugins) {\n          const marketplace = plugin.source.split('@')[1] || 'local'\n          if (!pluginsByMarketplace[marketplace]) {\n            pluginsByMarketplace[marketplace] = []\n          }\n          pluginsByMarketplace[marketplace]!.push(plugin)\n        }\n\n        // Create marketplace info array with enabled/disabled counts\n        const marketplaceInfos: MarketplaceInfo[] = []\n        for (const [name, plugins] of Object.entries(pluginsByMarketplace)) {\n          const enabledCount = count(plugins, p => {\n            const pluginId = `${p.name}@${name}`\n            return mergedSettings?.enabledPlugins?.[pluginId] !== false\n          })\n          const disabledCount = plugins.length - enabledCount\n\n          marketplaceInfos.push({\n            name,\n            installedPlugins: plugins,\n            enabledCount,\n            disabledCount,\n          })\n        }\n\n        // Sort marketplaces: claude-plugin-directory first, then alphabetically\n        marketplaceInfos.sort((a, b) => {\n          if (a.name === 'claude-plugin-directory') return -1\n          if (b.name === 'claude-plugin-directory') return 1\n          return a.name.localeCompare(b.name)\n        })\n\n        setMarketplaces(marketplaceInfos)\n\n        // Build flat list of all plugin states\n        const allStates: PluginState[] = []\n        for (const marketplace of marketplaceInfos) {\n          for (const plugin of marketplace.installedPlugins) {\n            const pluginId = `${plugin.name}@${marketplace.name}`\n            // Built-in plugins don't have V2 install entries — skip the lookup.\n            const scope = plugin.isBuiltin\n              ? 'builtin'\n              : getPluginInstallationFromV2(pluginId).scope\n\n            allStates.push({\n              plugin,\n              marketplace: marketplace.name,\n              scope,\n              pendingEnable: undefined,\n              pendingUpdate: false,\n            })\n          }\n        }\n        setPluginStates(allStates)\n        setSelectedIndex(0)\n      } finally {\n        setLoading(false)\n      }\n    }\n\n    void loadInstalledPlugins()\n  }, [])\n\n  // Auto-navigate to target plugin if specified (once only)\n  useEffect(() => {\n    if (hasAutoNavigated.current) return\n    if (targetPlugin && marketplaces.length > 0 && !loading) {\n      // targetPlugin may be `name` or `name@marketplace` (parseArgs passes the\n      // raw arg through). Parse it so p.name matching works either way.\n      const { name: targetName, marketplace: targetMktFromId } =\n        parsePluginIdentifier(targetPlugin)\n      const effectiveTargetMarketplace = targetMarketplace ?? targetMktFromId\n\n      // Use targetMarketplace if provided, otherwise search all\n      const marketplacesToSearch = effectiveTargetMarketplace\n        ? marketplaces.filter(m => m.name === effectiveTargetMarketplace)\n        : marketplaces\n\n      // First check successfully loaded plugins\n      for (const marketplace of marketplacesToSearch) {\n        const plugin = marketplace.installedPlugins.find(\n          p => p.name === targetName,\n        )\n        if (plugin) {\n          // Get scope from V2 data for proper operation handling\n          const pluginId = `${plugin.name}@${marketplace.name}`\n          const { scope } = getPluginInstallationFromV2(pluginId)\n\n          const pluginState: PluginState = {\n            plugin,\n            marketplace: marketplace.name,\n            scope,\n            pendingEnable: undefined,\n            pendingUpdate: false,\n          }\n          setSelectedPlugin(pluginState)\n          setViewState('plugin-details')\n          pendingAutoActionRef.current = action\n          hasAutoNavigated.current = true\n          return\n        }\n      }\n\n      // Fall back to failed plugins (those with errors but not loaded)\n      const failedItem = unifiedItems.find(\n        item => item.type === 'failed-plugin' && item.name === targetName,\n      )\n      if (failedItem && failedItem.type === 'failed-plugin') {\n        setViewState({\n          type: 'failed-plugin-details',\n          plugin: {\n            id: failedItem.id,\n            name: failedItem.name,\n            marketplace: failedItem.marketplace,\n            errors: failedItem.errors,\n            scope: failedItem.scope,\n          },\n        })\n        hasAutoNavigated.current = true\n      }\n\n      // No match in loaded OR failed plugins — close the dialog with a\n      // message rather than silently landing on the plugin list. Only do\n      // this when an action was requested (e.g. /plugin uninstall X);\n      // plain navigation (/plugin manage) should still just show the list.\n      if (!hasAutoNavigated.current && action) {\n        hasAutoNavigated.current = true\n        setResult(`Plugin \"${targetPlugin}\" is not installed in this project`)\n      }\n    }\n  }, [\n    targetPlugin,\n    targetMarketplace,\n    marketplaces,\n    loading,\n    unifiedItems,\n    action,\n    setResult,\n  ])\n\n  // Handle single plugin operations from details view\n  const handleSingleOperation = async (\n    operation: 'enable' | 'disable' | 'update' | 'uninstall',\n  ) => {\n    if (!selectedPlugin) return\n\n    const pluginScope = selectedPlugin.scope || 'user'\n    const isBuiltin = pluginScope === 'builtin'\n\n    // Built-in plugins can only be enabled/disabled, not updated/uninstalled.\n    if (isBuiltin && (operation === 'update' || operation === 'uninstall')) {\n      setProcessError('Built-in plugins cannot be updated or uninstalled.')\n      return\n    }\n\n    // Managed scope plugins can only be updated, not enabled/disabled/uninstalled\n    if (\n      !isBuiltin &&\n      !isInstallableScope(pluginScope) &&\n      operation !== 'update'\n    ) {\n      setProcessError(\n        'This plugin is managed by your organization. Contact your admin to disable it.',\n      )\n      return\n    }\n\n    setIsProcessing(true)\n    setProcessError(null)\n\n    try {\n      const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n      let reverseDependents: string[] | undefined\n\n      // enable/disable omit scope — pluginScope is the install scope from\n      // installed_plugins.json (where files are cached), which can diverge\n      // from the settings scope (where enablement lives). Passing it trips\n      // the cross-scope guard. Auto-detect finds the right scope. #38084\n      switch (operation) {\n        case 'enable': {\n          const enableResult = await enablePluginOp(pluginId)\n          if (!enableResult.success) {\n            throw new Error(enableResult.message)\n          }\n          break\n        }\n        case 'disable': {\n          const disableResult = await disablePluginOp(pluginId)\n          if (!disableResult.success) {\n            throw new Error(disableResult.message)\n          }\n          reverseDependents = disableResult.reverseDependents\n          break\n        }\n        case 'uninstall': {\n          if (isBuiltin) break // guarded above; narrows pluginScope\n          if (!isInstallableScope(pluginScope)) break\n          // If the plugin is enabled in .claude/settings.json (shared with the\n          // team), divert to a confirmation dialog that offers to disable in\n          // settings.local.json instead. Check the settings file directly —\n          // `pluginScope` (from installed_plugins.json) can be 'user' even when\n          // the plugin is ALSO project-enabled, and uninstalling the user-scope\n          // install would leave the project enablement active.\n          if (isPluginEnabledAtProjectScope(pluginId)) {\n            setIsProcessing(false)\n            setViewState('confirm-project-uninstall')\n            return\n          }\n          // If the plugin has persistent data (${CLAUDE_PLUGIN_DATA}) AND this\n          // is the last scope, prompt before deleting it. For multi-scope\n          // installs, the op's isLastScope check won't delete regardless of\n          // the user's y/n — showing the dialog would mislead (\"y\" → nothing\n          // happens). Length check mirrors pluginOperations.ts:513.\n          const installs = loadInstalledPluginsV2().plugins[pluginId]\n          const isLastScope = !installs || installs.length <= 1\n          const dataSize = isLastScope\n            ? await getPluginDataDirSize(pluginId)\n            : null\n          if (dataSize) {\n            setIsProcessing(false)\n            setViewState({ type: 'confirm-data-cleanup', size: dataSize })\n            return\n          }\n          const result = await uninstallPluginOp(pluginId, pluginScope)\n          if (!result.success) {\n            throw new Error(result.message)\n          }\n          reverseDependents = result.reverseDependents\n          break\n        }\n        case 'update': {\n          if (isBuiltin) break // guarded above; narrows pluginScope\n          const result = await updatePluginOp(pluginId, pluginScope)\n          if (!result.success) {\n            throw new Error(result.message)\n          }\n          // If already up to date, show message and exit\n          if (result.alreadyUpToDate) {\n            setResult(\n              `${selectedPlugin.plugin.name} is already at the latest version (${result.newVersion}).`,\n            )\n            if (onManageComplete) {\n              await onManageComplete()\n            }\n            setParentViewState({ type: 'menu' })\n            return\n          }\n          // Success - will show standard message below\n          break\n        }\n      }\n\n      // Operations (enable, disable, uninstall, update) now use centralized functions\n      // that handle their own settings updates, so we only need to clear caches here\n      clearAllCaches()\n\n      // Prompt for manifest.userConfig + channel userConfig if the plugin ends\n      // up enabled. Re-read settings rather than keying on `operation ===\n      // 'enable'`: install enables on install, so the menu shows \"Disable\"\n      // first. PluginOptionsFlow itself checks getUnconfiguredOptions — if\n      // nothing needs filling, it calls onDone('skipped') immediately.\n      const pluginIdNow = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n      const settingsAfter = getSettings_DEPRECATED()\n      const enabledAfter =\n        settingsAfter?.enabledPlugins?.[pluginIdNow] !== false\n      if (enabledAfter) {\n        setIsProcessing(false)\n        setViewState({ type: 'plugin-options' })\n        return\n      }\n\n      const operationName =\n        operation === 'enable'\n          ? 'Enabled'\n          : operation === 'disable'\n            ? 'Disabled'\n            : operation === 'update'\n              ? 'Updated'\n              : 'Uninstalled'\n\n      // Single-line warning — notification timeout is ~8s, multi-line would scroll off.\n      // The persistent record is in the Errors tab (dependency-unsatisfied after reload).\n      const depWarn =\n        reverseDependents && reverseDependents.length > 0\n          ? ` · required by ${reverseDependents.join(', ')}`\n          : ''\n      const message = `✓ ${operationName} ${selectedPlugin.plugin.name}${depWarn}. Run /reload-plugins to apply.`\n      setResult(message)\n\n      if (onManageComplete) {\n        await onManageComplete()\n      }\n\n      setParentViewState({ type: 'menu' })\n    } catch (error) {\n      setIsProcessing(false)\n      const errorMessage =\n        error instanceof Error ? error.message : String(error)\n      setProcessError(`Failed to ${operation}: ${errorMessage}`)\n      logError(toError(error))\n    }\n  }\n\n  // Latest-ref: lets the auto-action effect call the current closure without\n  // adding handleSingleOperation (recreated every render) to its deps.\n  const handleSingleOperationRef = useRef(handleSingleOperation)\n  handleSingleOperationRef.current = handleSingleOperation\n\n  // Auto-execute the action prop (/plugin uninstall X, /plugin enable X, etc.)\n  // once auto-navigation has landed on plugin-details.\n  useEffect(() => {\n    if (\n      viewState === 'plugin-details' &&\n      selectedPlugin &&\n      pendingAutoActionRef.current\n    ) {\n      const pending = pendingAutoActionRef.current\n      pendingAutoActionRef.current = undefined\n      void handleSingleOperationRef.current(pending)\n    }\n  }, [viewState, selectedPlugin])\n\n  // Handle toggle enable/disable\n  const handleToggle = React.useCallback(() => {\n    if (selectedIndex >= filteredItems.length) return\n    const item = filteredItems[selectedIndex]\n    if (item?.type === 'flagged-plugin') return\n    if (item?.type === 'plugin') {\n      const pluginId = `${item.plugin.name}@${item.marketplace}`\n      const mergedSettings = getSettings_DEPRECATED()\n      const currentPending = pendingToggles.get(pluginId)\n      const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false\n      const pluginScope = item.scope\n      const isBuiltin = pluginScope === 'builtin'\n      if (isBuiltin || isInstallableScope(pluginScope)) {\n        const newPending = new Map(pendingToggles)\n        // Omit scope — see handleSingleOperation's enable/disable comment.\n        if (currentPending) {\n          // Cancel: reverse the operation back to the original state\n          newPending.delete(pluginId)\n          void (async () => {\n            try {\n              if (currentPending === 'will-disable') {\n                await enablePluginOp(pluginId)\n              } else {\n                await disablePluginOp(pluginId)\n              }\n              clearAllCaches()\n            } catch (err) {\n              logError(err)\n            }\n          })()\n        } else {\n          newPending.set(pluginId, isEnabled ? 'will-disable' : 'will-enable')\n          void (async () => {\n            try {\n              if (isEnabled) {\n                await disablePluginOp(pluginId)\n              } else {\n                await enablePluginOp(pluginId)\n              }\n              clearAllCaches()\n            } catch (err) {\n              logError(err)\n            }\n          })()\n        }\n        setPendingToggles(newPending)\n      }\n    } else if (item?.type === 'mcp') {\n      void toggleMcpServer(item.client.name)\n    }\n  }, [\n    selectedIndex,\n    filteredItems,\n    pendingToggles,\n    pluginStates,\n    toggleMcpServer,\n  ])\n\n  // Handle accept (Enter) in plugin-list\n  const handleAccept = React.useCallback(() => {\n    if (selectedIndex >= filteredItems.length) return\n    const item = filteredItems[selectedIndex]\n    if (item?.type === 'plugin') {\n      const state = pluginStates.find(\n        s =>\n          s.plugin.name === item.plugin.name &&\n          s.marketplace === item.marketplace,\n      )\n      if (state) {\n        setSelectedPlugin(state)\n        setViewState('plugin-details')\n        setDetailsMenuIndex(0)\n        setProcessError(null)\n      }\n    } else if (item?.type === 'flagged-plugin') {\n      setViewState({\n        type: 'flagged-detail',\n        plugin: {\n          id: item.id,\n          name: item.name,\n          marketplace: item.marketplace,\n          reason: item.reason,\n          text: item.text,\n          flaggedAt: item.flaggedAt,\n        },\n      })\n      setProcessError(null)\n    } else if (item?.type === 'failed-plugin') {\n      setViewState({\n        type: 'failed-plugin-details',\n        plugin: {\n          id: item.id,\n          name: item.name,\n          marketplace: item.marketplace,\n          errors: item.errors,\n          scope: item.scope,\n        },\n      })\n      setDetailsMenuIndex(0)\n      setProcessError(null)\n    } else if (item?.type === 'mcp') {\n      setViewState({ type: 'mcp-detail', client: item.client })\n      setProcessError(null)\n    }\n  }, [selectedIndex, filteredItems, pluginStates])\n\n  // Plugin-list navigation (non-search mode)\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (selectedIndex === 0) {\n          setIsSearchMode(true)\n        } else {\n          pagination.handleSelectionChange(selectedIndex - 1, setSelectedIndex)\n        }\n      },\n      'select:next': () => {\n        if (selectedIndex < filteredItems.length - 1) {\n          pagination.handleSelectionChange(selectedIndex + 1, setSelectedIndex)\n        }\n      },\n      'select:accept': handleAccept,\n    },\n    {\n      context: 'Select',\n      isActive: viewState === 'plugin-list' && !isSearchMode,\n    },\n  )\n\n  useKeybindings(\n    { 'plugin:toggle': handleToggle },\n    {\n      context: 'Plugin',\n      isActive: viewState === 'plugin-list' && !isSearchMode,\n    },\n  )\n\n  // Handle dismiss action in flagged-detail view\n  const handleFlaggedDismiss = React.useCallback(() => {\n    if (typeof viewState !== 'object' || viewState.type !== 'flagged-detail')\n      return\n    void removeFlaggedPlugin(viewState.plugin.id)\n    setViewState('plugin-list')\n  }, [viewState])\n\n  useKeybindings(\n    { 'select:accept': handleFlaggedDismiss },\n    {\n      context: 'Select',\n      isActive:\n        typeof viewState === 'object' && viewState.type === 'flagged-detail',\n    },\n  )\n\n  // Build details menu items (needed for navigation)\n  const detailsMenuItems = React.useMemo(() => {\n    if (viewState !== 'plugin-details' || !selectedPlugin) return []\n\n    const mergedSettings = getSettings_DEPRECATED()\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n    const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false\n    const isBuiltin = selectedPlugin.marketplace === 'builtin'\n\n    const menuItems: Array<{ label: string; action: () => void }> = []\n\n    menuItems.push({\n      label: isEnabled ? 'Disable plugin' : 'Enable plugin',\n      action: () =>\n        void handleSingleOperation(isEnabled ? 'disable' : 'enable'),\n    })\n\n    // Update/Uninstall options — not available for built-in plugins\n    if (!isBuiltin) {\n      menuItems.push({\n        label: selectedPlugin.pendingUpdate\n          ? 'Unmark for update'\n          : 'Mark for update',\n        action: async () => {\n          try {\n            const localError = await checkIfLocalPlugin(\n              selectedPlugin.plugin.name,\n              selectedPlugin.marketplace,\n            )\n\n            if (localError) {\n              setProcessError(localError)\n              return\n            }\n\n            const newStates = [...pluginStates]\n            const index = newStates.findIndex(\n              s =>\n                s.plugin.name === selectedPlugin.plugin.name &&\n                s.marketplace === selectedPlugin.marketplace,\n            )\n            if (index !== -1) {\n              newStates[index]!.pendingUpdate = !selectedPlugin.pendingUpdate\n              setPluginStates(newStates)\n              setSelectedPlugin({\n                ...selectedPlugin,\n                pendingUpdate: !selectedPlugin.pendingUpdate,\n              })\n            }\n          } catch (error) {\n            setProcessError(\n              error instanceof Error\n                ? error.message\n                : 'Failed to check plugin update availability',\n            )\n          }\n        },\n      })\n\n      if (selectedPluginHasMcpb) {\n        menuItems.push({\n          label: 'Configure',\n          action: async () => {\n            setIsLoadingConfig(true)\n            try {\n              const mcpServersSpec = selectedPlugin.plugin.manifest.mcpServers\n\n              let mcpbPath: string | null = null\n              if (\n                typeof mcpServersSpec === 'string' &&\n                isMcpbSource(mcpServersSpec)\n              ) {\n                mcpbPath = mcpServersSpec\n              } else if (Array.isArray(mcpServersSpec)) {\n                for (const spec of mcpServersSpec) {\n                  if (typeof spec === 'string' && isMcpbSource(spec)) {\n                    mcpbPath = spec\n                    break\n                  }\n                }\n              }\n\n              if (!mcpbPath) {\n                setProcessError('No MCPB file found in plugin')\n                setIsLoadingConfig(false)\n                return\n              }\n\n              const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n              const result = await loadMcpbFile(\n                mcpbPath,\n                selectedPlugin.plugin.path,\n                pluginId,\n                undefined,\n                undefined,\n                true,\n              )\n\n              if ('status' in result && result.status === 'needs-config') {\n                setConfigNeeded(result)\n                setViewState('configuring')\n              } else {\n                setProcessError('Failed to load MCPB for configuration')\n              }\n            } catch (err) {\n              const errorMsg = errorMessage(err)\n              setProcessError(`Failed to load configuration: ${errorMsg}`)\n            } finally {\n              setIsLoadingConfig(false)\n            }\n          },\n        })\n      }\n\n      if (\n        selectedPlugin.plugin.manifest.userConfig &&\n        Object.keys(selectedPlugin.plugin.manifest.userConfig).length > 0\n      ) {\n        menuItems.push({\n          label: 'Configure options',\n          action: () => {\n            setViewState({\n              type: 'configuring-options',\n              schema: selectedPlugin.plugin.manifest.userConfig!,\n            })\n          },\n        })\n      }\n\n      menuItems.push({\n        label: 'Update now',\n        action: () => void handleSingleOperation('update'),\n      })\n\n      menuItems.push({\n        label: 'Uninstall',\n        action: () => void handleSingleOperation('uninstall'),\n      })\n    }\n\n    if (selectedPlugin.plugin.manifest.homepage) {\n      menuItems.push({\n        label: 'Open homepage',\n        action: () =>\n          void openBrowser(selectedPlugin.plugin.manifest.homepage!),\n      })\n    }\n\n    if (selectedPlugin.plugin.manifest.repository) {\n      menuItems.push({\n        // Generic label — manifest.repository can be GitLab, Bitbucket,\n        // Azure DevOps, etc. (gh-31598). pluginDetailsHelpers.tsx:74 keeps\n        // 'View on GitHub' because that path has an explicit isGitHub check.\n        label: 'View repository',\n        action: () =>\n          void openBrowser(selectedPlugin.plugin.manifest.repository!),\n      })\n    }\n\n    menuItems.push({\n      label: 'Back to plugin list',\n      action: () => {\n        setViewState('plugin-list')\n        setSelectedPlugin(null)\n        setProcessError(null)\n      },\n    })\n\n    return menuItems\n  }, [viewState, selectedPlugin, selectedPluginHasMcpb, pluginStates])\n\n  // Plugin-details navigation\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (detailsMenuIndex > 0) {\n          setDetailsMenuIndex(detailsMenuIndex - 1)\n        }\n      },\n      'select:next': () => {\n        if (detailsMenuIndex < detailsMenuItems.length - 1) {\n          setDetailsMenuIndex(detailsMenuIndex + 1)\n        }\n      },\n      'select:accept': () => {\n        if (detailsMenuItems[detailsMenuIndex]) {\n          detailsMenuItems[detailsMenuIndex]!.action()\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive: viewState === 'plugin-details' && !!selectedPlugin,\n    },\n  )\n\n  // Failed-plugin-details: only \"Uninstall\" option, handle Enter\n  useKeybindings(\n    {\n      'select:accept': () => {\n        if (\n          typeof viewState === 'object' &&\n          viewState.type === 'failed-plugin-details'\n        ) {\n          void (async () => {\n            setIsProcessing(true)\n            setProcessError(null)\n            const pluginId = viewState.plugin.id\n            const pluginScope = viewState.plugin.scope\n            // Pass scope to uninstallPluginOp so it can find the correct V2\n            // installation record and clean up on-disk files. Fall back to\n            // default scope if not installable (e.g. 'managed', though that\n            // case is guarded by isActive below). deleteDataDir=false: this\n            // is a recovery path for a plugin that failed to load — it may\n            // be reinstallable, so don't nuke ${CLAUDE_PLUGIN_DATA} silently.\n            // The normal uninstall path prompts; this one preserves.\n            const result = isInstallableScope(pluginScope)\n              ? await uninstallPluginOp(pluginId, pluginScope, false)\n              : await uninstallPluginOp(pluginId, 'user', false)\n            let success = result.success\n            if (!success) {\n              // Plugin was never installed (only in enabledPlugins settings).\n              // Remove directly from all editable settings sources.\n              const editableSources = [\n                'userSettings' as const,\n                'projectSettings' as const,\n                'localSettings' as const,\n              ]\n              for (const source of editableSources) {\n                const settings = getSettingsForSource(source)\n                if (settings?.enabledPlugins?.[pluginId] !== undefined) {\n                  updateSettingsForSource(source, {\n                    enabledPlugins: {\n                      ...settings.enabledPlugins,\n                      [pluginId]: undefined,\n                    },\n                  })\n                  success = true\n                }\n              }\n              // Clear memoized caches so next loadAllPlugins() picks up settings changes\n              clearAllCaches()\n            }\n            if (success) {\n              if (onManageComplete) {\n                await onManageComplete()\n              }\n              setIsProcessing(false)\n              // Return to list (don't setResult — that closes the whole dialog)\n              setViewState('plugin-list')\n            } else {\n              setIsProcessing(false)\n              setProcessError(result.message)\n            }\n          })()\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive:\n        typeof viewState === 'object' &&\n        viewState.type === 'failed-plugin-details' &&\n        viewState.plugin.scope !== 'managed',\n    },\n  )\n\n  // Confirm-project-uninstall: y/enter disables in settings.local.json, n/escape cancels\n  useKeybindings(\n    {\n      'confirm:yes': () => {\n        if (!selectedPlugin) return\n        setIsProcessing(true)\n        setProcessError(null)\n        const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n        // Write `false` directly — disablePluginOp's cross-scope guard would\n        // reject this (plugin isn't in localSettings yet; the override IS the\n        // point).\n        const { error } = updateSettingsForSource('localSettings', {\n          enabledPlugins: {\n            ...getSettingsForSource('localSettings')?.enabledPlugins,\n            [pluginId]: false,\n          },\n        })\n        if (error) {\n          setIsProcessing(false)\n          setProcessError(`Failed to write settings: ${error.message}`)\n          return\n        }\n        clearAllCaches()\n        setResult(\n          `✓ Disabled ${selectedPlugin.plugin.name} in .claude/settings.local.json. Run /reload-plugins to apply.`,\n        )\n        if (onManageComplete) void onManageComplete()\n        setParentViewState({ type: 'menu' })\n      },\n      'confirm:no': () => {\n        setViewState('plugin-details')\n        setProcessError(null)\n      },\n    },\n    {\n      context: 'Confirmation',\n      isActive:\n        viewState === 'confirm-project-uninstall' &&\n        !!selectedPlugin &&\n        !isProcessing,\n    },\n  )\n\n  // Confirm-data-cleanup: y uninstalls + deletes data dir, n uninstalls + keeps,\n  // esc cancels. Raw useInput because: (1) the Confirmation context maps\n  // enter→confirm:yes, which would make Enter delete the data directory — a\n  // destructive default the UI text (\"y to delete · n to keep\") doesn't\n  // advertise; (2) unlike confirm-project-uninstall (which uses useKeybindings\n  // where n and escape both map to confirm:no), here n and escape are DIFFERENT\n  // actions (keep-data vs cancel), so this deliberately stays on raw useInput.\n  // eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw y/n/esc; Enter must not trigger destructive delete\n  useInput(\n    (input, key) => {\n      if (!selectedPlugin) return\n      const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n      const pluginScope = selectedPlugin.scope\n      // Dialog is only reachable from the uninstall case (which guards on\n      // isBuiltin), but TS can't track that across viewState transitions.\n      if (\n        !pluginScope ||\n        pluginScope === 'builtin' ||\n        !isInstallableScope(pluginScope)\n      )\n        return\n      const doUninstall = async (deleteDataDir: boolean) => {\n        setIsProcessing(true)\n        setProcessError(null)\n        try {\n          const result = await uninstallPluginOp(\n            pluginId,\n            pluginScope,\n            deleteDataDir,\n          )\n          if (!result.success) throw new Error(result.message)\n          clearAllCaches()\n          const suffix = deleteDataDir ? '' : ' · data preserved'\n          setResult(`${figures.tick} ${result.message}${suffix}`)\n          if (onManageComplete) void onManageComplete()\n          setParentViewState({ type: 'menu' })\n        } catch (e) {\n          setIsProcessing(false)\n          setProcessError(e instanceof Error ? e.message : String(e))\n        }\n      }\n      if (input === 'y' || input === 'Y') {\n        void doUninstall(true)\n      } else if (input === 'n' || input === 'N') {\n        void doUninstall(false)\n      } else if (key.escape) {\n        setViewState('plugin-details')\n        setProcessError(null)\n      }\n    },\n    {\n      isActive:\n        typeof viewState === 'object' &&\n        viewState.type === 'confirm-data-cleanup' &&\n        !!selectedPlugin &&\n        !isProcessing,\n    },\n  )\n\n  // Reset selection when search query changes\n  React.useEffect(() => {\n    setSelectedIndex(0)\n  }, [searchQuery])\n\n  // Handle input for entering search mode (text input handled by useSearchInput hook)\n  // eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input\n  useInput(\n    (input, key) => {\n      const keyIsNotCtrlOrMeta = !key.ctrl && !key.meta\n      if (isSearchMode) {\n        // Text input is handled by useSearchInput hook\n        return\n      }\n\n      // Enter search mode with '/' or any printable character (except navigation keys)\n      if (input === '/' && keyIsNotCtrlOrMeta) {\n        setIsSearchMode(true)\n        setSearchQuery('')\n        setSelectedIndex(0)\n      } else if (\n        keyIsNotCtrlOrMeta &&\n        input.length > 0 &&\n        !/^\\s+$/.test(input) &&\n        input !== 'j' &&\n        input !== 'k' &&\n        input !== ' '\n      ) {\n        setIsSearchMode(true)\n        setSearchQuery(input)\n        setSelectedIndex(0)\n      }\n    },\n    { isActive: viewState === 'plugin-list' },\n  )\n\n  // Loading state\n  if (loading) {\n    return <Text>Loading installed plugins…</Text>\n  }\n\n  // No plugins or MCPs installed\n  if (unifiedItems.length === 0) {\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Manage plugins</Text>\n        </Box>\n        <Text>No plugins or MCP servers installed.</Text>\n        <Box marginTop={1}>\n          <Text dimColor>Esc to go back</Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  if (\n    typeof viewState === 'object' &&\n    viewState.type === 'plugin-options' &&\n    selectedPlugin\n  ) {\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n    function finish(msg: string): void {\n      setResult(msg)\n      // Plugin is enabled regardless of whether config was saved or\n      // skipped — onManageComplete → markPluginsChanged → the\n      // persistent \"run /reload-plugins\" notice.\n      if (onManageComplete) {\n        void onManageComplete()\n      }\n      setParentViewState({ type: 'menu' })\n    }\n    return (\n      <PluginOptionsFlow\n        plugin={selectedPlugin.plugin}\n        pluginId={pluginId}\n        onDone={(outcome, detail) => {\n          switch (outcome) {\n            case 'configured':\n              finish(\n                `✓ Enabled and configured ${selectedPlugin.plugin.name}. Run /reload-plugins to apply.`,\n              )\n              break\n            case 'skipped':\n              finish(\n                `✓ Enabled ${selectedPlugin.plugin.name}. Run /reload-plugins to apply.`,\n              )\n              break\n            case 'error':\n              finish(`Failed to save configuration: ${detail}`)\n              break\n          }\n        }}\n      />\n    )\n  }\n\n  // Configure options (from the Manage menu)\n  if (\n    typeof viewState === 'object' &&\n    viewState.type === 'configuring-options' &&\n    selectedPlugin\n  ) {\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n    return (\n      <PluginOptionsDialog\n        title={`Configure ${selectedPlugin.plugin.name}`}\n        subtitle=\"Plugin options\"\n        configSchema={viewState.schema}\n        initialValues={loadPluginOptions(pluginId)}\n        onSave={values => {\n          try {\n            savePluginOptions(pluginId, values, viewState.schema)\n            clearAllCaches()\n            setResult(\n              'Configuration saved. Run /reload-plugins for changes to take effect.',\n            )\n          } catch (err) {\n            setProcessError(\n              `Failed to save configuration: ${errorMessage(err)}`,\n            )\n          }\n          setViewState('plugin-details')\n        }}\n        onCancel={() => setViewState('plugin-details')}\n      />\n    )\n  }\n\n  // Configuration view\n  if (viewState === 'configuring' && configNeeded && selectedPlugin) {\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n\n    async function handleSave(config: UserConfigValues) {\n      if (!configNeeded || !selectedPlugin) return\n\n      try {\n        // Find MCPB path again\n        const mcpServersSpec = selectedPlugin.plugin.manifest.mcpServers\n        let mcpbPath: string | null = null\n\n        if (\n          typeof mcpServersSpec === 'string' &&\n          isMcpbSource(mcpServersSpec)\n        ) {\n          mcpbPath = mcpServersSpec\n        } else if (Array.isArray(mcpServersSpec)) {\n          for (const spec of mcpServersSpec) {\n            if (typeof spec === 'string' && isMcpbSource(spec)) {\n              mcpbPath = spec\n              break\n            }\n          }\n        }\n\n        if (!mcpbPath) {\n          setProcessError('No MCPB file found')\n          setViewState('plugin-details')\n          return\n        }\n\n        // Reload with provided config\n        await loadMcpbFile(\n          mcpbPath,\n          selectedPlugin.plugin.path,\n          pluginId,\n          undefined,\n          config,\n        )\n\n        // Success - go back to details\n        setProcessError(null)\n        setConfigNeeded(null)\n        setViewState('plugin-details')\n        setResult(\n          'Configuration saved. Run /reload-plugins for changes to take effect.',\n        )\n      } catch (err) {\n        const errorMsg = errorMessage(err)\n        setProcessError(`Failed to save configuration: ${errorMsg}`)\n        setViewState('plugin-details')\n      }\n    }\n\n    function handleCancel() {\n      setConfigNeeded(null)\n      setViewState('plugin-details')\n    }\n\n    return (\n      <PluginOptionsDialog\n        title={`Configure ${configNeeded.manifest.name}`}\n        subtitle={`Plugin: ${selectedPlugin.plugin.name}`}\n        configSchema={configNeeded.configSchema}\n        initialValues={configNeeded.existingConfig}\n        onSave={handleSave}\n        onCancel={handleCancel}\n      />\n    )\n  }\n\n  // Flagged plugin detail view\n  if (typeof viewState === 'object' && viewState.type === 'flagged-detail') {\n    const fp = viewState.plugin\n    return (\n      <Box flexDirection=\"column\">\n        <Box>\n          <Text bold>\n            {fp.name} @ {fp.marketplace}\n          </Text>\n        </Box>\n\n        <Box marginBottom={1}>\n          <Text dimColor>Status: </Text>\n          <Text color=\"error\">Removed</Text>\n        </Box>\n\n        <Box marginBottom={1} flexDirection=\"column\">\n          <Text color=\"error\">\n            Removed from marketplace · reason: {fp.reason}\n          </Text>\n          <Text>{fp.text}</Text>\n          <Text dimColor>\n            Flagged on {new Date(fp.flaggedAt).toLocaleDateString()}\n          </Text>\n        </Box>\n\n        <Box marginTop={1} flexDirection=\"column\">\n          <Box>\n            <Text>{figures.pointer} </Text>\n            <Text color=\"suggestion\">Dismiss</Text>\n          </Box>\n        </Box>\n\n        <Byline>\n          <ConfigurableShortcutHint\n            action=\"select:accept\"\n            context=\"Select\"\n            fallback=\"Enter\"\n            description=\"dismiss\"\n          />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"back\"\n          />\n        </Byline>\n      </Box>\n    )\n  }\n\n  // Confirm-project-uninstall: warn about shared .claude/settings.json,\n  // offer to disable in settings.local.json instead.\n  if (viewState === 'confirm-project-uninstall' && selectedPlugin) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold color=\"warning\">\n          {selectedPlugin.plugin.name} is enabled in .claude/settings.json\n          (shared with your team)\n        </Text>\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text>Disable it just for you in .claude/settings.local.json?</Text>\n          <Text dimColor>\n            This has the same effect as uninstalling, without affecting other\n            contributors.\n          </Text>\n        </Box>\n        {processError && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{processError}</Text>\n          </Box>\n        )}\n        <Box marginTop={1}>\n          {isProcessing ? (\n            <Text dimColor>Disabling…</Text>\n          ) : (\n            <Byline>\n              <ConfigurableShortcutHint\n                action=\"confirm:yes\"\n                context=\"Confirmation\"\n                fallback=\"y\"\n                description=\"disable\"\n              />\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"cancel\"\n              />\n            </Byline>\n          )}\n        </Box>\n      </Box>\n    )\n  }\n\n  // Confirm-data-cleanup: prompt before deleting ${CLAUDE_PLUGIN_DATA} dir\n  if (\n    typeof viewState === 'object' &&\n    viewState.type === 'confirm-data-cleanup' &&\n    selectedPlugin\n  ) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>\n          {selectedPlugin.plugin.name} has {viewState.size.human} of persistent\n          data\n        </Text>\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text>Delete it along with the plugin?</Text>\n          <Text dimColor>\n            {pluginDataDirPath(\n              `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`,\n            )}\n          </Text>\n        </Box>\n        {processError && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{processError}</Text>\n          </Box>\n        )}\n        <Box marginTop={1}>\n          {isProcessing ? (\n            <Text dimColor>Uninstalling…</Text>\n          ) : (\n            <Text>\n              <Text bold>y</Text> to delete · <Text bold>n</Text> to keep ·{' '}\n              <Text bold>esc</Text> to cancel\n            </Text>\n          )}\n        </Box>\n      </Box>\n    )\n  }\n\n  // Plugin details view\n  if (viewState === 'plugin-details' && selectedPlugin) {\n    const mergedSettings = getSettings_DEPRECATED() // Use merged settings to respect all layers\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n    const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false\n\n    // Compute plugin errors section\n    const filteredPluginErrors = pluginErrors.filter(\n      e =>\n        ('plugin' in e && e.plugin === selectedPlugin.plugin.name) ||\n        e.source === pluginId ||\n        e.source.startsWith(`${selectedPlugin.plugin.name}@`),\n    )\n    const pluginErrorsSection =\n      filteredPluginErrors.length === 0 ? null : (\n        <Box flexDirection=\"column\" marginBottom={1}>\n          <Text bold color=\"error\">\n            {filteredPluginErrors.length}{' '}\n            {plural(filteredPluginErrors.length, 'error')}:\n          </Text>\n          {filteredPluginErrors.map((error, i) => {\n            const guidance = getErrorGuidance(error)\n            return (\n              <Box key={i} flexDirection=\"column\" marginLeft={2}>\n                <Text color=\"error\">{formatErrorMessage(error)}</Text>\n                {guidance && (\n                  <Text dimColor italic>\n                    {figures.arrowRight} {guidance}\n                  </Text>\n                )}\n              </Box>\n            )\n          })}\n        </Box>\n      )\n\n    return (\n      <Box flexDirection=\"column\">\n        <Box>\n          <Text bold>\n            {selectedPlugin.plugin.name} @ {selectedPlugin.marketplace}\n          </Text>\n        </Box>\n\n        {/* Scope */}\n        <Box>\n          <Text dimColor>Scope: </Text>\n          <Text>{selectedPlugin.scope || 'user'}</Text>\n        </Box>\n\n        {/* Plugin details */}\n        {selectedPlugin.plugin.manifest.version && (\n          <Box>\n            <Text dimColor>Version: </Text>\n            <Text>{selectedPlugin.plugin.manifest.version}</Text>\n          </Box>\n        )}\n\n        {selectedPlugin.plugin.manifest.description && (\n          <Box marginBottom={1}>\n            <Text>{selectedPlugin.plugin.manifest.description}</Text>\n          </Box>\n        )}\n\n        {selectedPlugin.plugin.manifest.author && (\n          <Box>\n            <Text dimColor>Author: </Text>\n            <Text>{selectedPlugin.plugin.manifest.author.name}</Text>\n          </Box>\n        )}\n\n        {/* Current status */}\n        <Box marginBottom={1}>\n          <Text dimColor>Status: </Text>\n          <Text color={isEnabled ? 'success' : 'warning'}>\n            {isEnabled ? 'Enabled' : 'Disabled'}\n          </Text>\n          {selectedPlugin.pendingUpdate && (\n            <Text color=\"suggestion\"> · Marked for update</Text>\n          )}\n        </Box>\n\n        {/* Installed components */}\n        <PluginComponentsDisplay\n          plugin={selectedPlugin.plugin}\n          marketplace={selectedPlugin.marketplace}\n        />\n\n        {/* Plugin errors */}\n        {pluginErrorsSection}\n\n        {/* Menu */}\n        <Box marginTop={1} flexDirection=\"column\">\n          {detailsMenuItems.map((item, index) => {\n            const isSelected = index === detailsMenuIndex\n\n            return (\n              <Box key={index}>\n                {isSelected && <Text>{figures.pointer} </Text>}\n                {!isSelected && <Text>{'  '}</Text>}\n                <Text\n                  bold={isSelected}\n                  color={\n                    item.label.includes('Uninstall')\n                      ? 'error'\n                      : item.label.includes('Update')\n                        ? 'suggestion'\n                        : undefined\n                  }\n                >\n                  {item.label}\n                </Text>\n              </Box>\n            )\n          })}\n        </Box>\n\n        {/* Processing state */}\n        {isProcessing && (\n          <Box marginTop={1}>\n            <Text>Processing…</Text>\n          </Box>\n        )}\n\n        {/* Error message */}\n        {processError && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{processError}</Text>\n          </Box>\n        )}\n\n        <Box marginTop={1}>\n          <Text dimColor italic>\n            <Byline>\n              <ConfigurableShortcutHint\n                action=\"select:previous\"\n                context=\"Select\"\n                fallback=\"↑\"\n                description=\"navigate\"\n              />\n              <ConfigurableShortcutHint\n                action=\"select:accept\"\n                context=\"Select\"\n                fallback=\"Enter\"\n                description=\"select\"\n              />\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"back\"\n              />\n            </Byline>\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Failed plugin detail view\n  if (\n    typeof viewState === 'object' &&\n    viewState.type === 'failed-plugin-details'\n  ) {\n    const failedPlugin = viewState.plugin\n\n    const firstError = failedPlugin.errors[0]\n    const errorMessage = firstError\n      ? formatErrorMessage(firstError)\n      : 'Failed to load'\n\n    return (\n      <Box flexDirection=\"column\">\n        <Text>\n          <Text bold>{failedPlugin.name}</Text>\n          <Text dimColor> @ {failedPlugin.marketplace}</Text>\n          <Text dimColor> ({failedPlugin.scope})</Text>\n        </Text>\n        <Text color=\"error\">{errorMessage}</Text>\n\n        {failedPlugin.scope === 'managed' ? (\n          <Box marginTop={1}>\n            <Text dimColor>\n              Managed by your organization — contact your admin\n            </Text>\n          </Box>\n        ) : (\n          <Box marginTop={1}>\n            <Text color=\"suggestion\">{figures.pointer} </Text>\n            <Text bold>Remove</Text>\n          </Box>\n        )}\n\n        {isProcessing && <Text>Processing…</Text>}\n        {processError && <Text color=\"error\">{processError}</Text>}\n\n        <Box marginTop={1}>\n          <Text dimColor italic>\n            <Byline>\n              {failedPlugin.scope !== 'managed' && (\n                <ConfigurableShortcutHint\n                  action=\"select:accept\"\n                  context=\"Select\"\n                  fallback=\"Enter\"\n                  description=\"remove\"\n                />\n              )}\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"back\"\n              />\n            </Byline>\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // MCP detail view\n  if (typeof viewState === 'object' && viewState.type === 'mcp-detail') {\n    const client = viewState.client\n    const serverToolsCount = filterToolsByServer(mcpTools, client.name).length\n\n    // Common handlers for MCP menus\n    const handleMcpViewTools = () => {\n      setViewState({ type: 'mcp-tools', client })\n    }\n\n    const handleMcpCancel = () => {\n      setViewState('plugin-list')\n    }\n\n    const handleMcpComplete = (result?: string) => {\n      if (result) {\n        setResult(result)\n      }\n      setViewState('plugin-list')\n    }\n\n    // Transform MCPServerConnection to appropriate ServerInfo type\n    const scope = client.config.scope\n    const configType = client.config.type\n\n    if (configType === 'stdio') {\n      const server: StdioServerInfo = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'stdio',\n        config: client.config as McpStdioServerConfig,\n      }\n      return (\n        <MCPStdioServerMenu\n          server={server}\n          serverToolsCount={serverToolsCount}\n          onViewTools={handleMcpViewTools}\n          onCancel={handleMcpCancel}\n          onComplete={handleMcpComplete}\n          borderless\n        />\n      )\n    } else if (configType === 'sse') {\n      const server: SSEServerInfo = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'sse',\n        isAuthenticated: undefined,\n        config: client.config as McpSSEServerConfig,\n      }\n      return (\n        <MCPRemoteServerMenu\n          server={server}\n          serverToolsCount={serverToolsCount}\n          onViewTools={handleMcpViewTools}\n          onCancel={handleMcpCancel}\n          onComplete={handleMcpComplete}\n          borderless\n        />\n      )\n    } else if (configType === 'http') {\n      const server: HTTPServerInfo = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'http',\n        isAuthenticated: undefined,\n        config: client.config as McpHTTPServerConfig,\n      }\n      return (\n        <MCPRemoteServerMenu\n          server={server}\n          serverToolsCount={serverToolsCount}\n          onViewTools={handleMcpViewTools}\n          onCancel={handleMcpCancel}\n          onComplete={handleMcpComplete}\n          borderless\n        />\n      )\n    } else if (configType === 'claudeai-proxy') {\n      const server: ClaudeAIServerInfo = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'claudeai-proxy',\n        isAuthenticated: undefined,\n        config: client.config as McpClaudeAIProxyServerConfig,\n      }\n      return (\n        <MCPRemoteServerMenu\n          server={server}\n          serverToolsCount={serverToolsCount}\n          onViewTools={handleMcpViewTools}\n          onCancel={handleMcpCancel}\n          onComplete={handleMcpComplete}\n          borderless\n        />\n      )\n    }\n\n    // Fallback - shouldn't happen but handle gracefully\n    setViewState('plugin-list')\n    return null\n  }\n\n  // MCP tools view\n  if (typeof viewState === 'object' && viewState.type === 'mcp-tools') {\n    const client = viewState.client\n    const scope = client.config.scope\n    const configType = client.config.type\n\n    // Build ServerInfo for MCPToolListView\n    let server:\n      | StdioServerInfo\n      | SSEServerInfo\n      | HTTPServerInfo\n      | ClaudeAIServerInfo\n    if (configType === 'stdio') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'stdio',\n        config: client.config as McpStdioServerConfig,\n      }\n    } else if (configType === 'sse') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'sse',\n        isAuthenticated: undefined,\n        config: client.config as McpSSEServerConfig,\n      }\n    } else if (configType === 'http') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'http',\n        isAuthenticated: undefined,\n        config: client.config as McpHTTPServerConfig,\n      }\n    } else {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'claudeai-proxy',\n        isAuthenticated: undefined,\n        config: client.config as McpClaudeAIProxyServerConfig,\n      }\n    }\n\n    return (\n      <MCPToolListView\n        server={server}\n        onSelectTool={(tool: Tool) => {\n          setViewState({ type: 'mcp-tool-detail', client, tool })\n        }}\n        onBack={() => setViewState({ type: 'mcp-detail', client })}\n      />\n    )\n  }\n\n  // MCP tool detail view\n  if (typeof viewState === 'object' && viewState.type === 'mcp-tool-detail') {\n    const { client, tool } = viewState\n    const scope = client.config.scope\n    const configType = client.config.type\n\n    // Build ServerInfo for MCPToolDetailView\n    let server:\n      | StdioServerInfo\n      | SSEServerInfo\n      | HTTPServerInfo\n      | ClaudeAIServerInfo\n    if (configType === 'stdio') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'stdio',\n        config: client.config as McpStdioServerConfig,\n      }\n    } else if (configType === 'sse') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'sse',\n        isAuthenticated: undefined,\n        config: client.config as McpSSEServerConfig,\n      }\n    } else if (configType === 'http') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'http',\n        isAuthenticated: undefined,\n        config: client.config as McpHTTPServerConfig,\n      }\n    } else {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'claudeai-proxy',\n        isAuthenticated: undefined,\n        config: client.config as McpClaudeAIProxyServerConfig,\n      }\n    }\n\n    return (\n      <MCPToolDetailView\n        tool={tool}\n        server={server}\n        onBack={() => setViewState({ type: 'mcp-tools', client })}\n      />\n    )\n  }\n\n  // Plugin list view (main management interface)\n  const visibleItems = pagination.getVisibleItems(filteredItems)\n\n  return (\n    <Box flexDirection=\"column\">\n      {/* Search box */}\n      <Box marginBottom={1}>\n        <SearchBox\n          query={searchQuery}\n          isFocused={isSearchMode}\n          isTerminalFocused={isTerminalFocused}\n          width={terminalWidth - 4}\n          cursorOffset={searchCursorOffset}\n        />\n      </Box>\n\n      {/* No search results */}\n      {filteredItems.length === 0 && searchQuery && (\n        <Box marginBottom={1}>\n          <Text dimColor>No items match &quot;{searchQuery}&quot;</Text>\n        </Box>\n      )}\n\n      {/* Scroll up indicator */}\n      {pagination.scrollPosition.canScrollUp && (\n        <Box>\n          <Text dimColor> {figures.arrowUp} more above</Text>\n        </Box>\n      )}\n\n      {/* Unified list of plugins and MCPs grouped by scope */}\n      {visibleItems.map((item, visibleIndex) => {\n        const actualIndex = pagination.toActualIndex(visibleIndex)\n        const isSelected = actualIndex === selectedIndex && !isSearchMode\n\n        // Check if we need to show a scope header\n        const prevItem =\n          visibleIndex > 0 ? visibleItems[visibleIndex - 1] : null\n        const showScopeHeader = !prevItem || prevItem.scope !== item.scope\n\n        // Get scope label\n        const getScopeLabel = (scope: string): string => {\n          switch (scope) {\n            case 'flagged':\n              return 'Flagged'\n            case 'project':\n              return 'Project'\n            case 'local':\n              return 'Local'\n            case 'user':\n              return 'User'\n            case 'enterprise':\n              return 'Enterprise'\n            case 'managed':\n              return 'Managed'\n            case 'builtin':\n              return 'Built-in'\n            case 'dynamic':\n              return 'Built-in'\n            default:\n              return scope\n          }\n        }\n\n        return (\n          <React.Fragment key={item.id}>\n            {showScopeHeader && (\n              <Box marginTop={visibleIndex > 0 ? 1 : 0} paddingLeft={2}>\n                <Text\n                  dimColor={item.scope !== 'flagged'}\n                  color={item.scope === 'flagged' ? 'warning' : undefined}\n                  bold={item.scope === 'flagged'}\n                >\n                  {getScopeLabel(item.scope)}\n                </Text>\n              </Box>\n            )}\n            <UnifiedInstalledCell item={item} isSelected={isSelected} />\n          </React.Fragment>\n        )\n      })}\n\n      {/* Scroll down indicator */}\n      {pagination.scrollPosition.canScrollDown && (\n        <Box>\n          <Text dimColor> {figures.arrowDown} more below</Text>\n        </Box>\n      )}\n\n      {/* Help text */}\n      <Box marginTop={1} marginLeft={1}>\n        <Text dimColor italic>\n          <Byline>\n            <Text>type to search</Text>\n            <ConfigurableShortcutHint\n              action=\"plugin:toggle\"\n              context=\"Plugin\"\n              fallback=\"Space\"\n              description=\"toggle\"\n            />\n            <ConfigurableShortcutHint\n              action=\"select:accept\"\n              context=\"Select\"\n              fallback=\"Enter\"\n              description=\"details\"\n            />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"back\"\n            />\n          </Byline>\n        </Text>\n      </Box>\n\n      {/* Reload disclaimer for plugin changes */}\n      {pendingToggles.size > 0 && (\n        <Box marginLeft={1}>\n          <Text dimColor italic>\n            Run /reload-plugins to apply changes\n          </Text>\n        </Box>\n      )}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/PluginErrors.tsx b/src/commands/plugin/PluginErrors.tsx new file mode 100644 index 0000000000000000000000000000000000000000..8991e8d2d7cd0088fbafc2b8581ae1a34102365e --- /dev/null +++ b/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":[]} \ No newline at end of file diff --git a/src/commands/plugin/PluginOptionsDialog.tsx b/src/commands/plugin/PluginOptionsDialog.tsx new file mode 100644 index 0000000000000000000000000000000000000000..87e6721b70908c0d0fd48b94f7e6b994959266f1 --- /dev/null +++ b/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, 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 && *; + $[34] = isRequired; + $[35] = t13; + } else { + t13 = $[35]; + } + let t14; + if ($[36] !== t12 || $[37] !== t13) { + t14 = {t12}{t13}; + $[36] = t12; + $[37] = t13; + $[38] = t14; + } else { + t14 = $[38]; + } + let t15; + if ($[39] !== fieldSchema.description) { + t15 = fieldSchema.description && {fieldSchema.description}; + $[39] = fieldSchema.description; + $[40] = t15; + } else { + t15 = $[40]; + } + let t16; + if ($[41] === Symbol.for("react.memo_cache_sentinel")) { + t16 = {figures.pointerSmall} ; + $[41] = t16; + } else { + t16 = $[41]; + } + let t17; + if ($[42] !== displayValue) { + t17 = {displayValue}; + $[42] = displayValue; + $[43] = t17; + } else { + t17 = $[43]; + } + let t18; + if ($[44] === Symbol.for("react.memo_cache_sentinel")) { + t18 = █; + $[44] = t18; + } else { + t18 = $[44]; + } + let t19; + if ($[45] !== t17) { + t19 = {t16}{t17}{t18}; + $[45] = t17; + $[46] = t19; + } else { + t19 = $[46]; + } + let t20; + if ($[47] !== t14 || $[48] !== t15 || $[49] !== t19) { + t20 = {t14}{t15}{t19}; + $[47] = t14; + $[48] = t15; + $[49] = t19; + $[50] = t20; + } else { + t20 = $[50]; + } + const t21 = currentFieldIndex + 1; + let t22; + if ($[51] !== fields.length || $[52] !== t21) { + t22 = Field {t21} of {fields.length}; + $[51] = fields.length; + $[52] = t21; + $[53] = t22; + } else { + t22 = $[53]; + } + let t23; + if ($[54] !== currentFieldIndex || $[55] !== fields.length) { + t23 = currentFieldIndex < fields.length - 1 && Tab: Next field · Enter: Save and continue; + $[54] = currentFieldIndex; + $[55] = fields.length; + $[56] = t23; + } else { + t23 = $[56]; + } + let t24; + if ($[57] !== currentFieldIndex || $[58] !== fields.length) { + t24 = currentFieldIndex === fields.length - 1 && Enter: Save configuration; + $[57] = currentFieldIndex; + $[58] = fields.length; + $[59] = t24; + } else { + t24 = $[59]; + } + let t25; + if ($[60] !== t22 || $[61] !== t23 || $[62] !== t24) { + t25 = {t22}{t23}{t24}; + $[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 = {t20}{t25}; + $[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":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/PluginOptionsFlow.tsx b/src/commands/plugin/PluginOptionsFlow.tsx new file mode 100644 index 0000000000000000000000000000000000000000..837704fac4bc4c4548753316337a54c681d894ed --- /dev/null +++ b/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 { + 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(() => { + 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 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":[]} \ No newline at end of file diff --git a/src/commands/plugin/PluginSettings.tsx b/src/commands/plugin/PluginSettings.tsx new file mode 100644 index 0000000000000000000000000000000000000000..f325180c25300b5e01cfebd96ce8647839f1bdf5 --- /dev/null +++ b/src/commands/plugin/PluginSettings.tsx @@ -0,0 +1,1072 @@ +import { c as _c } from "react/compiler-runtime"; +import figures from 'figures'; +import * as React from 'react'; +import { useCallback, useEffect, useState } from 'react'; +import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'; +import { Byline } from '../../components/design-system/Byline.js'; +import { Pane } from '../../components/design-system/Pane.js'; +import { Tab, Tabs } from '../../components/design-system/Tabs.js'; +import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'; +import { Box, Text } from '../../ink.js'; +import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js'; +import { useAppState, useSetAppState } from '../../state/AppState.js'; +import type { PluginError } from '../../types/plugin.js'; +import { errorMessage } from '../../utils/errors.js'; +import { clearAllCaches } from '../../utils/plugins/cacheUtils.js'; +import { loadMarketplacesWithGracefulDegradation } from '../../utils/plugins/marketplaceHelpers.js'; +import { loadKnownMarketplacesConfig, removeMarketplaceSource } from '../../utils/plugins/marketplaceManager.js'; +import { getPluginEditableScopes } from '../../utils/plugins/pluginStartupCheck.js'; +import type { EditableSettingSource } from '../../utils/settings/constants.js'; +import { getSettingsForSource, updateSettingsForSource } from '../../utils/settings/settings.js'; +import { AddMarketplace } from './AddMarketplace.js'; +import { BrowseMarketplace } from './BrowseMarketplace.js'; +import { DiscoverPlugins } from './DiscoverPlugins.js'; +import { ManageMarketplaces } from './ManageMarketplaces.js'; +import { ManagePlugins } from './ManagePlugins.js'; +import { formatErrorMessage, getErrorGuidance } from './PluginErrors.js'; +import { type ParsedCommand, parsePluginArgs } from './parseArgs.js'; +import type { PluginSettingsProps, ViewState } from './types.js'; +import { ValidatePlugin } from './ValidatePlugin.js'; +type TabId = 'discover' | 'installed' | 'marketplaces' | 'errors'; +function MarketplaceList(t0) { + const $ = _c(4); + const { + onComplete + } = t0; + let t1; + let t2; + if ($[0] !== onComplete) { + t1 = () => { + const loadList = async function loadList() { + ; + try { + const config = await loadKnownMarketplacesConfig(); + const names = Object.keys(config); + if (names.length === 0) { + onComplete("No marketplaces configured"); + } else { + onComplete(`Configured marketplaces:\n${names.map(_temp).join("\n")}`); + } + } catch (t3) { + const err = t3; + onComplete(`Error loading marketplaces: ${errorMessage(err)}`); + } + }; + loadList(); + }; + t2 = [onComplete]; + $[0] = onComplete; + $[1] = t1; + $[2] = t2; + } else { + t1 = $[1]; + t2 = $[2]; + } + useEffect(t1, t2); + let t3; + if ($[3] === Symbol.for("react.memo_cache_sentinel")) { + t3 = Loading marketplaces...; + $[3] = t3; + } else { + t3 = $[3]; + } + return t3; +} +function _temp(n) { + return ` • ${n}`; +} +function McpRedirectBanner() { + return null; +} +type ErrorRowAction = { + kind: 'navigate'; + tab: TabId; + viewState: ViewState; +} | { + kind: 'remove-extra-marketplace'; + name: string; + sources: Array<{ + source: EditableSettingSource; + scope: string; + }>; +} | { + kind: 'remove-installed-marketplace'; + name: string; +} | { + kind: 'managed-only'; + name: string; +} | { + kind: 'none'; +}; +type ErrorRow = { + label: string; + message: string; + guidance?: string | null; + action: ErrorRowAction; + scope?: string; +}; + +/** + * Determine which settings sources define an extraKnownMarketplace entry. + * Returns the editable sources (user/project/local) and whether policy also has it. + */ +function getExtraMarketplaceSourceInfo(name: string): { + editableSources: Array<{ + source: EditableSettingSource; + scope: string; + }>; + isInPolicy: boolean; +} { + const editableSources: Array<{ + source: EditableSettingSource; + scope: string; + }> = []; + const sourcesToCheck = [{ + source: 'userSettings' as const, + scope: 'user' + }, { + source: 'projectSettings' as const, + scope: 'project' + }, { + source: 'localSettings' as const, + scope: 'local' + }]; + for (const { + source, + scope + } of sourcesToCheck) { + const settings = getSettingsForSource(source); + if (settings?.extraKnownMarketplaces?.[name]) { + editableSources.push({ + source, + scope + }); + } + } + const policySettings = getSettingsForSource('policySettings'); + const isInPolicy = Boolean(policySettings?.extraKnownMarketplaces?.[name]); + return { + editableSources, + isInPolicy + }; +} +function buildMarketplaceAction(name: string): ErrorRowAction { + const { + editableSources, + isInPolicy + } = getExtraMarketplaceSourceInfo(name); + if (editableSources.length > 0) { + return { + kind: 'remove-extra-marketplace', + name, + sources: editableSources + }; + } + if (isInPolicy) { + return { + kind: 'managed-only', + name + }; + } + + // Marketplace is in known_marketplaces.json but not in extraKnownMarketplaces + // (e.g. previously installed manually) — route to ManageMarketplaces + return { + kind: 'navigate', + tab: 'marketplaces', + viewState: { + type: 'manage-marketplaces', + targetMarketplace: name, + action: 'remove' + } + }; +} +function buildPluginAction(pluginName: string): ErrorRowAction { + return { + kind: 'navigate', + tab: 'installed', + viewState: { + type: 'manage-plugins', + targetPlugin: pluginName, + action: 'uninstall' + } + }; +} +const TRANSIENT_ERROR_TYPES = new Set(['git-auth-failed', 'git-timeout', 'network-error']); +function isTransientError(error: PluginError): boolean { + return TRANSIENT_ERROR_TYPES.has(error.type); +} + +/** + * Extract the plugin name from a PluginError, checking explicit fields first, + * then falling back to the source field (format: "pluginName@marketplace"). + */ +function getPluginNameFromError(error: PluginError): string | undefined { + if ('pluginId' in error && error.pluginId) return error.pluginId; + if ('plugin' in error && error.plugin) return error.plugin; + // Fallback: source often contains "pluginName@marketplace" + if (error.source.includes('@')) return error.source.split('@')[0]; + return undefined; +} +function buildErrorRows(failedMarketplaces: Array<{ + name: string; + error?: string; +}>, extraMarketplaceErrors: PluginError[], pluginLoadingErrors: PluginError[], otherErrors: PluginError[], brokenInstalledMarketplaces: Array<{ + name: string; + error: string; +}>, transientErrors: PluginError[], pluginScopes: Map): ErrorRow[] { + const rows: ErrorRow[] = []; + + // --- Transient errors at the top (restart to retry) --- + for (const error of transientErrors) { + const pluginName = 'pluginId' in error ? error.pluginId : 'plugin' in error ? error.plugin : undefined; + rows.push({ + label: pluginName ?? error.source, + message: formatErrorMessage(error), + guidance: 'Restart to retry loading plugins', + action: { + kind: 'none' + } + }); + } + + // --- Marketplace errors --- + // Track shown marketplace names to avoid duplicates across sources + const shownMarketplaceNames = new Set(); + for (const m of failedMarketplaces) { + shownMarketplaceNames.add(m.name); + const action = buildMarketplaceAction(m.name); + const sourceInfo = getExtraMarketplaceSourceInfo(m.name); + const scope = sourceInfo.isInPolicy ? 'managed' : sourceInfo.editableSources[0]?.scope; + rows.push({ + label: m.name, + message: m.error ?? 'Installation failed', + guidance: action.kind === 'managed-only' ? 'Managed by your organization — contact your admin' : undefined, + action, + scope + }); + } + for (const e of extraMarketplaceErrors) { + const marketplace = 'marketplace' in e ? e.marketplace : e.source; + if (shownMarketplaceNames.has(marketplace)) continue; + shownMarketplaceNames.add(marketplace); + const action = buildMarketplaceAction(marketplace); + const sourceInfo = getExtraMarketplaceSourceInfo(marketplace); + const scope = sourceInfo.isInPolicy ? 'managed' : sourceInfo.editableSources[0]?.scope; + rows.push({ + label: marketplace, + message: formatErrorMessage(e), + guidance: action.kind === 'managed-only' ? 'Managed by your organization — contact your admin' : getErrorGuidance(e), + action, + scope + }); + } + + // Installed marketplaces that fail to load data (from known_marketplaces.json) + for (const m of brokenInstalledMarketplaces) { + if (shownMarketplaceNames.has(m.name)) continue; + shownMarketplaceNames.add(m.name); + rows.push({ + label: m.name, + message: m.error, + action: { + kind: 'remove-installed-marketplace', + name: m.name + } + }); + } + + // --- Plugin errors --- + const shownPluginNames = new Set(); + for (const error of pluginLoadingErrors) { + const pluginName = getPluginNameFromError(error); + if (pluginName && shownPluginNames.has(pluginName)) continue; + if (pluginName) shownPluginNames.add(pluginName); + const marketplace = 'marketplace' in error ? error.marketplace : undefined; + // Try pluginId@marketplace format first, then just pluginName + const scope = pluginName ? pluginScopes.get(error.source) ?? pluginScopes.get(pluginName) : undefined; + rows.push({ + label: pluginName ? marketplace ? `${pluginName} @ ${marketplace}` : pluginName : error.source, + message: formatErrorMessage(error), + guidance: getErrorGuidance(error), + action: pluginName ? buildPluginAction(pluginName) : { + kind: 'none' + }, + scope + }); + } + + // --- Other errors (non-marketplace, non-plugin-specific) --- + for (const error of otherErrors) { + rows.push({ + label: error.source, + message: formatErrorMessage(error), + guidance: getErrorGuidance(error), + action: { + kind: 'none' + } + }); + } + return rows; +} + +/** + * Remove a marketplace from extraKnownMarketplaces in the given settings sources, + * and also remove any associated enabled plugins. + */ +function removeExtraMarketplace(name: string, sources: Array<{ + source: EditableSettingSource; +}>): void { + for (const { + source + } of sources) { + const settings = getSettingsForSource(source); + if (!settings) continue; + const updates: Record = {}; + + // Remove from extraKnownMarketplaces + if (settings.extraKnownMarketplaces?.[name]) { + updates.extraKnownMarketplaces = { + ...settings.extraKnownMarketplaces, + [name]: undefined + }; + } + + // Remove associated enabled plugins (format: "plugin@marketplace") + if (settings.enabledPlugins) { + const suffix = `@${name}`; + let removedPlugins = false; + const updatedPlugins = { + ...settings.enabledPlugins + }; + for (const pluginId in updatedPlugins) { + if (pluginId.endsWith(suffix)) { + updatedPlugins[pluginId] = undefined; + removedPlugins = true; + } + } + if (removedPlugins) { + updates.enabledPlugins = updatedPlugins; + } + } + if (Object.keys(updates).length > 0) { + updateSettingsForSource(source, updates); + } + } +} +function ErrorsTabContent(t0) { + const $ = _c(26); + const { + setViewState, + setActiveTab, + markPluginsChanged + } = t0; + const errors = useAppState(_temp2); + const installationStatus = useAppState(_temp3); + const setAppState = useSetAppState(); + const [selectedIndex, setSelectedIndex] = useState(0); + const [actionMessage, setActionMessage] = useState(null); + let t1; + if ($[0] === Symbol.for("react.memo_cache_sentinel")) { + t1 = []; + $[0] = t1; + } else { + t1 = $[0]; + } + const [marketplaceLoadFailures, setMarketplaceLoadFailures] = useState(t1); + let t2; + let t3; + if ($[1] === Symbol.for("react.memo_cache_sentinel")) { + t2 = () => { + (async () => { + try { + const config = await loadKnownMarketplacesConfig(); + const { + failures + } = await loadMarketplacesWithGracefulDegradation(config); + setMarketplaceLoadFailures(failures); + } catch {} + })(); + }; + t3 = []; + $[1] = t2; + $[2] = t3; + } else { + t2 = $[1]; + t3 = $[2]; + } + useEffect(t2, t3); + const failedMarketplaces = installationStatus.marketplaces.filter(_temp4); + const failedMarketplaceNames = new Set(failedMarketplaces.map(_temp5)); + const transientErrors = errors.filter(isTransientError); + const extraMarketplaceErrors = errors.filter(e => (e.type === "marketplace-not-found" || e.type === "marketplace-load-failed" || e.type === "marketplace-blocked-by-policy") && !failedMarketplaceNames.has(e.marketplace)); + const pluginLoadingErrors = errors.filter(_temp6); + const otherErrors = errors.filter(_temp7); + const pluginScopes = getPluginEditableScopes(); + const rows = buildErrorRows(failedMarketplaces, extraMarketplaceErrors, pluginLoadingErrors, otherErrors, marketplaceLoadFailures, transientErrors, pluginScopes); + let t4; + if ($[3] !== setViewState) { + t4 = () => { + setViewState({ + type: "menu" + }); + }; + $[3] = setViewState; + $[4] = t4; + } else { + t4 = $[4]; + } + let t5; + if ($[5] === Symbol.for("react.memo_cache_sentinel")) { + t5 = { + context: "Confirmation" + }; + $[5] = t5; + } else { + t5 = $[5]; + } + useKeybinding("confirm:no", t4, t5); + const handleSelect = () => { + const row = rows[selectedIndex]; + if (!row) { + return; + } + const { + action + } = row; + bb77: switch (action.kind) { + case "navigate": + { + setActiveTab(action.tab); + setViewState(action.viewState); + break bb77; + } + case "remove-extra-marketplace": + { + const scopes = action.sources.map(_temp8).join(", "); + removeExtraMarketplace(action.name, action.sources); + clearAllCaches(); + setAppState(prev_0 => ({ + ...prev_0, + plugins: { + ...prev_0.plugins, + errors: prev_0.plugins.errors.filter(e_2 => !("marketplace" in e_2 && e_2.marketplace === action.name)), + installationStatus: { + ...prev_0.plugins.installationStatus, + marketplaces: prev_0.plugins.installationStatus.marketplaces.filter(m_1 => m_1.name !== action.name) + } + } + })); + setActionMessage(`${figures.tick} Removed "${action.name}" from ${scopes} settings`); + markPluginsChanged(); + break bb77; + } + case "remove-installed-marketplace": + { + (async () => { + ; + try { + await removeMarketplaceSource(action.name); + clearAllCaches(); + setMarketplaceLoadFailures(prev => prev.filter(f => f.name !== action.name)); + setActionMessage(`${figures.tick} Removed marketplace "${action.name}"`); + markPluginsChanged(); + } catch (t6) { + const err = t6; + setActionMessage(`Failed to remove "${action.name}": ${err instanceof Error ? err.message : String(err)}`); + } + })(); + break bb77; + } + case "managed-only": + { + break bb77; + } + case "none": + } + }; + let t7; + if ($[6] === Symbol.for("react.memo_cache_sentinel")) { + t7 = () => setSelectedIndex(_temp9); + $[6] = t7; + } else { + t7 = $[6]; + } + const t8 = rows.length > 0; + let t9; + if ($[7] !== t8) { + t9 = { + context: "Select", + isActive: t8 + }; + $[7] = t8; + $[8] = t9; + } else { + t9 = $[8]; + } + useKeybindings({ + "select:previous": t7, + "select:next": () => setSelectedIndex(prev_2 => Math.min(rows.length - 1, prev_2 + 1)), + "select:accept": handleSelect + }, t9); + const clampedIndex = Math.min(selectedIndex, Math.max(0, rows.length - 1)); + if (clampedIndex !== selectedIndex) { + setSelectedIndex(clampedIndex); + } + const selectedAction = rows[clampedIndex]?.action; + const hasAction = selectedAction && selectedAction.kind !== "none" && selectedAction.kind !== "managed-only"; + if (rows.length === 0) { + let t10; + if ($[9] === Symbol.for("react.memo_cache_sentinel")) { + t10 = No plugin errors; + $[9] = t10; + } else { + t10 = $[9]; + } + let t11; + if ($[10] === Symbol.for("react.memo_cache_sentinel")) { + t11 = {t10}; + $[10] = t11; + } else { + t11 = $[10]; + } + return t11; + } + const T0 = Box; + const t10 = "column"; + let t11; + if ($[11] !== clampedIndex) { + t11 = (row_0, idx) => { + const isSelected = idx === clampedIndex; + return {isSelected ? figures.pointer : figures.cross}{" "}{row_0.label}{row_0.scope && ({row_0.scope})}{row_0.message}{row_0.guidance && {row_0.guidance}}; + }; + $[11] = clampedIndex; + $[12] = t11; + } else { + t11 = $[12]; + } + const t12 = rows.map(t11); + let t13; + if ($[13] !== actionMessage) { + t13 = actionMessage && {actionMessage}; + $[13] = actionMessage; + $[14] = t13; + } else { + t13 = $[14]; + } + let t14; + if ($[15] === Symbol.for("react.memo_cache_sentinel")) { + t14 = ; + $[15] = t14; + } else { + t14 = $[15]; + } + let t15; + if ($[16] !== hasAction) { + t15 = hasAction && ; + $[16] = hasAction; + $[17] = t15; + } else { + t15 = $[17]; + } + let t16; + if ($[18] === Symbol.for("react.memo_cache_sentinel")) { + t16 = ; + $[18] = t16; + } else { + t16 = $[18]; + } + let t17; + if ($[19] !== t15) { + t17 = {t14}{t15}{t16}; + $[19] = t15; + $[20] = t17; + } else { + t17 = $[20]; + } + let t18; + if ($[21] !== T0 || $[22] !== t12 || $[23] !== t13 || $[24] !== t17) { + t18 = {t12}{t13}{t17}; + $[21] = T0; + $[22] = t12; + $[23] = t13; + $[24] = t17; + $[25] = t18; + } else { + t18 = $[25]; + } + return t18; +} +function _temp9(prev_1) { + return Math.max(0, prev_1 - 1); +} +function _temp8(s_1) { + return s_1.scope; +} +function _temp7(e_1) { + if (isTransientError(e_1)) { + return false; + } + if (e_1.type === "marketplace-not-found" || e_1.type === "marketplace-load-failed" || e_1.type === "marketplace-blocked-by-policy") { + return false; + } + return getPluginNameFromError(e_1) === undefined; +} +function _temp6(e_0) { + if (isTransientError(e_0)) { + return false; + } + if (e_0.type === "marketplace-not-found" || e_0.type === "marketplace-load-failed" || e_0.type === "marketplace-blocked-by-policy") { + return false; + } + return getPluginNameFromError(e_0) !== undefined; +} +function _temp5(m_0) { + return m_0.name; +} +function _temp4(m) { + return m.status === "failed"; +} +function _temp3(s_0) { + return s_0.plugins.installationStatus; +} +function _temp2(s) { + return s.plugins.errors; +} +function getInitialViewState(parsedCommand: ParsedCommand): ViewState { + switch (parsedCommand.type) { + case 'help': + return { + type: 'help' + }; + case 'validate': + return { + type: 'validate', + path: parsedCommand.path + }; + case 'install': + if (parsedCommand.marketplace) { + return { + type: 'browse-marketplace', + targetMarketplace: parsedCommand.marketplace, + targetPlugin: parsedCommand.plugin + }; + } + if (parsedCommand.plugin) { + return { + type: 'discover-plugins', + targetPlugin: parsedCommand.plugin + }; + } + return { + type: 'discover-plugins' + }; + case 'manage': + return { + type: 'manage-plugins' + }; + case 'uninstall': + return { + type: 'manage-plugins', + targetPlugin: parsedCommand.plugin, + action: 'uninstall' + }; + case 'enable': + return { + type: 'manage-plugins', + targetPlugin: parsedCommand.plugin, + action: 'enable' + }; + case 'disable': + return { + type: 'manage-plugins', + targetPlugin: parsedCommand.plugin, + action: 'disable' + }; + case 'marketplace': + if (parsedCommand.action === 'list') { + return { + type: 'marketplace-list' + }; + } + if (parsedCommand.action === 'add') { + return { + type: 'add-marketplace', + initialValue: parsedCommand.target + }; + } + if (parsedCommand.action === 'remove') { + return { + type: 'manage-marketplaces', + targetMarketplace: parsedCommand.target, + action: 'remove' + }; + } + if (parsedCommand.action === 'update') { + return { + type: 'manage-marketplaces', + targetMarketplace: parsedCommand.target, + action: 'update' + }; + } + return { + type: 'marketplace-menu' + }; + case 'menu': + default: + // Default to discover view showing all plugins + return { + type: 'discover-plugins' + }; + } +} +function getInitialTab(viewState: ViewState): TabId { + if (viewState.type === 'manage-plugins') return 'installed'; + if (viewState.type === 'manage-marketplaces') return 'marketplaces'; + return 'discover'; +} +export function PluginSettings(t0) { + const $ = _c(75); + const { + onComplete, + args, + showMcpRedirectMessage + } = t0; + let parsedCommand; + let t1; + if ($[0] !== args) { + parsedCommand = parsePluginArgs(args); + t1 = getInitialViewState(parsedCommand); + $[0] = args; + $[1] = parsedCommand; + $[2] = t1; + } else { + parsedCommand = $[1]; + t1 = $[2]; + } + const initialViewState = t1; + const [viewState, setViewState] = useState(initialViewState); + let t2; + if ($[3] !== initialViewState) { + t2 = getInitialTab(initialViewState); + $[3] = initialViewState; + $[4] = t2; + } else { + t2 = $[4]; + } + const [activeTab, setActiveTab] = useState(t2); + const [inputValue, setInputValue] = useState(viewState.type === "add-marketplace" ? viewState.initialValue || "" : ""); + const [cursorOffset, setCursorOffset] = useState(0); + const [error, setError] = useState(null); + const [result, setResult] = useState(null); + const [childSearchActive, setChildSearchActive] = useState(false); + const setAppState = useSetAppState(); + const pluginErrorCount = useAppState(_temp0); + const errorsTabTitle = pluginErrorCount > 0 ? `Errors (${pluginErrorCount})` : "Errors"; + const exitState = useExitOnCtrlCDWithKeybindings(); + const cliMode = parsedCommand.type === "marketplace" && parsedCommand.action === "add" && parsedCommand.target !== undefined; + let t3; + if ($[5] !== setAppState) { + t3 = () => { + setAppState(_temp1); + }; + $[5] = setAppState; + $[6] = t3; + } else { + t3 = $[6]; + } + const markPluginsChanged = t3; + let t4; + if ($[7] === Symbol.for("react.memo_cache_sentinel")) { + t4 = tabId => { + const tab = tabId as TabId; + setActiveTab(tab); + setError(null); + bb37: switch (tab) { + case "discover": + { + setViewState({ + type: "discover-plugins" + }); + break bb37; + } + case "installed": + { + setViewState({ + type: "manage-plugins" + }); + break bb37; + } + case "marketplaces": + { + setViewState({ + type: "manage-marketplaces" + }); + break bb37; + } + case "errors": + } + }; + $[7] = t4; + } else { + t4 = $[7]; + } + const handleTabChange = t4; + let t5; + let t6; + if ($[8] !== onComplete || $[9] !== result || $[10] !== viewState.type) { + t5 = () => { + if (viewState.type === "menu" && !result) { + onComplete(); + } + }; + t6 = [viewState.type, result, onComplete]; + $[8] = onComplete; + $[9] = result; + $[10] = viewState.type; + $[11] = t5; + $[12] = t6; + } else { + t5 = $[11]; + t6 = $[12]; + } + useEffect(t5, t6); + let t7; + let t8; + if ($[13] !== activeTab || $[14] !== viewState.type) { + t7 = () => { + if (viewState.type === "browse-marketplace" && activeTab !== "discover") { + setActiveTab("discover"); + } + }; + t8 = [viewState.type, activeTab]; + $[13] = activeTab; + $[14] = viewState.type; + $[15] = t7; + $[16] = t8; + } else { + t7 = $[15]; + t8 = $[16]; + } + useEffect(t7, t8); + let t9; + if ($[17] === Symbol.for("react.memo_cache_sentinel")) { + t9 = () => { + setActiveTab("marketplaces"); + setViewState({ + type: "manage-marketplaces" + }); + setInputValue(""); + setError(null); + }; + $[17] = t9; + } else { + t9 = $[17]; + } + const handleAddMarketplaceEscape = t9; + const t10 = viewState.type === "add-marketplace"; + let t11; + if ($[18] !== t10) { + t11 = { + context: "Settings", + isActive: t10 + }; + $[18] = t10; + $[19] = t11; + } else { + t11 = $[19]; + } + useKeybinding("confirm:no", handleAddMarketplaceEscape, t11); + let t12; + let t13; + if ($[20] !== onComplete || $[21] !== result) { + t12 = () => { + if (result) { + onComplete(result); + } + }; + t13 = [result, onComplete]; + $[20] = onComplete; + $[21] = result; + $[22] = t12; + $[23] = t13; + } else { + t12 = $[22]; + t13 = $[23]; + } + useEffect(t12, t13); + let t14; + let t15; + if ($[24] !== onComplete || $[25] !== viewState.type) { + t14 = () => { + if (viewState.type === "help") { + onComplete(); + } + }; + t15 = [viewState.type, onComplete]; + $[24] = onComplete; + $[25] = viewState.type; + $[26] = t14; + $[27] = t15; + } else { + t14 = $[26]; + t15 = $[27]; + } + useEffect(t14, t15); + if (viewState.type === "help") { + let t16; + if ($[28] === Symbol.for("react.memo_cache_sentinel")) { + t16 = Plugin Command Usage: Installation: /plugin install - Browse and install plugins{" "}{"/plugin install - Install from specific marketplace"}{" /plugin install - Install specific plugin"}{" "}{"/plugin install @ - Install plugin from marketplace"} Management: /plugin manage - Manage installed plugins{" /plugin enable - Enable a plugin"}{" /plugin disable - Disable a plugin"}{" /plugin uninstall - Uninstall a plugin"} Marketplaces: /plugin marketplace - Marketplace management menu /plugin marketplace add - Add a marketplace{" "}{"/plugin marketplace add - Add marketplace directly"} /plugin marketplace update - Update marketplaces{" "}{"/plugin marketplace update - Update specific marketplace"} /plugin marketplace remove - Remove a marketplace{" "}{"/plugin marketplace remove - Remove specific marketplace"} /plugin marketplace list - List all marketplaces Validation:{" "}{"/plugin validate - Validate a manifest file or directory"} Other: /plugin - Main plugin menu /plugin help - Show this help /plugins - Alias for /plugin; + $[28] = t16; + } else { + t16 = $[28]; + } + return t16; + } + if (viewState.type === "validate") { + let t16; + if ($[29] !== onComplete || $[30] !== viewState.path) { + t16 = ; + $[29] = onComplete; + $[30] = viewState.path; + $[31] = t16; + } else { + t16 = $[31]; + } + return t16; + } + if (viewState.type === "marketplace-menu") { + setViewState({ + type: "menu" + }); + return null; + } + if (viewState.type === "marketplace-list") { + let t16; + if ($[32] !== onComplete) { + t16 = ; + $[32] = onComplete; + $[33] = t16; + } else { + t16 = $[33]; + } + return t16; + } + if (viewState.type === "add-marketplace") { + let t16; + if ($[34] !== cliMode || $[35] !== cursorOffset || $[36] !== error || $[37] !== inputValue || $[38] !== markPluginsChanged || $[39] !== result) { + t16 = ; + $[34] = cliMode; + $[35] = cursorOffset; + $[36] = error; + $[37] = inputValue; + $[38] = markPluginsChanged; + $[39] = result; + $[40] = t16; + } else { + t16 = $[40]; + } + return t16; + } + let t16; + if ($[41] !== activeTab || $[42] !== showMcpRedirectMessage) { + t16 = showMcpRedirectMessage && activeTab === "installed" ? : undefined; + $[41] = activeTab; + $[42] = showMcpRedirectMessage; + $[43] = t16; + } else { + t16 = $[43]; + } + let t17; + if ($[44] !== error || $[45] !== markPluginsChanged || $[46] !== result || $[47] !== viewState.targetMarketplace || $[48] !== viewState.targetPlugin || $[49] !== viewState.type) { + t17 = {viewState.type === "browse-marketplace" ? : }; + $[44] = error; + $[45] = markPluginsChanged; + $[46] = result; + $[47] = viewState.targetMarketplace; + $[48] = viewState.targetPlugin; + $[49] = viewState.type; + $[50] = t17; + } else { + t17 = $[50]; + } + const t18 = viewState.type === "manage-plugins" ? viewState.targetPlugin : undefined; + const t19 = viewState.type === "manage-plugins" ? viewState.targetMarketplace : undefined; + const t20 = viewState.type === "manage-plugins" ? viewState.action : undefined; + let t21; + if ($[51] !== markPluginsChanged || $[52] !== t18 || $[53] !== t19 || $[54] !== t20) { + t21 = ; + $[51] = markPluginsChanged; + $[52] = t18; + $[53] = t19; + $[54] = t20; + $[55] = t21; + } else { + t21 = $[55]; + } + const t22 = viewState.type === "manage-marketplaces" ? viewState.targetMarketplace : undefined; + const t23 = viewState.type === "manage-marketplaces" ? viewState.action : undefined; + let t24; + if ($[56] !== error || $[57] !== exitState || $[58] !== markPluginsChanged || $[59] !== t22 || $[60] !== t23) { + t24 = ; + $[56] = error; + $[57] = exitState; + $[58] = markPluginsChanged; + $[59] = t22; + $[60] = t23; + $[61] = t24; + } else { + t24 = $[61]; + } + let t25; + if ($[62] !== markPluginsChanged) { + t25 = ; + $[62] = markPluginsChanged; + $[63] = t25; + } else { + t25 = $[63]; + } + let t26; + if ($[64] !== errorsTabTitle || $[65] !== t25) { + t26 = {t25}; + $[64] = errorsTabTitle; + $[65] = t25; + $[66] = t26; + } else { + t26 = $[66]; + } + let t27; + if ($[67] !== activeTab || $[68] !== childSearchActive || $[69] !== t16 || $[70] !== t17 || $[71] !== t21 || $[72] !== t24 || $[73] !== t26) { + t27 = {t17}{t21}{t24}{t26}; + $[67] = activeTab; + $[68] = childSearchActive; + $[69] = t16; + $[70] = t17; + $[71] = t21; + $[72] = t24; + $[73] = t26; + $[74] = t27; + } else { + t27 = $[74]; + } + return t27; +} +function _temp1(prev) { + return prev.plugins.needsRefresh ? prev : { + ...prev, + plugins: { + ...prev.plugins, + needsRefresh: true + } + }; +} +function _temp0(s) { + let count = s.plugins.errors.length; + for (const m of s.plugins.installationStatus.marketplaces) { + if (m.status === "failed") { + count++; + } + } + return count; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useCallback","useEffect","useState","ConfigurableShortcutHint","Byline","Pane","Tab","Tabs","useExitOnCtrlCDWithKeybindings","Box","Text","useKeybinding","useKeybindings","useAppState","useSetAppState","PluginError","errorMessage","clearAllCaches","loadMarketplacesWithGracefulDegradation","loadKnownMarketplacesConfig","removeMarketplaceSource","getPluginEditableScopes","EditableSettingSource","getSettingsForSource","updateSettingsForSource","AddMarketplace","BrowseMarketplace","DiscoverPlugins","ManageMarketplaces","ManagePlugins","formatErrorMessage","getErrorGuidance","ParsedCommand","parsePluginArgs","PluginSettingsProps","ViewState","ValidatePlugin","TabId","MarketplaceList","t0","$","_c","onComplete","t1","t2","loadList","config","names","Object","keys","length","map","_temp","join","t3","err","Symbol","for","n","McpRedirectBanner","ErrorRowAction","kind","tab","viewState","name","sources","Array","source","scope","ErrorRow","label","message","guidance","action","getExtraMarketplaceSourceInfo","editableSources","isInPolicy","sourcesToCheck","const","settings","extraKnownMarketplaces","push","policySettings","Boolean","buildMarketplaceAction","type","targetMarketplace","buildPluginAction","pluginName","targetPlugin","TRANSIENT_ERROR_TYPES","Set","isTransientError","error","has","getPluginNameFromError","pluginId","plugin","includes","split","undefined","buildErrorRows","failedMarketplaces","extraMarketplaceErrors","pluginLoadingErrors","otherErrors","brokenInstalledMarketplaces","transientErrors","pluginScopes","Map","rows","shownMarketplaceNames","m","add","sourceInfo","e","marketplace","shownPluginNames","get","removeExtraMarketplace","updates","Record","enabledPlugins","suffix","removedPlugins","updatedPlugins","endsWith","ErrorsTabContent","setViewState","setActiveTab","markPluginsChanged","errors","_temp2","installationStatus","_temp3","setAppState","selectedIndex","setSelectedIndex","actionMessage","setActionMessage","marketplaceLoadFailures","setMarketplaceLoadFailures","failures","marketplaces","filter","_temp4","failedMarketplaceNames","_temp5","_temp6","_temp7","t4","t5","context","handleSelect","row","bb77","scopes","_temp8","prev_0","prev","plugins","e_2","m_1","tick","f","t6","Error","String","t7","_temp9","t8","t9","isActive","select:next","prev_2","Math","min","clampedIndex","max","selectedAction","hasAction","t10","t11","T0","row_0","idx","isSelected","pointer","cross","t12","t13","t14","t15","t16","t17","t18","prev_1","s_1","s","e_1","e_0","m_0","status","s_0","getInitialViewState","parsedCommand","path","initialValue","target","getInitialTab","PluginSettings","args","showMcpRedirectMessage","initialViewState","activeTab","inputValue","setInputValue","cursorOffset","setCursorOffset","setError","result","setResult","childSearchActive","setChildSearchActive","pluginErrorCount","_temp0","errorsTabTitle","exitState","cliMode","_temp1","tabId","bb37","handleTabChange","handleAddMarketplaceEscape","t19","t20","t21","t22","t23","t24","t25","t26","t27","needsRefresh","count"],"sources":["PluginSettings.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { useCallback, useEffect, useState } from 'react'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { Pane } from '../../components/design-system/Pane.js'\nimport { Tab, Tabs } from '../../components/design-system/Tabs.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { Box, Text } from '../../ink.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport { useAppState, useSetAppState } from '../../state/AppState.js'\nimport type { PluginError } from '../../types/plugin.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport { loadMarketplacesWithGracefulDegradation } from '../../utils/plugins/marketplaceHelpers.js'\nimport {\n  loadKnownMarketplacesConfig,\n  removeMarketplaceSource,\n} from '../../utils/plugins/marketplaceManager.js'\nimport { getPluginEditableScopes } from '../../utils/plugins/pluginStartupCheck.js'\nimport type { EditableSettingSource } from '../../utils/settings/constants.js'\nimport {\n  getSettingsForSource,\n  updateSettingsForSource,\n} from '../../utils/settings/settings.js'\nimport { AddMarketplace } from './AddMarketplace.js'\nimport { BrowseMarketplace } from './BrowseMarketplace.js'\nimport { DiscoverPlugins } from './DiscoverPlugins.js'\nimport { ManageMarketplaces } from './ManageMarketplaces.js'\nimport { ManagePlugins } from './ManagePlugins.js'\nimport { formatErrorMessage, getErrorGuidance } from './PluginErrors.js'\nimport { type ParsedCommand, parsePluginArgs } from './parseArgs.js'\nimport type { PluginSettingsProps, ViewState } from './types.js'\nimport { ValidatePlugin } from './ValidatePlugin.js'\n\ntype TabId = 'discover' | 'installed' | 'marketplaces' | 'errors'\n\nfunction MarketplaceList({\n  onComplete,\n}: {\n  onComplete: (result?: string) => void\n}): React.ReactNode {\n  useEffect(() => {\n    async function loadList() {\n      try {\n        const config = await loadKnownMarketplacesConfig()\n        const names = Object.keys(config)\n\n        if (names.length === 0) {\n          onComplete('No marketplaces configured')\n        } else {\n          onComplete(\n            `Configured marketplaces:\\n${names.map(n => `  • ${n}`).join('\\n')}`,\n          )\n        }\n      } catch (err) {\n        onComplete(`Error loading marketplaces: ${errorMessage(err)}`)\n      }\n    }\n\n    void loadList()\n  }, [onComplete])\n\n  return <Text>Loading marketplaces...</Text>\n}\n\nfunction McpRedirectBanner(): React.ReactNode {\n  if (\"external\" !== 'ant') {\n    return null\n  }\n\n  return (\n    <Box\n      flexDirection=\"row\"\n      alignItems=\"flex-start\"\n      paddingLeft={1}\n      marginTop={1}\n      borderLeft\n      borderRight={false}\n      borderTop={false}\n      borderBottom={false}\n      borderColor=\"permission\"\n      borderStyle=\"single\"\n    >\n      <Box flexShrink={0}>\n        <Text bold italic color=\"permission\">\n          i{' '}\n        </Text>\n      </Box>\n      <Text>\n        [ANT-ONLY] MCP servers are now managed in /plugins. Use /mcp no-redirect\n        to test old UI\n      </Text>\n    </Box>\n  )\n}\n\ntype ErrorRowAction =\n  | { kind: 'navigate'; tab: TabId; viewState: ViewState }\n  | {\n      kind: 'remove-extra-marketplace'\n      name: string\n      sources: Array<{ source: EditableSettingSource; scope: string }>\n    }\n  | { kind: 'remove-installed-marketplace'; name: string }\n  | { kind: 'managed-only'; name: string }\n  | { kind: 'none' }\n\ntype ErrorRow = {\n  label: string\n  message: string\n  guidance?: string | null\n  action: ErrorRowAction\n  scope?: string\n}\n\n/**\n * Determine which settings sources define an extraKnownMarketplace entry.\n * Returns the editable sources (user/project/local) and whether policy also has it.\n */\nfunction getExtraMarketplaceSourceInfo(name: string): {\n  editableSources: Array<{ source: EditableSettingSource; scope: string }>\n  isInPolicy: boolean\n} {\n  const editableSources: Array<{\n    source: EditableSettingSource\n    scope: string\n  }> = []\n\n  const sourcesToCheck = [\n    { source: 'userSettings' as const, scope: 'user' },\n    { source: 'projectSettings' as const, scope: 'project' },\n    { source: 'localSettings' as const, scope: 'local' },\n  ]\n\n  for (const { source, scope } of sourcesToCheck) {\n    const settings = getSettingsForSource(source)\n    if (settings?.extraKnownMarketplaces?.[name]) {\n      editableSources.push({ source, scope })\n    }\n  }\n\n  const policySettings = getSettingsForSource('policySettings')\n  const isInPolicy = Boolean(policySettings?.extraKnownMarketplaces?.[name])\n\n  return { editableSources, isInPolicy }\n}\n\nfunction buildMarketplaceAction(name: string): ErrorRowAction {\n  const { editableSources, isInPolicy } = getExtraMarketplaceSourceInfo(name)\n\n  if (editableSources.length > 0) {\n    return {\n      kind: 'remove-extra-marketplace',\n      name,\n      sources: editableSources,\n    }\n  }\n\n  if (isInPolicy) {\n    return { kind: 'managed-only', name }\n  }\n\n  // Marketplace is in known_marketplaces.json but not in extraKnownMarketplaces\n  // (e.g. previously installed manually) — route to ManageMarketplaces\n  return {\n    kind: 'navigate',\n    tab: 'marketplaces',\n    viewState: {\n      type: 'manage-marketplaces',\n      targetMarketplace: name,\n      action: 'remove',\n    },\n  }\n}\n\nfunction buildPluginAction(pluginName: string): ErrorRowAction {\n  return {\n    kind: 'navigate',\n    tab: 'installed',\n    viewState: {\n      type: 'manage-plugins',\n      targetPlugin: pluginName,\n      action: 'uninstall',\n    },\n  }\n}\n\nconst TRANSIENT_ERROR_TYPES = new Set([\n  'git-auth-failed',\n  'git-timeout',\n  'network-error',\n])\n\nfunction isTransientError(error: PluginError): boolean {\n  return TRANSIENT_ERROR_TYPES.has(error.type)\n}\n\n/**\n * Extract the plugin name from a PluginError, checking explicit fields first,\n * then falling back to the source field (format: \"pluginName@marketplace\").\n */\nfunction getPluginNameFromError(error: PluginError): string | undefined {\n  if ('pluginId' in error && error.pluginId) return error.pluginId\n  if ('plugin' in error && error.plugin) return error.plugin\n  // Fallback: source often contains \"pluginName@marketplace\"\n  if (error.source.includes('@')) return error.source.split('@')[0]\n  return undefined\n}\n\nfunction buildErrorRows(\n  failedMarketplaces: Array<{ name: string; error?: string }>,\n  extraMarketplaceErrors: PluginError[],\n  pluginLoadingErrors: PluginError[],\n  otherErrors: PluginError[],\n  brokenInstalledMarketplaces: Array<{ name: string; error: string }>,\n  transientErrors: PluginError[],\n  pluginScopes: Map<string, string>,\n): ErrorRow[] {\n  const rows: ErrorRow[] = []\n\n  // --- Transient errors at the top (restart to retry) ---\n  for (const error of transientErrors) {\n    const pluginName =\n      'pluginId' in error\n        ? error.pluginId\n        : 'plugin' in error\n          ? error.plugin\n          : undefined\n    rows.push({\n      label: pluginName ?? error.source,\n      message: formatErrorMessage(error),\n      guidance: 'Restart to retry loading plugins',\n      action: { kind: 'none' },\n    })\n  }\n\n  // --- Marketplace errors ---\n  // Track shown marketplace names to avoid duplicates across sources\n  const shownMarketplaceNames = new Set<string>()\n\n  for (const m of failedMarketplaces) {\n    shownMarketplaceNames.add(m.name)\n    const action = buildMarketplaceAction(m.name)\n    const sourceInfo = getExtraMarketplaceSourceInfo(m.name)\n    const scope = sourceInfo.isInPolicy\n      ? 'managed'\n      : sourceInfo.editableSources[0]?.scope\n    rows.push({\n      label: m.name,\n      message: m.error ?? 'Installation failed',\n      guidance:\n        action.kind === 'managed-only'\n          ? 'Managed by your organization — contact your admin'\n          : undefined,\n      action,\n      scope,\n    })\n  }\n\n  for (const e of extraMarketplaceErrors) {\n    const marketplace = 'marketplace' in e ? e.marketplace : e.source\n    if (shownMarketplaceNames.has(marketplace)) continue\n    shownMarketplaceNames.add(marketplace)\n    const action = buildMarketplaceAction(marketplace)\n    const sourceInfo = getExtraMarketplaceSourceInfo(marketplace)\n    const scope = sourceInfo.isInPolicy\n      ? 'managed'\n      : sourceInfo.editableSources[0]?.scope\n    rows.push({\n      label: marketplace,\n      message: formatErrorMessage(e),\n      guidance:\n        action.kind === 'managed-only'\n          ? 'Managed by your organization — contact your admin'\n          : getErrorGuidance(e),\n      action,\n      scope,\n    })\n  }\n\n  // Installed marketplaces that fail to load data (from known_marketplaces.json)\n  for (const m of brokenInstalledMarketplaces) {\n    if (shownMarketplaceNames.has(m.name)) continue\n    shownMarketplaceNames.add(m.name)\n    rows.push({\n      label: m.name,\n      message: m.error,\n      action: { kind: 'remove-installed-marketplace', name: m.name },\n    })\n  }\n\n  // --- Plugin errors ---\n  const shownPluginNames = new Set<string>()\n  for (const error of pluginLoadingErrors) {\n    const pluginName = getPluginNameFromError(error)\n    if (pluginName && shownPluginNames.has(pluginName)) continue\n    if (pluginName) shownPluginNames.add(pluginName)\n\n    const marketplace = 'marketplace' in error ? error.marketplace : undefined\n    // Try pluginId@marketplace format first, then just pluginName\n    const scope = pluginName\n      ? (pluginScopes.get(error.source) ?? pluginScopes.get(pluginName))\n      : undefined\n    rows.push({\n      label: pluginName\n        ? marketplace\n          ? `${pluginName} @ ${marketplace}`\n          : pluginName\n        : error.source,\n      message: formatErrorMessage(error),\n      guidance: getErrorGuidance(error),\n      action: pluginName ? buildPluginAction(pluginName) : { kind: 'none' },\n      scope,\n    })\n  }\n\n  // --- Other errors (non-marketplace, non-plugin-specific) ---\n  for (const error of otherErrors) {\n    rows.push({\n      label: error.source,\n      message: formatErrorMessage(error),\n      guidance: getErrorGuidance(error),\n      action: { kind: 'none' },\n    })\n  }\n\n  return rows\n}\n\n/**\n * Remove a marketplace from extraKnownMarketplaces in the given settings sources,\n * and also remove any associated enabled plugins.\n */\nfunction removeExtraMarketplace(\n  name: string,\n  sources: Array<{ source: EditableSettingSource }>,\n): void {\n  for (const { source } of sources) {\n    const settings = getSettingsForSource(source)\n    if (!settings) continue\n\n    const updates: Record<string, unknown> = {}\n\n    // Remove from extraKnownMarketplaces\n    if (settings.extraKnownMarketplaces?.[name]) {\n      updates.extraKnownMarketplaces = {\n        ...settings.extraKnownMarketplaces,\n        [name]: undefined,\n      }\n    }\n\n    // Remove associated enabled plugins (format: \"plugin@marketplace\")\n    if (settings.enabledPlugins) {\n      const suffix = `@${name}`\n      let removedPlugins = false\n      const updatedPlugins = { ...settings.enabledPlugins }\n      for (const pluginId in updatedPlugins) {\n        if (pluginId.endsWith(suffix)) {\n          updatedPlugins[pluginId] = undefined\n          removedPlugins = true\n        }\n      }\n      if (removedPlugins) {\n        updates.enabledPlugins = updatedPlugins\n      }\n    }\n\n    if (Object.keys(updates).length > 0) {\n      updateSettingsForSource(source, updates)\n    }\n  }\n}\n\nfunction ErrorsTabContent({\n  setViewState,\n  setActiveTab,\n  markPluginsChanged,\n}: {\n  setViewState: (state: ViewState) => void\n  setActiveTab: (tab: TabId) => void\n  markPluginsChanged: () => void\n}): React.ReactNode {\n  const errors = useAppState(s => s.plugins.errors)\n  const installationStatus = useAppState(s => s.plugins.installationStatus)\n  const setAppState = useSetAppState()\n  const [selectedIndex, setSelectedIndex] = useState(0)\n  const [actionMessage, setActionMessage] = useState<string | null>(null)\n  const [marketplaceLoadFailures, setMarketplaceLoadFailures] = useState<\n    Array<{ name: string; error: string }>\n  >([])\n\n  // Detect marketplaces that are installed but fail to load their data\n  useEffect(() => {\n    void (async () => {\n      try {\n        const config = await loadKnownMarketplacesConfig()\n        const { failures } =\n          await loadMarketplacesWithGracefulDegradation(config)\n        setMarketplaceLoadFailures(failures)\n      } catch {\n        // Ignore — if we can't load config, other tabs handle it\n      }\n    })()\n  }, [])\n\n  const failedMarketplaces = installationStatus.marketplaces.filter(\n    m => m.status === 'failed',\n  )\n  const failedMarketplaceNames = new Set(failedMarketplaces.map(m => m.name))\n\n  // Transient errors (git/network) — show at top with \"restart to retry\"\n  const transientErrors = errors.filter(isTransientError)\n\n  // Marketplace-related loading errors not already covered by install failures\n  const extraMarketplaceErrors = errors.filter(\n    e =>\n      (e.type === 'marketplace-not-found' ||\n        e.type === 'marketplace-load-failed' ||\n        e.type === 'marketplace-blocked-by-policy') &&\n      !failedMarketplaceNames.has(e.marketplace),\n  )\n\n  // Plugin-specific loading errors\n  const pluginLoadingErrors = errors.filter(e => {\n    if (isTransientError(e)) return false\n    if (\n      e.type === 'marketplace-not-found' ||\n      e.type === 'marketplace-load-failed' ||\n      e.type === 'marketplace-blocked-by-policy'\n    ) {\n      return false\n    }\n    return getPluginNameFromError(e) !== undefined\n  })\n\n  // Remaining errors with no plugin association\n  const otherErrors = errors.filter(e => {\n    if (isTransientError(e)) return false\n    if (\n      e.type === 'marketplace-not-found' ||\n      e.type === 'marketplace-load-failed' ||\n      e.type === 'marketplace-blocked-by-policy'\n    ) {\n      return false\n    }\n    return getPluginNameFromError(e) === undefined\n  })\n\n  const pluginScopes = getPluginEditableScopes()\n  const rows = buildErrorRows(\n    failedMarketplaces,\n    extraMarketplaceErrors,\n    pluginLoadingErrors,\n    otherErrors,\n    marketplaceLoadFailures,\n    transientErrors,\n    pluginScopes,\n  )\n\n  // Handle escape to exit the plugin menu\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setViewState({ type: 'menu' })\n    },\n    { context: 'Confirmation' },\n  )\n\n  const handleSelect = () => {\n    const row = rows[selectedIndex]\n    if (!row) return\n    const { action } = row\n    switch (action.kind) {\n      case 'navigate':\n        setActiveTab(action.tab)\n        setViewState(action.viewState)\n        break\n      case 'remove-extra-marketplace': {\n        const scopes = action.sources.map(s => s.scope).join(', ')\n        removeExtraMarketplace(action.name, action.sources)\n        clearAllCaches()\n        // Synchronously clear all stale state for this marketplace so the UI\n        // updates glitch-free. markPluginsChanged only sets needsRefresh —\n        // it does not refresh plugins.errors, so this is the authoritative\n        // cleanup until the user runs /reload-plugins.\n        setAppState(prev => ({\n          ...prev,\n          plugins: {\n            ...prev.plugins,\n            errors: prev.plugins.errors.filter(\n              e => !('marketplace' in e && e.marketplace === action.name),\n            ),\n            installationStatus: {\n              ...prev.plugins.installationStatus,\n              marketplaces: prev.plugins.installationStatus.marketplaces.filter(\n                m => m.name !== action.name,\n              ),\n            },\n          },\n        }))\n        setActionMessage(\n          `${figures.tick} Removed \"${action.name}\" from ${scopes} settings`,\n        )\n        markPluginsChanged()\n        break\n      }\n      case 'remove-installed-marketplace': {\n        void (async () => {\n          try {\n            await removeMarketplaceSource(action.name)\n            clearAllCaches()\n            setMarketplaceLoadFailures(prev =>\n              prev.filter(f => f.name !== action.name),\n            )\n            setActionMessage(\n              `${figures.tick} Removed marketplace \"${action.name}\"`,\n            )\n            markPluginsChanged()\n          } catch (err) {\n            setActionMessage(\n              `Failed to remove \"${action.name}\": ${err instanceof Error ? err.message : String(err)}`,\n            )\n          }\n        })()\n        break\n      }\n      case 'managed-only':\n        // No action available — guidance text already shown\n        break\n      case 'none':\n        break\n    }\n  }\n\n  useKeybindings(\n    {\n      'select:previous': () => setSelectedIndex(prev => Math.max(0, prev - 1)),\n      'select:next': () =>\n        setSelectedIndex(prev => Math.min(rows.length - 1, prev + 1)),\n      'select:accept': handleSelect,\n    },\n    { context: 'Select', isActive: rows.length > 0 },\n  )\n\n  // Clamp selectedIndex when rows shrink (e.g. after removal)\n  const clampedIndex = Math.min(selectedIndex, Math.max(0, rows.length - 1))\n  if (clampedIndex !== selectedIndex) {\n    setSelectedIndex(clampedIndex)\n  }\n\n  const selectedAction = rows[clampedIndex]?.action\n  const hasAction =\n    selectedAction &&\n    selectedAction.kind !== 'none' &&\n    selectedAction.kind !== 'managed-only'\n\n  if (rows.length === 0) {\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginLeft={1}>\n          <Text dimColor>No plugin errors</Text>\n        </Box>\n        <Box marginTop={1}>\n          <Text dimColor italic>\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"back\"\n            />\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  return (\n    <Box flexDirection=\"column\">\n      {rows.map((row, idx) => {\n        const isSelected = idx === clampedIndex\n        return (\n          <Box key={idx} marginLeft={1} flexDirection=\"column\" marginBottom={1}>\n            <Text>\n              <Text color={isSelected ? 'suggestion' : 'error'}>\n                {isSelected ? figures.pointer : figures.cross}{' '}\n              </Text>\n              <Text bold={isSelected}>{row.label}</Text>\n              {row.scope && <Text dimColor> ({row.scope})</Text>}\n            </Text>\n            <Box marginLeft={3}>\n              <Text color=\"error\">{row.message}</Text>\n            </Box>\n            {row.guidance && (\n              <Box marginLeft={3}>\n                <Text dimColor italic>\n                  {row.guidance}\n                </Text>\n              </Box>\n            )}\n          </Box>\n        )\n      })}\n\n      {actionMessage && (\n        <Box marginTop={1} marginLeft={1}>\n          <Text color=\"claude\">{actionMessage}</Text>\n        </Box>\n      )}\n\n      <Box marginTop={1}>\n        <Text dimColor italic>\n          <Byline>\n            <ConfigurableShortcutHint\n              action=\"select:previous\"\n              context=\"Select\"\n              fallback=\"↑\"\n              description=\"navigate\"\n            />\n            {hasAction && (\n              <ConfigurableShortcutHint\n                action=\"select:accept\"\n                context=\"Select\"\n                fallback=\"Enter\"\n                description=\"resolve\"\n              />\n            )}\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"back\"\n            />\n          </Byline>\n        </Text>\n      </Box>\n    </Box>\n  )\n}\n\nfunction getInitialViewState(parsedCommand: ParsedCommand): ViewState {\n  switch (parsedCommand.type) {\n    case 'help':\n      return { type: 'help' }\n    case 'validate':\n      return { type: 'validate', path: parsedCommand.path }\n    case 'install':\n      if (parsedCommand.marketplace) {\n        return {\n          type: 'browse-marketplace',\n          targetMarketplace: parsedCommand.marketplace,\n          targetPlugin: parsedCommand.plugin,\n        }\n      }\n      if (parsedCommand.plugin) {\n        return {\n          type: 'discover-plugins',\n          targetPlugin: parsedCommand.plugin,\n        }\n      }\n      return { type: 'discover-plugins' }\n    case 'manage':\n      return { type: 'manage-plugins' }\n    case 'uninstall':\n      return {\n        type: 'manage-plugins',\n        targetPlugin: parsedCommand.plugin,\n        action: 'uninstall',\n      }\n    case 'enable':\n      return {\n        type: 'manage-plugins',\n        targetPlugin: parsedCommand.plugin,\n        action: 'enable',\n      }\n    case 'disable':\n      return {\n        type: 'manage-plugins',\n        targetPlugin: parsedCommand.plugin,\n        action: 'disable',\n      }\n    case 'marketplace':\n      if (parsedCommand.action === 'list') {\n        return { type: 'marketplace-list' }\n      }\n      if (parsedCommand.action === 'add') {\n        return {\n          type: 'add-marketplace',\n          initialValue: parsedCommand.target,\n        }\n      }\n      if (parsedCommand.action === 'remove') {\n        return {\n          type: 'manage-marketplaces',\n          targetMarketplace: parsedCommand.target,\n          action: 'remove',\n        }\n      }\n      if (parsedCommand.action === 'update') {\n        return {\n          type: 'manage-marketplaces',\n          targetMarketplace: parsedCommand.target,\n          action: 'update',\n        }\n      }\n      return { type: 'marketplace-menu' }\n    case 'menu':\n    default:\n      // Default to discover view showing all plugins\n      return { type: 'discover-plugins' }\n  }\n}\n\nfunction getInitialTab(viewState: ViewState): TabId {\n  if (viewState.type === 'manage-plugins') return 'installed'\n  if (viewState.type === 'manage-marketplaces') return 'marketplaces'\n  return 'discover'\n}\n\nexport function PluginSettings({\n  onComplete,\n  args,\n  showMcpRedirectMessage,\n}: PluginSettingsProps): React.ReactNode {\n  const parsedCommand = parsePluginArgs(args)\n  const initialViewState = getInitialViewState(parsedCommand)\n  const [viewState, setViewState] = useState<ViewState>(initialViewState)\n  const [activeTab, setActiveTab] = useState<TabId>(\n    getInitialTab(initialViewState),\n  )\n  const [inputValue, setInputValue] = useState(\n    viewState.type === 'add-marketplace' ? viewState.initialValue || '' : '',\n  )\n  const [cursorOffset, setCursorOffset] = useState(0)\n  const [error, setError] = useState<string | null>(null)\n  const [result, setResult] = useState<string | null>(null)\n  const [childSearchActive, setChildSearchActive] = useState(false)\n  const setAppState = useSetAppState()\n\n  // Error count for the Errors tab badge — counts loader errors + background\n  // marketplace install failures. Does NOT count marketplace-on-disk load\n  // failures (those require I/O and are discovered lazily when the tab opens).\n  // May slightly overcount vs. displayed rows when a marketplace has both a\n  // loader error and a failed install status (buildErrorRows deduplicates).\n  const pluginErrorCount = useAppState(s => {\n    let count = s.plugins.errors.length\n    for (const m of s.plugins.installationStatus.marketplaces) {\n      if (m.status === 'failed') count++\n    }\n    return count\n  })\n  const errorsTabTitle =\n    pluginErrorCount > 0 ? `Errors (${pluginErrorCount})` : 'Errors'\n\n  const exitState = useExitOnCtrlCDWithKeybindings()\n\n  /**\n   * CLI mode is active when the user provides a complete command with all required arguments.\n   * In this mode, the operation executes immediately without interactive prompts.\n   * Interactive mode is used when arguments are missing, allowing the user to input them.\n   */\n  const cliMode =\n    parsedCommand.type === 'marketplace' &&\n    parsedCommand.action === 'add' &&\n    parsedCommand.target !== undefined\n\n  // Signal that plugin state has changed on disk (Layer 2) and active\n  // components (Layer 3) are stale. User runs /reload-plugins to apply.\n  // Previously this was updatePluginState() which did a partial refresh\n  // (commands only — agents/hooks/MCP were silently skipped). Now all\n  // Layer-3 refresh flows through the unified refreshActivePlugins()\n  // primitive via /reload-plugins, giving one consistent mental model:\n  // plugin changes require /reload-plugins.\n  const markPluginsChanged = useCallback(() => {\n    setAppState(prev =>\n      prev.plugins.needsRefresh\n        ? prev\n        : { ...prev, plugins: { ...prev.plugins, needsRefresh: true } },\n    )\n  }, [setAppState])\n\n  // Handle tab switching (called by Tabs component)\n  const handleTabChange = useCallback((tabId: string) => {\n    const tab = tabId as TabId\n    setActiveTab(tab)\n    setError(null)\n    switch (tab) {\n      case 'discover':\n        setViewState({ type: 'discover-plugins' })\n        break\n      case 'installed':\n        setViewState({ type: 'manage-plugins' })\n        break\n      case 'marketplaces':\n        setViewState({ type: 'manage-marketplaces' })\n        break\n      case 'errors':\n        // No viewState change needed — ErrorsTabContent renders inside <Tab id=\"errors\">\n        break\n    }\n  }, [])\n\n  // Handle exiting when child components set viewState to 'menu'.\n  // Child components typically set BOTH setResult(msg) and setParentViewState\n  // ({type:'menu'}) — both effects fire on the same render. Only close via this\n  // path when there's no result, otherwise the result effect (below) handles\n  // the close AND delivers the message to the transcript.\n  useEffect(() => {\n    if (viewState.type === 'menu' && !result) {\n      onComplete()\n    }\n  }, [viewState.type, result, onComplete])\n\n  // Sync activeTab when viewState changes to a different tab's content\n  // This handles cases like AddMarketplace navigating to browse-marketplace\n  useEffect(() => {\n    if (viewState.type === 'browse-marketplace' && activeTab !== 'discover') {\n      setActiveTab('discover')\n    }\n  }, [viewState.type, activeTab])\n\n  // Handle escape key for add-marketplace mode only\n  // Other tabbed views handle escape in their own components\n  const handleAddMarketplaceEscape = useCallback(() => {\n    setActiveTab('marketplaces')\n    setViewState({ type: 'manage-marketplaces' })\n    setInputValue('')\n    setError(null)\n  }, [])\n\n  useKeybinding('confirm:no', handleAddMarketplaceEscape, {\n    context: 'Settings',\n    isActive: viewState.type === 'add-marketplace',\n  })\n\n  useEffect(() => {\n    if (result) {\n      onComplete(result)\n    }\n  }, [result, onComplete])\n\n  // Handle help view completion\n  useEffect(() => {\n    if (viewState.type === 'help') {\n      onComplete()\n    }\n  }, [viewState.type, onComplete])\n\n  // Render different views based on state\n  if (viewState.type === 'help') {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>Plugin Command Usage:</Text>\n        <Text> </Text>\n        <Text dimColor>Installation:</Text>\n        <Text> /plugin install - Browse and install plugins</Text>\n        <Text>\n          {' '}\n          /plugin install &lt;marketplace&gt; - Install from specific\n          marketplace\n        </Text>\n        <Text> /plugin install &lt;plugin&gt; - Install specific plugin</Text>\n        <Text>\n          {' '}\n          /plugin install &lt;plugin&gt;@&lt;market&gt; - Install plugin from\n          marketplace\n        </Text>\n        <Text> </Text>\n        <Text dimColor>Management:</Text>\n        <Text> /plugin manage - Manage installed plugins</Text>\n        <Text> /plugin enable &lt;plugin&gt; - Enable a plugin</Text>\n        <Text> /plugin disable &lt;plugin&gt; - Disable a plugin</Text>\n        <Text> /plugin uninstall &lt;plugin&gt; - Uninstall a plugin</Text>\n        <Text> </Text>\n        <Text dimColor>Marketplaces:</Text>\n        <Text> /plugin marketplace - Marketplace management menu</Text>\n        <Text> /plugin marketplace add - Add a marketplace</Text>\n        <Text>\n          {' '}\n          /plugin marketplace add &lt;path/url&gt; - Add marketplace directly\n        </Text>\n        <Text> /plugin marketplace update - Update marketplaces</Text>\n        <Text>\n          {' '}\n          /plugin marketplace update &lt;name&gt; - Update specific marketplace\n        </Text>\n        <Text> /plugin marketplace remove - Remove a marketplace</Text>\n        <Text>\n          {' '}\n          /plugin marketplace remove &lt;name&gt; - Remove specific marketplace\n        </Text>\n        <Text> /plugin marketplace list - List all marketplaces</Text>\n        <Text> </Text>\n        <Text dimColor>Validation:</Text>\n        <Text>\n          {' '}\n          /plugin validate &lt;path&gt; - Validate a manifest file or directory\n        </Text>\n        <Text> </Text>\n        <Text dimColor>Other:</Text>\n        <Text> /plugin - Main plugin menu</Text>\n        <Text> /plugin help - Show this help</Text>\n        <Text> /plugins - Alias for /plugin</Text>\n      </Box>\n    )\n  }\n\n  if (viewState.type === 'validate') {\n    return <ValidatePlugin onComplete={onComplete} path={viewState.path} />\n  }\n\n  if (viewState.type === 'marketplace-menu') {\n    // Show a simple menu for marketplace operations\n    setViewState({ type: 'menu' })\n    return null\n  }\n\n  if (viewState.type === 'marketplace-list') {\n    return <MarketplaceList onComplete={onComplete} />\n  }\n\n  if (viewState.type === 'add-marketplace') {\n    return (\n      <AddMarketplace\n        inputValue={inputValue}\n        setInputValue={setInputValue}\n        cursorOffset={cursorOffset}\n        setCursorOffset={setCursorOffset}\n        error={error}\n        setError={setError}\n        result={result}\n        setResult={setResult}\n        setViewState={setViewState}\n        onAddComplete={markPluginsChanged}\n        cliMode={cliMode}\n      />\n    )\n  }\n  // Render tabbed interface using the design system Tabs component\n  return (\n    <Pane color=\"suggestion\">\n      <Tabs\n        title=\"Plugins\"\n        selectedTab={activeTab}\n        onTabChange={handleTabChange}\n        color=\"suggestion\"\n        disableNavigation={childSearchActive}\n        banner={\n          showMcpRedirectMessage && activeTab === 'installed' ? (\n            <McpRedirectBanner />\n          ) : undefined\n        }\n      >\n        <Tab id=\"discover\" title=\"Discover\">\n          {viewState.type === 'browse-marketplace' ? (\n            <BrowseMarketplace\n              error={error}\n              setError={setError}\n              result={result}\n              setResult={setResult}\n              setViewState={setViewState}\n              onInstallComplete={markPluginsChanged}\n              targetMarketplace={viewState.targetMarketplace}\n              targetPlugin={viewState.targetPlugin}\n            />\n          ) : (\n            <DiscoverPlugins\n              error={error}\n              setError={setError}\n              result={result}\n              setResult={setResult}\n              setViewState={setViewState}\n              onInstallComplete={markPluginsChanged}\n              onSearchModeChange={setChildSearchActive}\n              targetPlugin={\n                viewState.type === 'discover-plugins'\n                  ? viewState.targetPlugin\n                  : undefined\n              }\n            />\n          )}\n        </Tab>\n        <Tab id=\"installed\" title=\"Installed\">\n          <ManagePlugins\n            setViewState={setViewState}\n            setResult={setResult}\n            onManageComplete={markPluginsChanged}\n            onSearchModeChange={setChildSearchActive}\n            targetPlugin={\n              viewState.type === 'manage-plugins'\n                ? viewState.targetPlugin\n                : undefined\n            }\n            targetMarketplace={\n              viewState.type === 'manage-plugins'\n                ? viewState.targetMarketplace\n                : undefined\n            }\n            action={\n              viewState.type === 'manage-plugins' ? viewState.action : undefined\n            }\n          />\n        </Tab>\n        <Tab id=\"marketplaces\" title=\"Marketplaces\">\n          <ManageMarketplaces\n            setViewState={setViewState}\n            error={error}\n            setError={setError}\n            setResult={setResult}\n            exitState={exitState}\n            onManageComplete={markPluginsChanged}\n            targetMarketplace={\n              viewState.type === 'manage-marketplaces'\n                ? viewState.targetMarketplace\n                : undefined\n            }\n            action={\n              viewState.type === 'manage-marketplaces'\n                ? viewState.action\n                : undefined\n            }\n          />\n        </Tab>\n        <Tab id=\"errors\" title={errorsTabTitle}>\n          <ErrorsTabContent\n            setViewState={setViewState}\n            setActiveTab={setActiveTab}\n            markPluginsChanged={markPluginsChanged}\n          />\n        </Tab>\n      </Tabs>\n    </Pane>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/PluginTrustWarning.tsx b/src/commands/plugin/PluginTrustWarning.tsx new file mode 100644 index 0000000000000000000000000000000000000000..a0321dc47b5616c584cdd02e8661618355b3ee87 --- /dev/null +++ b/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 = {figures.warning} ; + $[1] = t1; + } else { + t1 = $[1]; + } + let t2; + if ($[2] === Symbol.for("react.memo_cache_sentinel")) { + t2 = {t1}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}` : ""}; + $[2] = t2; + } else { + t2 = $[2]; + } + return t2; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/src/commands/plugin/UnifiedInstalledCell.tsx b/src/commands/plugin/UnifiedInstalledCell.tsx new file mode 100644 index 0000000000000000000000000000000000000000..cc4cbcbd962a42177b98b90121221456ebfeea6a --- /dev/null +++ b/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 = {t2}; + $[10] = t1; + $[11] = t2; + $[12] = t3; + } else { + t3 = $[12]; + } + const t4 = isSelected ? "suggestion" : undefined; + let t5; + if ($[13] !== item.name || $[14] !== t4) { + t5 = {item.name}; + $[13] = item.name; + $[14] = t4; + $[15] = t5; + } else { + t5 = $[15]; + } + const t6 = !isSelected; + let t7; + if ($[16] === Symbol.for("react.memo_cache_sentinel")) { + t7 = Plugin; + $[16] = t7; + } else { + t7 = $[16]; + } + let t8; + if ($[17] !== t6) { + t8 = {" "}{t7}; + $[17] = t6; + $[18] = t8; + } else { + t8 = $[18]; + } + let t9; + if ($[19] !== item.marketplace) { + t9 = · {item.marketplace}; + $[19] = item.marketplace; + $[20] = t9; + } else { + t9 = $[20]; + } + const t10 = !isSelected; + let t11; + if ($[21] !== statusIcon || $[22] !== t10) { + t11 = · {statusIcon} ; + $[21] = statusIcon; + $[22] = t10; + $[23] = t11; + } else { + t11 = $[23]; + } + const t12 = !isSelected; + let t13; + if ($[24] !== statusText || $[25] !== t12) { + t13 = {statusText}; + $[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 = {t3}{t5}{t8}{t9}{t11}{t13}; + $[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 = {t3}; + $[36] = t2; + $[37] = t3; + $[38] = t4; + } else { + t4 = $[38]; + } + const t5 = isSelected ? "suggestion" : undefined; + let t6; + if ($[39] !== item.name || $[40] !== t5) { + t6 = {item.name}; + $[39] = item.name; + $[40] = t5; + $[41] = t6; + } else { + t6 = $[41]; + } + const t7 = !isSelected; + let t8; + if ($[42] === Symbol.for("react.memo_cache_sentinel")) { + t8 = Plugin; + $[42] = t8; + } else { + t8 = $[42]; + } + let t9; + if ($[43] !== t7) { + t9 = {" "}{t8}; + $[43] = t7; + $[44] = t9; + } else { + t9 = $[44]; + } + let t10; + if ($[45] !== item.marketplace) { + t10 = · {item.marketplace}; + $[45] = item.marketplace; + $[46] = t10; + } else { + t10 = $[46]; + } + const t11 = !isSelected; + let t12; + if ($[47] !== statusIcon_0 || $[48] !== t11) { + t12 = · {statusIcon_0} ; + $[47] = statusIcon_0; + $[48] = t11; + $[49] = t12; + } else { + t12 = $[49]; + } + const t13 = !isSelected; + let t14; + if ($[50] !== t13) { + t14 = removed; + $[50] = t13; + $[51] = t14; + } else { + t14 = $[51]; + } + let t15; + if ($[52] !== t10 || $[53] !== t12 || $[54] !== t14 || $[55] !== t4 || $[56] !== t6 || $[57] !== t9) { + t15 = {t4}{t6}{t9}{t10}{t12}{t14}; + $[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 = {t5}; + $[63] = t4; + $[64] = t5; + $[65] = t6; + } else { + t6 = $[65]; + } + const t7 = isSelected ? "suggestion" : undefined; + let t8; + if ($[66] !== item.name || $[67] !== t7) { + t8 = {item.name}; + $[66] = item.name; + $[67] = t7; + $[68] = t8; + } else { + t8 = $[68]; + } + const t9 = !isSelected; + let t10; + if ($[69] === Symbol.for("react.memo_cache_sentinel")) { + t10 = Plugin; + $[69] = t10; + } else { + t10 = $[69]; + } + let t11; + if ($[70] !== t9) { + t11 = {" "}{t10}; + $[70] = t9; + $[71] = t11; + } else { + t11 = $[71]; + } + let t12; + if ($[72] !== item.marketplace) { + t12 = · {item.marketplace}; + $[72] = item.marketplace; + $[73] = t12; + } else { + t12 = $[73]; + } + const t13 = !isSelected; + let t14; + if ($[74] !== statusIcon_1 || $[75] !== t13) { + t14 = · {statusIcon_1} ; + $[74] = statusIcon_1; + $[75] = t13; + $[76] = t14; + } else { + t14 = $[76]; + } + const t15 = !isSelected; + let t16; + if ($[77] !== statusText_0 || $[78] !== t15) { + t16 = {statusText_0}; + $[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 = {t6}{t8}{t11}{t12}{t14}{t16}; + $[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 = {t2}; + $[97] = t1; + $[98] = t2; + $[99] = t3; + } else { + t3 = $[99]; + } + const t4 = !isSelected; + let t5; + if ($[100] !== t4) { + t5 = └ ; + $[100] = t4; + $[101] = t5; + } else { + t5 = $[101]; + } + const t6 = isSelected ? "suggestion" : undefined; + let t7; + if ($[102] !== item.name || $[103] !== t6) { + t7 = {item.name}; + $[102] = item.name; + $[103] = t6; + $[104] = t7; + } else { + t7 = $[104]; + } + const t8 = !isSelected; + let t9; + if ($[105] === Symbol.for("react.memo_cache_sentinel")) { + t9 = MCP; + $[105] = t9; + } else { + t9 = $[105]; + } + let t10; + if ($[106] !== t8) { + t10 = {" "}{t9}; + $[106] = t8; + $[107] = t10; + } else { + t10 = $[107]; + } + const t11 = !isSelected; + let t12; + if ($[108] !== statusIcon_2 || $[109] !== t11) { + t12 = · {statusIcon_2} ; + $[108] = statusIcon_2; + $[109] = t11; + $[110] = t12; + } else { + t12 = $[110]; + } + const t13 = !isSelected; + let t14; + if ($[111] !== statusText_1 || $[112] !== t13) { + t14 = {statusText_1}; + $[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 = {t3}{t5}{t7}{t10}{t12}{t14}; + $[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 = {t2}; + $[121] = t1; + $[122] = t2; + $[123] = t3; + } else { + t3 = $[123]; + } + const t4 = isSelected ? "suggestion" : undefined; + let t5; + if ($[124] !== item.name || $[125] !== t4) { + t5 = {item.name}; + $[124] = item.name; + $[125] = t4; + $[126] = t5; + } else { + t5 = $[126]; + } + const t6 = !isSelected; + let t7; + if ($[127] === Symbol.for("react.memo_cache_sentinel")) { + t7 = MCP; + $[127] = t7; + } else { + t7 = $[127]; + } + let t8; + if ($[128] !== t6) { + t8 = {" "}{t7}; + $[128] = t6; + $[129] = t8; + } else { + t8 = $[129]; + } + const t9 = !isSelected; + let t10; + if ($[130] !== statusIcon_2 || $[131] !== t9) { + t10 = · {statusIcon_2} ; + $[130] = statusIcon_2; + $[131] = t9; + $[132] = t10; + } else { + t10 = $[132]; + } + const t11 = !isSelected; + let t12; + if ($[133] !== statusText_1 || $[134] !== t11) { + t12 = {statusText_1}; + $[133] = statusText_1; + $[134] = t11; + $[135] = t12; + } else { + t12 = $[135]; + } + let t13; + if ($[136] !== t10 || $[137] !== t12 || $[138] !== t3 || $[139] !== t5 || $[140] !== t8) { + t13 = {t3}{t5}{t8}{t10}{t12}; + $[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":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/ValidatePlugin.tsx b/src/commands/plugin/ValidatePlugin.tsx new file mode 100644 index 0000000000000000000000000000000000000000..084f5dc675951764bb00ef3749d869e825049cc1 --- /dev/null +++ b/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 \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 "); + 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 = Running validation...; + $[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":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/index.tsx b/src/commands/plugin/index.tsx new file mode 100644 index 0000000000000000000000000000000000000000..02dad87d730024db53c76032d872fd6b62e22f94 --- /dev/null +++ b/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== \ No newline at end of file diff --git a/src/commands/plugin/parseArgs.ts b/src/commands/plugin/parseArgs.ts new file mode 100644 index 0000000000000000000000000000000000000000..a2c36e4b95da8a11814c7804b45827a202e57561 --- /dev/null +++ b/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' } + } +} diff --git a/src/commands/plugin/plugin.tsx b/src/commands/plugin/plugin.tsx new file mode 100644 index 0000000000000000000000000000000000000000..f079f49a0f2187e6fcc41ac9cd46eefe94356e7c --- /dev/null +++ b/src/commands/plugin/plugin.tsx @@ -0,0 +1,7 @@ +import * as React from 'react'; +import type { LocalJSXCommandOnDone } from '../../types/command.js'; +import { PluginSettings } from './PluginSettings.js'; +export async function call(onDone: LocalJSXCommandOnDone, _context: unknown, args?: string): Promise { + return ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkxvY2FsSlNYQ29tbWFuZE9uRG9uZSIsIlBsdWdpblNldHRpbmdzIiwiY2FsbCIsIm9uRG9uZSIsIl9jb250ZXh0IiwiYXJncyIsIlByb21pc2UiLCJSZWFjdE5vZGUiXSwic291cmNlcyI6WyJwbHVnaW4udHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHR5cGUgeyBMb2NhbEpTWENvbW1hbmRPbkRvbmUgfSBmcm9tICcuLi8uLi90eXBlcy9jb21tYW5kLmpzJ1xuaW1wb3J0IHsgUGx1Z2luU2V0dGluZ3MgfSBmcm9tICcuL1BsdWdpblNldHRpbmdzLmpzJ1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gY2FsbChcbiAgb25Eb25lOiBMb2NhbEpTWENvbW1hbmRPbkRvbmUsXG4gIF9jb250ZXh0OiB1bmtub3duLFxuICBhcmdzPzogc3RyaW5nLFxuKTogUHJvbWlzZTxSZWFjdC5SZWFjdE5vZGU+IHtcbiAgcmV0dXJuIDxQbHVnaW5TZXR0aW5ncyBvbkNvbXBsZXRlPXtvbkRvbmV9IGFyZ3M9e2FyZ3N9IC8+XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBS0EsS0FBSyxNQUFNLE9BQU87QUFDOUIsY0FBY0MscUJBQXFCLFFBQVEsd0JBQXdCO0FBQ25FLFNBQVNDLGNBQWMsUUFBUSxxQkFBcUI7QUFFcEQsT0FBTyxlQUFlQyxJQUFJQSxDQUN4QkMsTUFBTSxFQUFFSCxxQkFBcUIsRUFDN0JJLFFBQVEsRUFBRSxPQUFPLEVBQ2pCQyxJQUFhLENBQVIsRUFBRSxNQUFNLENBQ2QsRUFBRUMsT0FBTyxDQUFDUCxLQUFLLENBQUNRLFNBQVMsQ0FBQyxDQUFDO0VBQzFCLE9BQU8sQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLENBQUNKLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDRSxJQUFJLENBQUMsR0FBRztBQUMzRCIsImlnbm9yZUxpc3QiOltdfQ== \ No newline at end of file diff --git a/src/commands/plugin/pluginDetailsHelpers.tsx b/src/commands/plugin/pluginDetailsHelpers.tsx new file mode 100644 index 0000000000000000000000000000000000000000..fbd365a9c77da136c51f886b8a332037dac35144 --- /dev/null +++ b/src/commands/plugin/pluginDetailsHelpers.tsx @@ -0,0 +1,117 @@ +import { c as _c } from "react/compiler-runtime"; +/** + * Shared helper functions and types for plugin details views + * + * Used by both DiscoverPlugins and BrowseMarketplace components. + */ + +import * as React from 'react'; +import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'; +import { Byline } from '../../components/design-system/Byline.js'; +import { Box, Text } from '../../ink.js'; +import type { PluginMarketplaceEntry } from '../../utils/plugins/schemas.js'; + +/** + * Represents a plugin available for installation from a marketplace + */ +export type InstallablePlugin = { + entry: PluginMarketplaceEntry; + marketplaceName: string; + pluginId: string; + isInstalled: boolean; +}; + +/** + * Menu option for plugin details view + */ +export type PluginDetailsMenuOption = { + label: string; + action: string; +}; + +/** + * Extract GitHub repo info from a plugin's source + */ +export function extractGitHubRepo(plugin: InstallablePlugin): string | null { + const isGitHub = plugin.entry.source && typeof plugin.entry.source === 'object' && 'source' in plugin.entry.source && plugin.entry.source.source === 'github'; + if (isGitHub && typeof plugin.entry.source === 'object' && 'repo' in plugin.entry.source) { + return plugin.entry.source.repo; + } + return null; +} + +/** + * Build menu options for plugin details view with scoped installation options + */ +export function buildPluginDetailsMenuOptions(hasHomepage: string | undefined, githubRepo: string | null): PluginDetailsMenuOption[] { + const options: PluginDetailsMenuOption[] = [{ + label: 'Install for you (user scope)', + action: 'install-user' + }, { + label: 'Install for all collaborators on this repository (project scope)', + action: 'install-project' + }, { + label: 'Install for you, in this repo only (local scope)', + action: 'install-local' + }]; + if (hasHomepage) { + options.push({ + label: 'Open homepage', + action: 'homepage' + }); + } + if (githubRepo) { + options.push({ + label: 'View on GitHub', + action: 'github' + }); + } + options.push({ + label: 'Back to plugin list', + action: 'back' + }); + return options; +} + +/** + * Key hint component for plugin selection screens + */ +export function PluginSelectionKeyHint(t0) { + const $ = _c(7); + const { + hasSelection + } = t0; + let t1; + if ($[0] !== hasSelection) { + t1 = hasSelection && ; + $[0] = hasSelection; + $[1] = t1; + } else { + t1 = $[1]; + } + let t2; + let t3; + let t4; + if ($[2] === Symbol.for("react.memo_cache_sentinel")) { + t2 = ; + t3 = ; + t4 = ; + $[2] = t2; + $[3] = t3; + $[4] = t4; + } else { + t2 = $[2]; + t3 = $[3]; + t4 = $[4]; + } + let t5; + if ($[5] !== t1) { + t5 = {t1}{t2}{t3}{t4}; + $[5] = t1; + $[6] = t5; + } else { + t5 = $[6]; + } + return t5; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","ConfigurableShortcutHint","Byline","Box","Text","PluginMarketplaceEntry","InstallablePlugin","entry","marketplaceName","pluginId","isInstalled","PluginDetailsMenuOption","label","action","extractGitHubRepo","plugin","isGitHub","source","repo","buildPluginDetailsMenuOptions","hasHomepage","githubRepo","options","push","PluginSelectionKeyHint","t0","$","_c","hasSelection","t1","t2","t3","t4","Symbol","for","t5"],"sources":["pluginDetailsHelpers.tsx"],"sourcesContent":["/**\n * Shared helper functions and types for plugin details views\n *\n * Used by both DiscoverPlugins and BrowseMarketplace components.\n */\n\nimport * as React from 'react'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { Box, Text } from '../../ink.js'\nimport type { PluginMarketplaceEntry } from '../../utils/plugins/schemas.js'\n\n/**\n * Represents a plugin available for installation from a marketplace\n */\nexport type InstallablePlugin = {\n  entry: PluginMarketplaceEntry\n  marketplaceName: string\n  pluginId: string\n  isInstalled: boolean\n}\n\n/**\n * Menu option for plugin details view\n */\nexport type PluginDetailsMenuOption = {\n  label: string\n  action: string\n}\n\n/**\n * Extract GitHub repo info from a plugin's source\n */\nexport function extractGitHubRepo(plugin: InstallablePlugin): string | null {\n  const isGitHub =\n    plugin.entry.source &&\n    typeof plugin.entry.source === 'object' &&\n    'source' in plugin.entry.source &&\n    plugin.entry.source.source === 'github'\n\n  if (\n    isGitHub &&\n    typeof plugin.entry.source === 'object' &&\n    'repo' in plugin.entry.source\n  ) {\n    return plugin.entry.source.repo\n  }\n\n  return null\n}\n\n/**\n * Build menu options for plugin details view with scoped installation options\n */\nexport function buildPluginDetailsMenuOptions(\n  hasHomepage: string | undefined,\n  githubRepo: string | null,\n): PluginDetailsMenuOption[] {\n  const options: PluginDetailsMenuOption[] = [\n    { label: 'Install for you (user scope)', action: 'install-user' },\n    {\n      label: 'Install for all collaborators on this repository (project scope)',\n      action: 'install-project',\n    },\n    {\n      label: 'Install for you, in this repo only (local scope)',\n      action: 'install-local',\n    },\n  ]\n  if (hasHomepage) {\n    options.push({ label: 'Open homepage', action: 'homepage' })\n  }\n  if (githubRepo) {\n    options.push({ label: 'View on GitHub', action: 'github' })\n  }\n  options.push({ label: 'Back to plugin list', action: 'back' })\n  return options\n}\n\n/**\n * Key hint component for plugin selection screens\n */\nexport function PluginSelectionKeyHint({\n  hasSelection,\n}: {\n  hasSelection: boolean\n}): React.ReactNode {\n  return (\n    <Box marginTop={1}>\n      <Text dimColor italic>\n        <Byline>\n          {hasSelection && (\n            <ConfigurableShortcutHint\n              action=\"plugin:install\"\n              context=\"Plugin\"\n              fallback=\"i\"\n              description=\"install\"\n              bold\n            />\n          )}\n          <ConfigurableShortcutHint\n            action=\"plugin:toggle\"\n            context=\"Plugin\"\n            fallback=\"Space\"\n            description=\"toggle\"\n          />\n          <ConfigurableShortcutHint\n            action=\"select:accept\"\n            context=\"Select\"\n            fallback=\"Enter\"\n            description=\"details\"\n          />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"back\"\n          />\n        </Byline>\n      </Text>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/plugin/usePagination.ts b/src/commands/plugin/usePagination.ts new file mode 100644 index 0000000000000000000000000000000000000000..8c1f4afaacbcc5b8ba42699c568e42ec9c303958 --- /dev/null +++ b/src/commands/plugin/usePagination.ts @@ -0,0 +1,171 @@ +import { useCallback, useMemo, useRef } from 'react' + +const DEFAULT_MAX_VISIBLE = 5 + +type UsePaginationOptions = { + totalItems: number + maxVisible?: number + selectedIndex?: number +} + +type UsePaginationResult = { + // For backwards compatibility with page-based terminology + currentPage: number + totalPages: number + startIndex: number + endIndex: number + needsPagination: boolean + pageSize: number + // Get visible slice of items + getVisibleItems: (items: T[]) => T[] + // Convert visible index to actual index + toActualIndex: (visibleIndex: number) => number + // Check if actual index is visible + isOnCurrentPage: (actualIndex: number) => boolean + // Navigation (kept for API compatibility) + goToPage: (page: number) => void + nextPage: () => void + prevPage: () => void + // Handle selection - just updates the index, scrolling is automatic + handleSelectionChange: ( + newIndex: number, + setSelectedIndex: (index: number) => void, + ) => void + // Page navigation - returns false for continuous scrolling (not needed) + handlePageNavigation: ( + direction: 'left' | 'right', + setSelectedIndex: (index: number) => void, + ) => boolean + // Scroll position info for UI display + scrollPosition: { + current: number + total: number + canScrollUp: boolean + canScrollDown: boolean + } +} + +export function usePagination({ + totalItems, + maxVisible = DEFAULT_MAX_VISIBLE, + selectedIndex = 0, +}: UsePaginationOptions): UsePaginationResult { + const needsPagination = totalItems > maxVisible + + // Use a ref to track the previous scroll offset for smooth scrolling + const scrollOffsetRef = useRef(0) + + // Compute the scroll offset based on selectedIndex + // This ensures the selected item is always visible + const scrollOffset = useMemo(() => { + if (!needsPagination) return 0 + + const prevOffset = scrollOffsetRef.current + + // If selected item is above the visible window, scroll up + if (selectedIndex < prevOffset) { + scrollOffsetRef.current = selectedIndex + return selectedIndex + } + + // If selected item is below the visible window, scroll down + if (selectedIndex >= prevOffset + maxVisible) { + const newOffset = selectedIndex - maxVisible + 1 + scrollOffsetRef.current = newOffset + return newOffset + } + + // Selected item is within visible window, keep current offset + // But ensure offset is still valid + const maxOffset = Math.max(0, totalItems - maxVisible) + const clampedOffset = Math.min(prevOffset, maxOffset) + scrollOffsetRef.current = clampedOffset + return clampedOffset + }, [selectedIndex, maxVisible, needsPagination, totalItems]) + + const startIndex = scrollOffset + const endIndex = Math.min(scrollOffset + maxVisible, totalItems) + + const getVisibleItems = useCallback( + (items: T[]): T[] => { + if (!needsPagination) return items + return items.slice(startIndex, endIndex) + }, + [needsPagination, startIndex, endIndex], + ) + + const toActualIndex = useCallback( + (visibleIndex: number): number => { + return startIndex + visibleIndex + }, + [startIndex], + ) + + const isOnCurrentPage = useCallback( + (actualIndex: number): boolean => { + return actualIndex >= startIndex && actualIndex < endIndex + }, + [startIndex, endIndex], + ) + + // These are mostly no-ops for continuous scrolling but kept for API compatibility + const goToPage = useCallback((_page: number) => { + // No-op - scrolling is controlled by selectedIndex + }, []) + + const nextPage = useCallback(() => { + // No-op - scrolling is controlled by selectedIndex + }, []) + + const prevPage = useCallback(() => { + // No-op - scrolling is controlled by selectedIndex + }, []) + + // Simple selection handler - just updates the index + // Scrolling happens automatically via the useMemo above + const handleSelectionChange = useCallback( + (newIndex: number, setSelectedIndex: (index: number) => void) => { + const clampedIndex = Math.max(0, Math.min(newIndex, totalItems - 1)) + setSelectedIndex(clampedIndex) + }, + [totalItems], + ) + + // Page navigation - disabled for continuous scrolling + const handlePageNavigation = useCallback( + ( + _direction: 'left' | 'right', + _setSelectedIndex: (index: number) => void, + ): boolean => { + return false + }, + [], + ) + + // Calculate page-like values for backwards compatibility + const totalPages = Math.max(1, Math.ceil(totalItems / maxVisible)) + const currentPage = Math.floor(scrollOffset / maxVisible) + + return { + currentPage, + totalPages, + startIndex, + endIndex, + needsPagination, + pageSize: maxVisible, + getVisibleItems, + toActualIndex, + isOnCurrentPage, + goToPage, + nextPage, + prevPage, + handleSelectionChange, + handlePageNavigation, + scrollPosition: { + current: selectedIndex + 1, + total: totalItems, + canScrollUp: scrollOffset > 0, + canScrollDown: scrollOffset + maxVisible < totalItems, + }, + } +} diff --git a/src/commands/pr_comments/index.ts b/src/commands/pr_comments/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..df8969fe324085a2388d80ce3ac611028d35dd77 --- /dev/null +++ b/src/commands/pr_comments/index.ts @@ -0,0 +1,50 @@ +import { createMovedToPluginCommand } from '../createMovedToPluginCommand.js' + +export default createMovedToPluginCommand({ + name: 'pr-comments', + description: 'Get comments from a GitHub pull request', + progressMessage: 'fetching PR comments', + pluginName: 'pr-comments', + pluginCommand: 'pr-comments', + async getPromptWhileMarketplaceIsPrivate(args) { + return [ + { + type: 'text', + text: `You are an AI assistant integrated into a git-based version control system. Your task is to fetch and display comments from a GitHub pull request. + +Follow these steps: + +1. Use \`gh pr view --json number,headRepository\` to get the PR number and repository info +2. Use \`gh api /repos/{owner}/{repo}/issues/{number}/comments\` to get PR-level comments +3. Use \`gh api /repos/{owner}/{repo}/pulls/{number}/comments\` to get review comments. Pay particular attention to the following fields: \`body\`, \`diff_hunk\`, \`path\`, \`line\`, etc. If the comment references some code, consider fetching it using eg \`gh api /repos/{owner}/{repo}/contents/{path}?ref={branch} | jq .content -r | base64 -d\` +4. Parse and format all comments in a readable way +5. Return ONLY the formatted comments, with no additional text + +Format the comments as: + +## Comments + +[For each comment thread:] +- @author file.ts#line: + \`\`\`diff + [diff_hunk from the API response] + \`\`\` + > quoted comment text + + [any replies indented] + +If there are no comments, return "No comments found." + +Remember: +1. Only show the actual comments, no explanatory text +2. Include both PR-level and code review comments +3. Preserve the threading/nesting of comment replies +4. Show the file and line number context for code review comments +5. Use jq to parse the JSON responses from the GitHub API + +${args ? 'Additional user input: ' + args : ''} +`, + }, + ] + }, +}) diff --git a/src/commands/privacy-settings/privacy-settings.tsx b/src/commands/privacy-settings/privacy-settings.tsx new file mode 100644 index 0000000000000000000000000000000000000000..4e4acf67c2cda14bd9c5825f15891a4cb9f59ed7 --- /dev/null +++ b/src/commands/privacy-settings/privacy-settings.tsx @@ -0,0 +1,58 @@ +import * as React from 'react'; +import { type GroveDecision, GroveDialog, PrivacySettingsDialog } from '../../components/grove/Grove.js'; +import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js'; +import { getGroveNoticeConfig, getGroveSettings, isQualifiedForGrove } from '../../services/api/grove.js'; +import type { LocalJSXCommandOnDone } from '../../types/command.js'; +const FALLBACK_MESSAGE = 'Review and manage your privacy settings at https://claude.ai/settings/data-privacy-controls'; +export async function call(onDone: LocalJSXCommandOnDone): Promise { + const qualified = await isQualifiedForGrove(); + if (!qualified) { + onDone(FALLBACK_MESSAGE); + return null; + } + const [settingsResult, configResult] = await Promise.all([getGroveSettings(), getGroveNoticeConfig()]); + // Hide dialog on API failure (after retry) + if (!settingsResult.success) { + onDone(FALLBACK_MESSAGE); + return null; + } + const settings = settingsResult.data; + const config = configResult.success ? configResult.data : null; + async function onDoneWithDecision(decision: GroveDecision) { + if (decision === 'escape' || decision === 'defer') { + onDone('Privacy settings dialog dismissed', { + display: 'system' + }); + return; + } + await onDoneWithSettingsCheck(); + } + async function onDoneWithSettingsCheck() { + const updatedSettingsResult = await getGroveSettings(); + if (!updatedSettingsResult.success) { + onDone('Unable to retrieve updated privacy settings', { + display: 'system' + }); + return; + } + const updatedSettings = updatedSettingsResult.data; + const groveStatus = updatedSettings.grove_enabled ? 'true' : 'false'; + onDone(`"Help improve Claude" set to ${groveStatus}.`); + if (settings.grove_enabled !== null && settings.grove_enabled !== updatedSettings.grove_enabled) { + logEvent('tengu_grove_policy_toggled', { + state: updatedSettings.grove_enabled as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + location: 'settings' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS + }); + } + } + + // Show privacy settings directly if the user has already accepted the + // terms. + if (settings.grove_enabled !== null) { + return ; + } + + // Show the GroveDialog for users who haven't accepted terms yet + return ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/src/commands/rate-limit-options/index.ts b/src/commands/rate-limit-options/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..671b440a14c1012fd368806cd1dc90093494d4b4 --- /dev/null +++ b/src/commands/rate-limit-options/index.ts @@ -0,0 +1,19 @@ +import type { Command } from '../../commands.js' +import { isClaudeAISubscriber } from '../../utils/auth.js' + +const rateLimitOptions = { + type: 'local-jsx', + name: 'rate-limit-options', + description: 'Show options when rate limit is reached', + isEnabled: () => { + if (!isClaudeAISubscriber()) { + return false + } + + return true + }, + isHidden: true, // Hidden from help - only used internally + load: () => import('./rate-limit-options.js'), +} satisfies Command + +export default rateLimitOptions diff --git a/src/commands/rate-limit-options/rate-limit-options.tsx b/src/commands/rate-limit-options/rate-limit-options.tsx new file mode 100644 index 0000000000000000000000000000000000000000..296ca4b8ef077d019bbf814b4c56b04bcabb0537 --- /dev/null +++ b/src/commands/rate-limit-options/rate-limit-options.tsx @@ -0,0 +1,210 @@ +import { c as _c } from "react/compiler-runtime"; +import React, { useMemo, useState } from 'react'; +import type { CommandResultDisplay, LocalJSXCommandContext } from '../../commands.js'; +import { type OptionWithDescription, Select } from '../../components/CustomSelect/select.js'; +import { Dialog } from '../../components/design-system/Dialog.js'; +import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'; +import { logEvent } from '../../services/analytics/index.js'; +import { useClaudeAiLimits } from '../../services/claudeAiLimitsHook.js'; +import type { ToolUseContext } from '../../Tool.js'; +import type { LocalJSXCommandOnDone } from '../../types/command.js'; +import { getOauthAccountInfo, getRateLimitTier, getSubscriptionType } from '../../utils/auth.js'; +import { hasClaudeAiBillingAccess } from '../../utils/billing.js'; +import { call as extraUsageCall } from '../extra-usage/extra-usage.js'; +import { extraUsage } from '../extra-usage/index.js'; +import upgrade from '../upgrade/index.js'; +import { call as upgradeCall } from '../upgrade/upgrade.js'; +type RateLimitOptionsMenuOptionType = 'upgrade' | 'extra-usage' | 'cancel'; +type RateLimitOptionsMenuProps = { + onDone: (result?: string, options?: { + display?: CommandResultDisplay | undefined; + } | undefined) => void; + context: ToolUseContext & LocalJSXCommandContext; +}; +function RateLimitOptionsMenu(t0) { + const $ = _c(25); + const { + onDone, + context + } = t0; + const [subCommandJSX, setSubCommandJSX] = useState(null); + const claudeAiLimits = useClaudeAiLimits(); + let t1; + if ($[0] === Symbol.for("react.memo_cache_sentinel")) { + t1 = getSubscriptionType(); + $[0] = t1; + } else { + t1 = $[0]; + } + const subscriptionType = t1; + let t2; + if ($[1] === Symbol.for("react.memo_cache_sentinel")) { + t2 = getRateLimitTier(); + $[1] = t2; + } else { + t2 = $[1]; + } + const rateLimitTier = t2; + const hasExtraUsageEnabled = getOauthAccountInfo()?.hasExtraUsageEnabled === true; + const isMax = subscriptionType === "max"; + const isMax20x = isMax && rateLimitTier === "default_claude_max_20x"; + const isTeamOrEnterprise = subscriptionType === "team" || subscriptionType === "enterprise"; + const buyFirst = getFeatureValue_CACHED_MAY_BE_STALE("tengu_jade_anvil_4", false); + let t3; + bb0: { + let actionOptions; + if ($[2] !== claudeAiLimits.overageDisabledReason || $[3] !== claudeAiLimits.overageStatus) { + actionOptions = []; + if (extraUsage.isEnabled()) { + const hasBillingAccess = hasClaudeAiBillingAccess(); + const needsToRequestFromAdmin = isTeamOrEnterprise && !hasBillingAccess; + const isOrgSpendCapDepleted = claudeAiLimits.overageDisabledReason === "out_of_credits" || claudeAiLimits.overageDisabledReason === "org_level_disabled_until" || claudeAiLimits.overageDisabledReason === "org_service_zero_credit_limit"; + if (needsToRequestFromAdmin && isOrgSpendCapDepleted) {} else { + const isOverageState = claudeAiLimits.overageStatus === "rejected" || claudeAiLimits.overageStatus === "allowed_warning"; + let label; + if (needsToRequestFromAdmin) { + label = isOverageState ? "Request more" : "Request extra usage"; + } else { + label = hasExtraUsageEnabled ? "Add funds to continue with extra usage" : "Switch to extra usage"; + } + let t4; + if ($[5] !== label) { + t4 = { + label, + value: "extra-usage" + }; + $[5] = label; + $[6] = t4; + } else { + t4 = $[6]; + } + actionOptions.push(t4); + } + } + if (!isMax20x && !isTeamOrEnterprise && upgrade.isEnabled()) { + let t4; + if ($[7] === Symbol.for("react.memo_cache_sentinel")) { + t4 = { + label: "Upgrade your plan", + value: "upgrade" + }; + $[7] = t4; + } else { + t4 = $[7]; + } + actionOptions.push(t4); + } + $[2] = claudeAiLimits.overageDisabledReason; + $[3] = claudeAiLimits.overageStatus; + $[4] = actionOptions; + } else { + actionOptions = $[4]; + } + let t4; + if ($[8] === Symbol.for("react.memo_cache_sentinel")) { + t4 = { + label: "Stop and wait for limit to reset", + value: "cancel" + }; + $[8] = t4; + } else { + t4 = $[8]; + } + const cancelOption = t4; + if (buyFirst) { + let t5; + if ($[9] !== actionOptions) { + t5 = [...actionOptions, cancelOption]; + $[9] = actionOptions; + $[10] = t5; + } else { + t5 = $[10]; + } + t3 = t5; + break bb0; + } + let t5; + if ($[11] !== actionOptions) { + t5 = [cancelOption, ...actionOptions]; + $[11] = actionOptions; + $[12] = t5; + } else { + t5 = $[12]; + } + t3 = t5; + } + const options = t3; + let t4; + if ($[13] !== onDone) { + t4 = function handleCancel() { + logEvent("tengu_rate_limit_options_menu_cancel", {}); + onDone(undefined, { + display: "skip" + }); + }; + $[13] = onDone; + $[14] = t4; + } else { + t4 = $[14]; + } + const handleCancel = t4; + let t5; + if ($[15] !== context || $[16] !== handleCancel || $[17] !== onDone) { + t5 = function handleSelect(value) { + if (value === "upgrade") { + logEvent("tengu_rate_limit_options_menu_select_upgrade", {}); + upgradeCall(onDone, context).then(jsx => { + if (jsx) { + setSubCommandJSX(jsx); + } + }); + } else { + if (value === "extra-usage") { + logEvent("tengu_rate_limit_options_menu_select_extra_usage", {}); + extraUsageCall(onDone, context).then(jsx_0 => { + if (jsx_0) { + setSubCommandJSX(jsx_0); + } + }); + } else { + if (value === "cancel") { + handleCancel(); + } + } + } + }; + $[15] = context; + $[16] = handleCancel; + $[17] = onDone; + $[18] = t5; + } else { + t5 = $[18]; + } + const handleSelect = t5; + if (subCommandJSX) { + return subCommandJSX; + } + let t6; + if ($[19] !== handleSelect || $[20] !== options) { + t6 = { + if (value === 'send') { + void handleConfirm(token); + } else { + handleCancel(); + } + }} onCancel={handleCancel} /> + ; +} +export async function call(onDone: LocalJSXCommandOnDone): Promise { + return ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["execa","React","useEffect","useState","Select","Dialog","LoadingState","Box","Text","logEvent","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","SafeString","LocalJSXCommandOnDone","openBrowser","getGhAuthStatus","createDefaultEnvironment","getCodeWebUrl","ImportTokenError","importGithubToken","isSignedIn","RedactedGithubToken","CheckResult","status","token","checkLoginState","Promise","ghStatus","stdout","stderr","timeout","reject","trimmed","trim","errorMessage","err","codeUrl","kind","Step","name","Web","onDone","step","setStep","then","result","url","handleCancel","handleConfirm","ok","error_kind","error","github_username","label","value","call","ReactNode"],"sources":["remote-setup.tsx"],"sourcesContent":["import { execa } from 'execa'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { Select } from '../../components/CustomSelect/index.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { LoadingState } from '../../components/design-system/LoadingState.js'\nimport { Box, Text } from '../../ink.js'\nimport {\n  logEvent,\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS as SafeString,\n} from '../../services/analytics/index.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport { getGhAuthStatus } from '../../utils/github/ghAuthStatus.js'\nimport {\n  createDefaultEnvironment,\n  getCodeWebUrl,\n  type ImportTokenError,\n  importGithubToken,\n  isSignedIn,\n  RedactedGithubToken,\n} from './api.js'\n\ntype CheckResult =\n  | { status: 'not_signed_in' }\n  | { status: 'has_gh_token'; token: RedactedGithubToken }\n  | { status: 'gh_not_installed' }\n  | { status: 'gh_not_authenticated' }\n\nasync function checkLoginState(): Promise<CheckResult> {\n  if (!(await isSignedIn())) {\n    return { status: 'not_signed_in' }\n  }\n\n  const ghStatus = await getGhAuthStatus()\n  if (ghStatus === 'not_installed') {\n    return { status: 'gh_not_installed' }\n  }\n  if (ghStatus === 'not_authenticated') {\n    return { status: 'gh_not_authenticated' }\n  }\n\n  // ghStatus === 'authenticated'. getGhAuthStatus spawns with stdout:'ignore'\n  // (telemetry-safe); spawn once more with stdout:'pipe' to read the token.\n  const { stdout } = await execa('gh', ['auth', 'token'], {\n    stdout: 'pipe',\n    stderr: 'ignore',\n    timeout: 5000,\n    reject: false,\n  })\n  const trimmed = stdout.trim()\n  if (!trimmed) {\n    return { status: 'gh_not_authenticated' }\n  }\n  return { status: 'has_gh_token', token: new RedactedGithubToken(trimmed) }\n}\n\nfunction errorMessage(err: ImportTokenError, codeUrl: string): string {\n  switch (err.kind) {\n    case 'not_signed_in':\n      return `Login failed. Please visit ${codeUrl} and login using the GitHub App`\n    case 'invalid_token':\n      return 'GitHub rejected that token. Run `gh auth login` and try again.'\n    case 'server':\n      return `Server error (${err.status}). Try again in a moment.`\n    case 'network':\n      return \"Couldn't reach the server. Check your connection.\"\n  }\n}\n\ntype Step =\n  | { name: 'checking' }\n  | { name: 'confirm'; token: RedactedGithubToken }\n  | { name: 'uploading' }\n\nfunction Web({ onDone }: { onDone: LocalJSXCommandOnDone }) {\n  const [step, setStep] = useState<Step>({ name: 'checking' })\n\n  useEffect(() => {\n    logEvent('tengu_remote_setup_started', {})\n    void checkLoginState().then(async result => {\n      switch (result.status) {\n        case 'not_signed_in':\n          logEvent('tengu_remote_setup_result', {\n            result: 'not_signed_in' as SafeString,\n          })\n          onDone('Not signed in to Claude. Run /login first.')\n          return\n        case 'gh_not_installed':\n        case 'gh_not_authenticated': {\n          const url = `${getCodeWebUrl()}/onboarding?step=alt-auth`\n          await openBrowser(url)\n          logEvent('tengu_remote_setup_result', {\n            result: result.status as SafeString,\n          })\n          onDone(\n            result.status === 'gh_not_installed'\n              ? `GitHub CLI not found. Install it via https://cli.github.com/, then run \\`gh auth login\\`, or connect GitHub on the web: ${url}`\n              : `GitHub CLI not authenticated. Run \\`gh auth login\\` and try again, or connect GitHub on the web: ${url}`,\n          )\n          return\n        }\n        case 'has_gh_token':\n          setStep({ name: 'confirm', token: result.token })\n      }\n    })\n    // onDone is stable across renders; intentionally not in deps.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  const handleCancel = () => {\n    logEvent('tengu_remote_setup_result', {\n      result: 'cancelled' as SafeString,\n    })\n    onDone()\n  }\n\n  const handleConfirm = async (token: RedactedGithubToken) => {\n    setStep({ name: 'uploading' })\n\n    const result = await importGithubToken(token)\n    if (!result.ok) {\n      logEvent('tengu_remote_setup_result', {\n        result: 'import_failed' as SafeString,\n        error_kind: result.error.kind as SafeString,\n      })\n      onDone(errorMessage(result.error, getCodeWebUrl()))\n      return\n    }\n\n    // Token import succeeded. Environment creation is best-effort — if it\n    // fails, the web state machine routes to env-setup on landing, which is\n    // one extra click but still better than the OAuth dance.\n    await createDefaultEnvironment()\n\n    const url = getCodeWebUrl()\n    await openBrowser(url)\n\n    logEvent('tengu_remote_setup_result', {\n      result: 'success' as SafeString,\n    })\n    onDone(`Connected as ${result.result.github_username}. Opened ${url}`)\n  }\n\n  if (step.name === 'checking') {\n    return <LoadingState message=\"Checking login status…\" />\n  }\n\n  if (step.name === 'uploading') {\n    return <LoadingState message=\"Connecting GitHub to Claude…\" />\n  }\n\n  const token = step.token\n  return (\n    <Dialog\n      title=\"Connect Claude on the web to GitHub?\"\n      onCancel={handleCancel}\n      hideInputGuide\n    >\n      <Box flexDirection=\"column\">\n        <Text>\n          Claude on the web requires connecting to your GitHub account to clone\n          and push code on your behalf.\n        </Text>\n        <Text dimColor>\n          Your local credentials are used to authenticate with GitHub\n        </Text>\n      </Box>\n      <Select\n        options={[\n          { label: 'Continue', value: 'send' },\n          { label: 'Cancel', value: 'cancel' },\n        ]}\n        onChange={value => {\n          if (value === 'send') {\n            void handleConfirm(token)\n          } else {\n            handleCancel()\n          }\n        }}\n        onCancel={handleCancel}\n      />\n    </Dialog>\n  )\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n): Promise<React.ReactNode> {\n  return <Web onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/rename/generateSessionName.ts b/src/commands/rename/generateSessionName.ts new file mode 100644 index 0000000000000000000000000000000000000000..2ebd78610f7a44273a1861ed2589450895166eef --- /dev/null +++ b/src/commands/rename/generateSessionName.ts @@ -0,0 +1,67 @@ +import { queryHaiku } from '../../services/api/claude.js' +import type { Message } from '../../types/message.js' +import { logForDebugging } from '../../utils/debug.js' +import { errorMessage } from '../../utils/errors.js' +import { safeParseJSON } from '../../utils/json.js' +import { extractTextContent } from '../../utils/messages.js' +import { extractConversationText } from '../../utils/sessionTitle.js' +import { asSystemPrompt } from '../../utils/systemPromptType.js' + +export async function generateSessionName( + messages: Message[], + signal: AbortSignal, +): Promise { + const conversationText = extractConversationText(messages) + if (!conversationText) { + return null + } + + try { + const result = await queryHaiku({ + systemPrompt: asSystemPrompt([ + 'Generate a short kebab-case name (2-4 words) that captures the main topic of this conversation. Use lowercase words separated by hyphens. Examples: "fix-login-bug", "add-auth-feature", "refactor-api-client", "debug-test-failures". Return JSON with a "name" field.', + ]), + userPrompt: conversationText, + outputFormat: { + type: 'json_schema', + schema: { + type: 'object', + properties: { + name: { type: 'string' }, + }, + required: ['name'], + additionalProperties: false, + }, + }, + signal, + options: { + querySource: 'rename_generate_name', + agents: [], + isNonInteractiveSession: false, + hasAppendSystemPrompt: false, + mcpTools: [], + }, + }) + + const content = extractTextContent(result.message.content) + + const response = safeParseJSON(content) + if ( + response && + typeof response === 'object' && + 'name' in response && + typeof (response as { name: unknown }).name === 'string' + ) { + return (response as { name: string }).name + } + return null + } catch (error) { + // Haiku timeout/rate-limit/network are expected operational failures — + // logForDebugging, not logError. Called automatically on every 3rd bridge + // message (initReplBridge.ts), so errors here would flood the error file. + logForDebugging(`generateSessionName failed: ${errorMessage(error)}`, { + level: 'error', + }) + return null + } +} diff --git a/src/commands/rename/index.ts b/src/commands/rename/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..1de08254b8d95323f4a7e00d6333b1a035e9997c --- /dev/null +++ b/src/commands/rename/index.ts @@ -0,0 +1,12 @@ +import type { Command } from '../../commands.js' + +const rename = { + type: 'local-jsx', + name: 'rename', + description: 'Rename the current conversation', + immediate: true, + argumentHint: '[name]', + load: () => import('./rename.js'), +} satisfies Command + +export default rename diff --git a/src/commands/rename/rename.ts b/src/commands/rename/rename.ts new file mode 100644 index 0000000000000000000000000000000000000000..014d7ebd41f24dd939afe13c75b05bee3f342671 --- /dev/null +++ b/src/commands/rename/rename.ts @@ -0,0 +1,87 @@ +import type { UUID } from 'crypto' +import { getSessionId } from '../../bootstrap/state.js' +import { + getBridgeBaseUrlOverride, + getBridgeTokenOverride, +} from '../../bridge/bridgeConfig.js' +import type { ToolUseContext } from '../../Tool.js' +import type { + LocalJSXCommandContext, + LocalJSXCommandOnDone, +} from '../../types/command.js' +import { getMessagesAfterCompactBoundary } from '../../utils/messages.js' +import { + getTranscriptPath, + saveAgentName, + saveCustomTitle, +} from '../../utils/sessionStorage.js' +import { isTeammate } from '../../utils/teammate.js' +import { generateSessionName } from './generateSessionName.js' + +export async function call( + onDone: LocalJSXCommandOnDone, + context: ToolUseContext & LocalJSXCommandContext, + args: string, +): Promise { + // Prevent teammates from renaming - their names are set by team leader + if (isTeammate()) { + onDone( + 'Cannot rename: This session is a swarm teammate. Teammate names are set by the team leader.', + { display: 'system' }, + ) + return null + } + + let newName: string + if (!args || args.trim() === '') { + const generated = await generateSessionName( + getMessagesAfterCompactBoundary(context.messages), + context.abortController.signal, + ) + if (!generated) { + onDone( + 'Could not generate a name: no conversation context yet. Usage: /rename ', + { display: 'system' }, + ) + return null + } + newName = generated + } else { + newName = args.trim() + } + + const sessionId = getSessionId() as UUID + const fullPath = getTranscriptPath() + + // Always save the custom title (session name) + await saveCustomTitle(sessionId, newName, fullPath) + + // Sync title to bridge session on claude.ai/code (best-effort, non-blocking). + // v2 env-less bridge stores cse_* in replBridgeSessionId — + // updateBridgeSessionTitle retags internally for the compat endpoint. + const appState = context.getAppState() + const bridgeSessionId = appState.replBridgeSessionId + if (bridgeSessionId) { + const tokenOverride = getBridgeTokenOverride() + void import('../../bridge/createSession.js').then( + ({ updateBridgeSessionTitle }) => + updateBridgeSessionTitle(bridgeSessionId, newName, { + baseUrl: getBridgeBaseUrlOverride(), + getAccessToken: tokenOverride ? () => tokenOverride : undefined, + }).catch(() => {}), + ) + } + + // Also persist as the session's agent name for prompt-bar display + await saveAgentName(sessionId, newName, fullPath) + context.setAppState(prev => ({ + ...prev, + standaloneAgentContext: { + ...prev.standaloneAgentContext, + name: newName, + }, + })) + + onDone(`Session renamed to: ${newName}`, { display: 'system' }) + return null +} diff --git a/src/commands/resume/resume.tsx b/src/commands/resume/resume.tsx new file mode 100644 index 0000000000000000000000000000000000000000..8226c441ade2777f0298fb83b6a511331981f914 --- /dev/null +++ b/src/commands/resume/resume.tsx @@ -0,0 +1,275 @@ +import { c as _c } from "react/compiler-runtime"; +import chalk from 'chalk'; +import type { UUID } from 'crypto'; +import figures from 'figures'; +import * as React from 'react'; +import { getOriginalCwd, getSessionId } from '../../bootstrap/state.js'; +import type { CommandResultDisplay, ResumeEntrypoint } from '../../commands.js'; +import { LogSelector } from '../../components/LogSelector.js'; +import { MessageResponse } from '../../components/MessageResponse.js'; +import { Spinner } from '../../components/Spinner.js'; +import { useIsInsideModal } from '../../context/modalContext.js'; +import { useTerminalSize } from '../../hooks/useTerminalSize.js'; +import { setClipboard } from '../../ink/termio/osc.js'; +import { Box, Text } from '../../ink.js'; +import type { LocalJSXCommandCall } from '../../types/command.js'; +import type { LogOption } from '../../types/logs.js'; +import { agenticSessionSearch } from '../../utils/agenticSessionSearch.js'; +import { checkCrossProjectResume } from '../../utils/crossProjectResume.js'; +import { getWorktreePaths } from '../../utils/getWorktreePaths.js'; +import { logError } from '../../utils/log.js'; +import { getLastSessionLog, getSessionIdFromLog, isCustomTitleEnabled, isLiteLog, loadAllProjectsMessageLogs, loadFullLog, loadSameRepoMessageLogs, searchSessionsByCustomTitle } from '../../utils/sessionStorage.js'; +import { validateUuid } from '../../utils/uuid.js'; +type ResumeResult = { + resultType: 'sessionNotFound'; + arg: string; +} | { + resultType: 'multipleMatches'; + arg: string; + count: number; +}; +function resumeHelpMessage(result: ResumeResult): string { + switch (result.resultType) { + case 'sessionNotFound': + return `Session ${chalk.bold(result.arg)} was not found.`; + case 'multipleMatches': + return `Found ${result.count} sessions matching ${chalk.bold(result.arg)}. Please use /resume to pick a specific session.`; + } +} +function ResumeError(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]; + } + React.useEffect(t1, t2); + let t3; + if ($[3] !== args) { + t3 = {figures.pointer} /resume {args}; + $[3] = args; + $[4] = t3; + } else { + t3 = $[4]; + } + let t4; + if ($[5] !== message) { + t4 = {message}; + $[5] = message; + $[6] = t4; + } else { + t4 = $[6]; + } + let t5; + if ($[7] !== t3 || $[8] !== t4) { + t5 = {t3}{t4}; + $[7] = t3; + $[8] = t4; + $[9] = t5; + } else { + t5 = $[9]; + } + return t5; +} +function ResumeCommand({ + onDone, + onResume +}: { + onDone: (result?: string, options?: { + display?: CommandResultDisplay; + }) => void; + onResume: (sessionId: UUID, log: LogOption, entrypoint: ResumeEntrypoint) => Promise; +}): React.ReactNode { + const [logs, setLogs] = React.useState([]); + const [worktreePaths, setWorktreePaths] = React.useState([]); + const [loading, setLoading] = React.useState(true); + const [resuming, setResuming] = React.useState(false); + const [showAllProjects, setShowAllProjects] = React.useState(false); + const { + rows + } = useTerminalSize(); + const insideModal = useIsInsideModal(); + const loadLogs = React.useCallback(async (allProjects: boolean, paths: string[]) => { + setLoading(true); + try { + const allLogs = allProjects ? await loadAllProjectsMessageLogs() : await loadSameRepoMessageLogs(paths); + const resumable = filterResumableSessions(allLogs, getSessionId()); + if (resumable.length === 0) { + onDone('No conversations found to resume'); + return; + } + setLogs(resumable); + } catch (_err) { + onDone('Failed to load conversations'); + } finally { + setLoading(false); + } + }, [onDone]); + React.useEffect(() => { + async function init() { + const paths_0 = await getWorktreePaths(getOriginalCwd()); + setWorktreePaths(paths_0); + void loadLogs(false, paths_0); + } + void init(); + }, [loadLogs]); + const handleToggleAllProjects = React.useCallback(() => { + const newValue = !showAllProjects; + setShowAllProjects(newValue); + void loadLogs(newValue, worktreePaths); + }, [showAllProjects, loadLogs, worktreePaths]); + async function handleSelect(log: LogOption) { + const sessionId = validateUuid(getSessionIdFromLog(log)); + if (!sessionId) { + onDone('Failed to resume conversation'); + return; + } + + // Load full messages for lite logs + const fullLog = isLiteLog(log) ? await loadFullLog(log) : log; + + // Check if this conversation is from a different directory + const crossProjectCheck = checkCrossProjectResume(fullLog, showAllProjects, worktreePaths); + if (crossProjectCheck.isCrossProject) { + if (crossProjectCheck.isSameRepoWorktree) { + // Same repo worktree - can resume directly + setResuming(true); + void onResume(sessionId, fullLog, 'slash_command_picker'); + return; + } + + // Different project - show command instead of resuming + const raw = await setClipboard(crossProjectCheck.command); + if (raw) process.stdout.write(raw); + + // Format the output message + const message = ['', 'This conversation is from a different directory.', '', 'To resume, run:', ` ${crossProjectCheck.command}`, '', '(Command copied to clipboard)', ''].join('\n'); + onDone(message, { + display: 'user' + }); + return; + } + + // Same directory - proceed with resume + setResuming(true); + void onResume(sessionId, fullLog, 'slash_command_picker'); + } + function handleCancel() { + onDone('Resume cancelled', { + display: 'system' + }); + } + if (loading) { + return + + Loading conversations… + ; + } + if (resuming) { + return + + Resuming conversation… + ; + } + return loadLogs(showAllProjects, worktreePaths)} showAllProjects={showAllProjects} onToggleAllProjects={handleToggleAllProjects} onAgenticSearch={agenticSessionSearch} />; +} +export function filterResumableSessions(logs: LogOption[], currentSessionId: string): LogOption[] { + return logs.filter(l => !l.isSidechain && getSessionIdFromLog(l) !== currentSessionId); +} +export const call: LocalJSXCommandCall = async (onDone, context, args) => { + const onResume = async (sessionId: UUID, log: LogOption, entrypoint: ResumeEntrypoint) => { + try { + await context.resume?.(sessionId, log, entrypoint); + onDone(undefined, { + display: 'skip' + }); + } catch (error) { + logError(error as Error); + onDone(`Failed to resume: ${(error as Error).message}`); + } + }; + const arg = args?.trim(); + + // No argument provided - show picker + if (!arg) { + return ; + } + + // Load logs to search (includes same-repo worktrees) + const worktreePaths = await getWorktreePaths(getOriginalCwd()); + const logs = await loadSameRepoMessageLogs(worktreePaths); + if (logs.length === 0) { + const message = 'No conversations found to resume.'; + return onDone(message)} />; + } + + // First, check if arg is a valid UUID + const maybeSessionId = validateUuid(arg); + if (maybeSessionId) { + const matchingLogs = logs.filter(l => getSessionIdFromLog(l) === maybeSessionId).sort((a, b) => b.modified.getTime() - a.modified.getTime()); + if (matchingLogs.length > 0) { + const log = matchingLogs[0]!; + const fullLog = isLiteLog(log) ? await loadFullLog(log) : log; + void onResume(maybeSessionId, fullLog, 'slash_command_session_id'); + return null; + } + + // Enriched logs didn't find it — try direct file lookup. This handles + // sessions filtered out by enrichLogs (e.g., first message >16KB makes + // firstPrompt extraction fail, causing the session to be dropped). + const directLog = await getLastSessionLog(maybeSessionId); + if (directLog) { + void onResume(maybeSessionId, directLog, 'slash_command_session_id'); + return null; + } + } + + // Next, try exact custom title match (only if feature is enabled) + if (isCustomTitleEnabled()) { + const titleMatches = await searchSessionsByCustomTitle(arg, { + exact: true + }); + if (titleMatches.length === 1) { + const log = titleMatches[0]!; + const sessionId = getSessionIdFromLog(log); + if (sessionId) { + const fullLog = isLiteLog(log) ? await loadFullLog(log) : log; + void onResume(sessionId, fullLog, 'slash_command_title'); + return null; + } + } + + // Multiple matches - show error + if (titleMatches.length > 1) { + const message = resumeHelpMessage({ + resultType: 'multipleMatches', + arg, + count: titleMatches.length + }); + return onDone(message)} />; + } + } + + // No match found - show error + const message = resumeHelpMessage({ + resultType: 'sessionNotFound', + arg + }); + return onDone(message)} />; +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","UUID","figures","React","getOriginalCwd","getSessionId","CommandResultDisplay","ResumeEntrypoint","LogSelector","MessageResponse","Spinner","useIsInsideModal","useTerminalSize","setClipboard","Box","Text","LocalJSXCommandCall","LogOption","agenticSessionSearch","checkCrossProjectResume","getWorktreePaths","logError","getLastSessionLog","getSessionIdFromLog","isCustomTitleEnabled","isLiteLog","loadAllProjectsMessageLogs","loadFullLog","loadSameRepoMessageLogs","searchSessionsByCustomTitle","validateUuid","ResumeResult","resultType","arg","count","resumeHelpMessage","result","bold","ResumeError","t0","$","_c","message","args","onDone","t1","t2","timer","setTimeout","clearTimeout","useEffect","t3","pointer","t4","t5","ResumeCommand","onResume","options","display","sessionId","log","entrypoint","Promise","ReactNode","logs","setLogs","useState","worktreePaths","setWorktreePaths","loading","setLoading","resuming","setResuming","showAllProjects","setShowAllProjects","rows","insideModal","loadLogs","useCallback","allProjects","paths","allLogs","resumable","filterResumableSessions","length","_err","init","handleToggleAllProjects","newValue","handleSelect","fullLog","crossProjectCheck","isCrossProject","isSameRepoWorktree","raw","command","process","stdout","write","join","handleCancel","Math","floor","currentSessionId","filter","l","isSidechain","call","context","resume","undefined","error","Error","trim","Date","now","maybeSessionId","matchingLogs","sort","a","b","modified","getTime","directLog","titleMatches","exact"],"sources":["resume.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport type { UUID } from 'crypto'\nimport figures from 'figures'\nimport * as React from 'react'\nimport { getOriginalCwd, getSessionId } from '../../bootstrap/state.js'\nimport type { CommandResultDisplay, ResumeEntrypoint } from '../../commands.js'\nimport { LogSelector } from '../../components/LogSelector.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { Spinner } from '../../components/Spinner.js'\nimport { useIsInsideModal } from '../../context/modalContext.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { setClipboard } from '../../ink/termio/osc.js'\nimport { Box, Text } from '../../ink.js'\nimport type { LocalJSXCommandCall } from '../../types/command.js'\nimport type { LogOption } from '../../types/logs.js'\nimport { agenticSessionSearch } from '../../utils/agenticSessionSearch.js'\nimport { checkCrossProjectResume } from '../../utils/crossProjectResume.js'\nimport { getWorktreePaths } from '../../utils/getWorktreePaths.js'\nimport { logError } from '../../utils/log.js'\nimport {\n  getLastSessionLog,\n  getSessionIdFromLog,\n  isCustomTitleEnabled,\n  isLiteLog,\n  loadAllProjectsMessageLogs,\n  loadFullLog,\n  loadSameRepoMessageLogs,\n  searchSessionsByCustomTitle,\n} from '../../utils/sessionStorage.js'\nimport { validateUuid } from '../../utils/uuid.js'\n\ntype ResumeResult =\n  | { resultType: 'sessionNotFound'; arg: string }\n  | { resultType: 'multipleMatches'; arg: string; count: number }\n\nfunction resumeHelpMessage(result: ResumeResult): string {\n  switch (result.resultType) {\n    case 'sessionNotFound':\n      return `Session ${chalk.bold(result.arg)} was not found.`\n    case 'multipleMatches':\n      return `Found ${result.count} sessions matching ${chalk.bold(result.arg)}. Please use /resume to pick a specific session.`\n  }\n}\n\nfunction ResumeError({\n  message,\n  args,\n  onDone,\n}: {\n  message: string\n  args: string\n  onDone: () => void\n}): React.ReactNode {\n  React.useEffect(() => {\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} /resume {args}\n      </Text>\n      <MessageResponse>\n        <Text>{message}</Text>\n      </MessageResponse>\n    </Box>\n  )\n}\n\nfunction ResumeCommand({\n  onDone,\n  onResume,\n}: {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n  onResume: (\n    sessionId: UUID,\n    log: LogOption,\n    entrypoint: ResumeEntrypoint,\n  ) => Promise<void>\n}): React.ReactNode {\n  const [logs, setLogs] = React.useState<LogOption[]>([])\n  const [worktreePaths, setWorktreePaths] = React.useState<string[]>([])\n  const [loading, setLoading] = React.useState(true)\n  const [resuming, setResuming] = React.useState(false)\n  const [showAllProjects, setShowAllProjects] = React.useState(false)\n  const { rows } = useTerminalSize()\n  const insideModal = useIsInsideModal()\n\n  const loadLogs = React.useCallback(\n    async (allProjects: boolean, paths: string[]) => {\n      setLoading(true)\n      try {\n        const allLogs = allProjects\n          ? await loadAllProjectsMessageLogs()\n          : await loadSameRepoMessageLogs(paths)\n        const resumable = filterResumableSessions(allLogs, getSessionId())\n        if (resumable.length === 0) {\n          onDone('No conversations found to resume')\n          return\n        }\n        setLogs(resumable)\n      } catch (_err) {\n        onDone('Failed to load conversations')\n      } finally {\n        setLoading(false)\n      }\n    },\n    [onDone],\n  )\n\n  React.useEffect(() => {\n    async function init() {\n      const paths = await getWorktreePaths(getOriginalCwd())\n      setWorktreePaths(paths)\n      void loadLogs(false, paths)\n    }\n    void init()\n  }, [loadLogs])\n\n  const handleToggleAllProjects = React.useCallback(() => {\n    const newValue = !showAllProjects\n    setShowAllProjects(newValue)\n    void loadLogs(newValue, worktreePaths)\n  }, [showAllProjects, loadLogs, worktreePaths])\n\n  async function handleSelect(log: LogOption) {\n    const sessionId = validateUuid(getSessionIdFromLog(log))\n    if (!sessionId) {\n      onDone('Failed to resume conversation')\n      return\n    }\n\n    // Load full messages for lite logs\n    const fullLog = isLiteLog(log) ? await loadFullLog(log) : log\n\n    // Check if this conversation is from a different directory\n    const crossProjectCheck = checkCrossProjectResume(\n      fullLog,\n      showAllProjects,\n      worktreePaths,\n    )\n    if (crossProjectCheck.isCrossProject) {\n      if (crossProjectCheck.isSameRepoWorktree) {\n        // Same repo worktree - can resume directly\n        setResuming(true)\n        void onResume(sessionId, fullLog, 'slash_command_picker')\n        return\n      }\n\n      // Different project - show command instead of resuming\n      const raw = await setClipboard(crossProjectCheck.command)\n      if (raw) process.stdout.write(raw)\n\n      // Format the output message\n      const message = [\n        '',\n        'This conversation is from a different directory.',\n        '',\n        'To resume, run:',\n        `  ${crossProjectCheck.command}`,\n        '',\n        '(Command copied to clipboard)',\n        '',\n      ].join('\\n')\n\n      onDone(message, { display: 'user' })\n      return\n    }\n\n    // Same directory - proceed with resume\n    setResuming(true)\n    void onResume(sessionId, fullLog, 'slash_command_picker')\n  }\n\n  function handleCancel() {\n    onDone('Resume cancelled', { display: 'system' })\n  }\n\n  if (loading) {\n    return (\n      <Box>\n        <Spinner />\n        <Text> Loading conversations…</Text>\n      </Box>\n    )\n  }\n\n  if (resuming) {\n    return (\n      <Box>\n        <Spinner />\n        <Text> Resuming conversation…</Text>\n      </Box>\n    )\n  }\n\n  return (\n    <LogSelector\n      logs={logs}\n      maxHeight={insideModal ? Math.floor(rows / 2) : rows - 2}\n      onCancel={handleCancel}\n      onSelect={handleSelect}\n      onLogsChanged={() => loadLogs(showAllProjects, worktreePaths)}\n      showAllProjects={showAllProjects}\n      onToggleAllProjects={handleToggleAllProjects}\n      onAgenticSearch={agenticSessionSearch}\n    />\n  )\n}\n\nexport function filterResumableSessions(\n  logs: LogOption[],\n  currentSessionId: string,\n): LogOption[] {\n  return logs.filter(\n    l => !l.isSidechain && getSessionIdFromLog(l) !== currentSessionId,\n  )\n}\n\nexport const call: LocalJSXCommandCall = async (onDone, context, args) => {\n  const onResume = async (\n    sessionId: UUID,\n    log: LogOption,\n    entrypoint: ResumeEntrypoint,\n  ) => {\n    try {\n      await context.resume?.(sessionId, log, entrypoint)\n      onDone(undefined, { display: 'skip' })\n    } catch (error) {\n      logError(error as Error)\n      onDone(`Failed to resume: ${(error as Error).message}`)\n    }\n  }\n\n  const arg = args?.trim()\n\n  // No argument provided - show picker\n  if (!arg) {\n    return (\n      <ResumeCommand key={Date.now()} onDone={onDone} onResume={onResume} />\n    )\n  }\n\n  // Load logs to search (includes same-repo worktrees)\n  const worktreePaths = await getWorktreePaths(getOriginalCwd())\n  const logs = await loadSameRepoMessageLogs(worktreePaths)\n  if (logs.length === 0) {\n    const message = 'No conversations found to resume.'\n    return (\n      <ResumeError\n        message={message}\n        args={arg}\n        onDone={() => onDone(message)}\n      />\n    )\n  }\n\n  // First, check if arg is a valid UUID\n  const maybeSessionId = validateUuid(arg)\n  if (maybeSessionId) {\n    const matchingLogs = logs\n      .filter(l => getSessionIdFromLog(l) === maybeSessionId)\n      .sort((a, b) => b.modified.getTime() - a.modified.getTime())\n\n    if (matchingLogs.length > 0) {\n      const log = matchingLogs[0]!\n      const fullLog = isLiteLog(log) ? await loadFullLog(log) : log\n      void onResume(maybeSessionId, fullLog, 'slash_command_session_id')\n      return null\n    }\n\n    // Enriched logs didn't find it — try direct file lookup. This handles\n    // sessions filtered out by enrichLogs (e.g., first message >16KB makes\n    // firstPrompt extraction fail, causing the session to be dropped).\n    const directLog = await getLastSessionLog(maybeSessionId)\n    if (directLog) {\n      void onResume(maybeSessionId, directLog, 'slash_command_session_id')\n      return null\n    }\n  }\n\n  // Next, try exact custom title match (only if feature is enabled)\n  if (isCustomTitleEnabled()) {\n    const titleMatches = await searchSessionsByCustomTitle(arg, {\n      exact: true,\n    })\n    if (titleMatches.length === 1) {\n      const log = titleMatches[0]!\n      const sessionId = getSessionIdFromLog(log)\n      if (sessionId) {\n        const fullLog = isLiteLog(log) ? await loadFullLog(log) : log\n        void onResume(sessionId, fullLog, 'slash_command_title')\n        return null\n      }\n    }\n\n    // Multiple matches - show error\n    if (titleMatches.length > 1) {\n      const message = resumeHelpMessage({\n        resultType: 'multipleMatches',\n        arg,\n        count: titleMatches.length,\n      })\n      return (\n        <ResumeError\n          message={message}\n          args={arg}\n          onDone={() => onDone(message)}\n        />\n      )\n    }\n  }\n\n  // No match found - show error\n  const message = resumeHelpMessage({ resultType: 'sessionNotFound', arg })\n  return (\n    <ResumeError message={message} args={arg} onDone={() => onDone(message)} />\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/review/reviewRemote.ts b/src/commands/review/reviewRemote.ts new file mode 100644 index 0000000000000000000000000000000000000000..0b80e33959d8a06075e59b451f72e4fdbffc1f98 --- /dev/null +++ b/src/commands/review/reviewRemote.ts @@ -0,0 +1,316 @@ +/** + * Teleported /ultrareview execution. Creates a CCR session with the current repo, + * sends the review prompt as the initial message, and registers a + * RemoteAgentTask so the polling loop pipes results back into the local + * session via task-notification. Mirrors the /ultraplan → CCR flow. + * + * TODO(#22051): pass useBundleMode once landed so local-only / uncommitted + * repo state is captured. The GitHub-clone path (current) only works for + * pushed branches on repos with the Claude GitHub app installed. + */ + +import type { ContentBlockParam } from '@anthropic-ai/sdk/resources/messages.js' +import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js' +import { + type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + logEvent, +} from '../../services/analytics/index.js' +import { fetchUltrareviewQuota } from '../../services/api/ultrareviewQuota.js' +import { fetchUtilization } from '../../services/api/usage.js' +import type { ToolUseContext } from '../../Tool.js' +import { + checkRemoteAgentEligibility, + formatPreconditionError, + getRemoteTaskSessionUrl, + registerRemoteAgentTask, +} from '../../tasks/RemoteAgentTask/RemoteAgentTask.js' +import { isEnterpriseSubscriber, isTeamSubscriber } from '../../utils/auth.js' +import { detectCurrentRepositoryWithHost } from '../../utils/detectRepository.js' +import { execFileNoThrow } from '../../utils/execFileNoThrow.js' +import { getDefaultBranch, gitExe } from '../../utils/git.js' +import { teleportToRemote } from '../../utils/teleport.js' + +// One-time session flag: once the user confirms overage billing via the +// dialog, all subsequent /ultrareview invocations in this session proceed +// without re-prompting. +let sessionOverageConfirmed = false + +export function confirmOverage(): void { + sessionOverageConfirmed = true +} + +export type OverageGate = + | { kind: 'proceed'; billingNote: string } + | { kind: 'not-enabled' } + | { kind: 'low-balance'; available: number } + | { kind: 'needs-confirm' } + +/** + * Determine whether the user can launch an ultrareview and under what + * billing terms. Fetches quota and utilization in parallel. + */ +export async function checkOverageGate(): Promise { + // Team and Enterprise plans include ultrareview — no free-review quota + // or Extra Usage dialog. The quota endpoint is scoped to consumer plans + // (pro/max); hitting it on team/ent would surface a confusing dialog. + if (isTeamSubscriber() || isEnterpriseSubscriber()) { + return { kind: 'proceed', billingNote: '' } + } + + const [quota, utilization] = await Promise.all([ + fetchUltrareviewQuota(), + fetchUtilization().catch(() => null), + ]) + + // No quota info (non-subscriber or endpoint down) — let it through, + // server-side billing will handle it. + if (!quota) { + return { kind: 'proceed', billingNote: '' } + } + + if (quota.reviews_remaining > 0) { + return { + kind: 'proceed', + billingNote: ` This is free ultrareview ${quota.reviews_used + 1} of ${quota.reviews_limit}.`, + } + } + + // Utilization fetch failed (transient network error, timeout, etc.) — + // let it through, same rationale as the quota fallback above. + if (!utilization) { + return { kind: 'proceed', billingNote: '' } + } + + // Free reviews exhausted — check Extra Usage setup. + const extraUsage = utilization.extra_usage + if (!extraUsage?.is_enabled) { + logEvent('tengu_review_overage_not_enabled', {}) + return { kind: 'not-enabled' } + } + + // Check available balance (null monthly_limit = unlimited). + const monthlyLimit = extraUsage.monthly_limit + const usedCredits = extraUsage.used_credits ?? 0 + const available = + monthlyLimit === null || monthlyLimit === undefined + ? Infinity + : monthlyLimit - usedCredits + + if (available < 10) { + logEvent('tengu_review_overage_low_balance', { available }) + return { kind: 'low-balance', available } + } + + if (!sessionOverageConfirmed) { + logEvent('tengu_review_overage_dialog_shown', {}) + return { kind: 'needs-confirm' } + } + + return { + kind: 'proceed', + billingNote: ' This review bills as Extra Usage.', + } +} + +/** + * Launch a teleported review session. Returns ContentBlockParam[] describing + * the launch outcome for injection into the local conversation (model is then + * queried with this content, so it can narrate the launch to the user). + * + * Returns ContentBlockParam[] with user-facing error messages on recoverable + * failures (missing merge-base, empty diff, bundle too large), or null on + * other failures so the caller falls through to the local-review prompt. + * Reason is captured in analytics. + * + * Caller must run checkOverageGate() BEFORE calling this function + * (ultrareviewCommand.tsx handles the dialog). + */ +export async function launchRemoteReview( + args: string, + context: ToolUseContext, + billingNote?: string, +): Promise { + const eligibility = await checkRemoteAgentEligibility() + // Synthetic DEFAULT_CODE_REVIEW_ENVIRONMENT_ID works without per-org CCR + // setup, so no_remote_environment isn't a blocker. Server-side quota + // consume at session creation routes billing: first N zero-rate, then + // anthropic:cccr org-service-key (overage-only). + if (!eligibility.eligible) { + const blockers = eligibility.errors.filter( + e => e.type !== 'no_remote_environment', + ) + if (blockers.length > 0) { + logEvent('tengu_review_remote_precondition_failed', { + precondition_errors: blockers + .map(e => e.type) + .join( + ',', + ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + }) + const reasons = blockers.map(formatPreconditionError).join('\n') + return [ + { + type: 'text', + text: `Ultrareview cannot launch:\n${reasons}`, + }, + ] + } + } + + const resolvedBillingNote = billingNote ?? '' + + const prNumber = args.trim() + const isPrNumber = /^\d+$/.test(prNumber) + // Synthetic code_review env. Go taggedid.FromUUID(TagEnvironment, + // UUID{...,0x02}) encodes with version prefix '01' — NOT Python's + // legacy tagged_id() format. Verified in prod. + const CODE_REVIEW_ENV_ID = 'env_011111111111111111111113' + // Lite-review bypasses bughunter.go entirely, so it doesn't see the + // webhook's bug_hunter_config (different GB project). These env vars are + // the only tuning surface — without them, run_hunt.sh's bash defaults + // apply (60min, 120s agent timeout), and 120s kills verifiers mid-run + // which causes infinite respawn. + // + // total_wallclock must stay below RemoteAgentTask's 30min poll timeout + // with headroom for finalization (~3min synthesis). Per-field guards + // match autoDream.ts — GB cache can return stale wrong-type values. + const raw = getFeatureValue_CACHED_MAY_BE_STALE | null>('tengu_review_bughunter_config', null) + const posInt = (v: unknown, fallback: number, max?: number): number => { + if (typeof v !== 'number' || !Number.isFinite(v)) return fallback + const n = Math.floor(v) + if (n <= 0) return fallback + return max !== undefined && n > max ? fallback : n + } + // Upper bounds: 27min on wallclock leaves ~3min for finalization under + // RemoteAgentTask's 30min poll timeout. If GB is set above that, the + // hang we're fixing comes back — fall to the safe default instead. + const commonEnvVars = { + BUGHUNTER_DRY_RUN: '1', + BUGHUNTER_FLEET_SIZE: String(posInt(raw?.fleet_size, 5, 20)), + BUGHUNTER_MAX_DURATION: String(posInt(raw?.max_duration_minutes, 10, 25)), + BUGHUNTER_AGENT_TIMEOUT: String( + posInt(raw?.agent_timeout_seconds, 600, 1800), + ), + BUGHUNTER_TOTAL_WALLCLOCK: String( + posInt(raw?.total_wallclock_minutes, 22, 27), + ), + ...(process.env.BUGHUNTER_DEV_BUNDLE_B64 && { + BUGHUNTER_DEV_BUNDLE_B64: process.env.BUGHUNTER_DEV_BUNDLE_B64, + }), + } + + let session + let command + let target + if (isPrNumber) { + // PR mode: refs/pull/N/head via github.com. Orchestrator --pr N. + const repo = await detectCurrentRepositoryWithHost() + if (!repo || repo.host !== 'github.com') { + logEvent('tengu_review_remote_precondition_failed', {}) + return null + } + session = await teleportToRemote({ + initialMessage: null, + description: `ultrareview: ${repo.owner}/${repo.name}#${prNumber}`, + signal: context.abortController.signal, + branchName: `refs/pull/${prNumber}/head`, + environmentId: CODE_REVIEW_ENV_ID, + environmentVariables: { + BUGHUNTER_PR_NUMBER: prNumber, + BUGHUNTER_REPOSITORY: `${repo.owner}/${repo.name}`, + ...commonEnvVars, + }, + }) + command = `/ultrareview ${prNumber}` + target = `${repo.owner}/${repo.name}#${prNumber}` + } else { + // Branch mode: bundle the working tree, orchestrator diffs against + // the fork point. No PR, no existing comments, no dedup. + const baseBranch = (await getDefaultBranch()) || 'main' + // Env-manager's `git remote remove origin` after bundle-clone + // deletes refs/remotes/origin/* — the base branch name won't resolve + // in the container. Pass the merge-base SHA instead: it's reachable + // from HEAD's history so `git diff ` works without a named ref. + const { stdout: mbOut, code: mbCode } = await execFileNoThrow( + gitExe(), + ['merge-base', baseBranch, 'HEAD'], + { preserveOutputOnError: false }, + ) + const mergeBaseSha = mbOut.trim() + if (mbCode !== 0 || !mergeBaseSha) { + logEvent('tengu_review_remote_precondition_failed', {}) + return [ + { + type: 'text', + text: `Could not find merge-base with ${baseBranch}. Make sure you're in a git repo with a ${baseBranch} branch.`, + }, + ] + } + + // Bail early on empty diffs instead of launching a container that + // will just echo "no changes". + const { stdout: diffStat, code: diffCode } = await execFileNoThrow( + gitExe(), + ['diff', '--shortstat', mergeBaseSha], + { preserveOutputOnError: false }, + ) + if (diffCode === 0 && !diffStat.trim()) { + logEvent('tengu_review_remote_precondition_failed', {}) + return [ + { + type: 'text', + text: `No changes against the ${baseBranch} fork point. Make some commits or stage files first.`, + }, + ] + } + + session = await teleportToRemote({ + initialMessage: null, + description: `ultrareview: ${baseBranch}`, + signal: context.abortController.signal, + useBundle: true, + environmentId: CODE_REVIEW_ENV_ID, + environmentVariables: { + BUGHUNTER_BASE_BRANCH: mergeBaseSha, + ...commonEnvVars, + }, + }) + if (!session) { + logEvent('tengu_review_remote_teleport_failed', {}) + return [ + { + type: 'text', + text: 'Repo is too large. Push a PR and use `/ultrareview ` instead.', + }, + ] + } + command = '/ultrareview' + target = baseBranch + } + + if (!session) { + logEvent('tengu_review_remote_teleport_failed', {}) + return null + } + registerRemoteAgentTask({ + remoteTaskType: 'ultrareview', + session, + command, + context, + isRemoteReview: true, + }) + logEvent('tengu_review_remote_launched', {}) + const sessionUrl = getRemoteTaskSessionUrl(session.id) + // Concise — the tool-output block is visible to the user, so the model + // shouldn't echo the same info. Just enough for Claude to acknowledge the + // launch without restating the target/URL (both already printed above). + return [ + { + type: 'text', + text: `Ultrareview launched for ${target} (~10–20 min, runs in the cloud). Track: ${sessionUrl}${resolvedBillingNote} Findings arrive via task-notification. Briefly acknowledge the launch to the user without repeating the target or URL — both are already visible in the tool output above.`, + }, + ] +} diff --git a/src/commands/sandbox-toggle/sandbox-toggle.tsx b/src/commands/sandbox-toggle/sandbox-toggle.tsx new file mode 100644 index 0000000000000000000000000000000000000000..f56503c24a2a6ad8e4a7ebd267810360c2ee9568 --- /dev/null +++ b/src/commands/sandbox-toggle/sandbox-toggle.tsx @@ -0,0 +1,83 @@ +import { relative } from 'path'; +import React from 'react'; +import { getCwdState } from '../../bootstrap/state.js'; +import { SandboxSettings } from '../../components/sandbox/SandboxSettings.js'; +import { color } from '../../ink.js'; +import { getPlatform } from '../../utils/platform.js'; +import { addToExcludedCommands, SandboxManager } from '../../utils/sandbox/sandbox-adapter.js'; +import { getSettings_DEPRECATED, getSettingsFilePathForSource } from '../../utils/settings/settings.js'; +import type { ThemeName } from '../../utils/theme.js'; +export async function call(onDone: (result?: string) => void, _context: unknown, args?: string): Promise { + const settings = getSettings_DEPRECATED(); + const themeName: ThemeName = settings.theme as ThemeName || 'light'; + const platform = getPlatform(); + if (!SandboxManager.isSupportedPlatform()) { + // WSL1 users will see this since isSupportedPlatform returns false for WSL1 + const errorMessage = platform === 'wsl' ? 'Error: Sandboxing requires WSL2. WSL1 is not supported.' : 'Error: Sandboxing is currently only supported on macOS, Linux, and WSL2.'; + const message = color('error', themeName)(errorMessage); + onDone(message); + return null; + } + + // Check dependencies - get structured result with errors/warnings + const depCheck = SandboxManager.checkDependencies(); + + // Check if platform is in enabledPlatforms list (undocumented enterprise setting) + if (!SandboxManager.isPlatformInEnabledList()) { + const message = color('error', themeName)(`Error: Sandboxing is disabled for this platform (${platform}) via the enabledPlatforms setting.`); + onDone(message); + return null; + } + + // Check if sandbox settings are locked by higher-priority settings + if (SandboxManager.areSandboxSettingsLockedByPolicy()) { + const message = color('error', themeName)('Error: Sandbox settings are overridden by a higher-priority configuration and cannot be changed locally.'); + onDone(message); + return null; + } + + // Parse the arguments + const trimmedArgs = args?.trim() || ''; + + // If no args, show the interactive menu + if (!trimmedArgs) { + return ; + } + + // Handle subcommands + if (trimmedArgs) { + const parts = trimmedArgs.split(' '); + const subcommand = parts[0]; + if (subcommand === 'exclude') { + // Handle exclude subcommand + const commandPattern = trimmedArgs.slice('exclude '.length).trim(); + if (!commandPattern) { + const message = color('error', themeName)('Error: Please provide a command pattern to exclude (e.g., /sandbox exclude "npm run test:*")'); + onDone(message); + return null; + } + + // Remove quotes if present + const cleanPattern = commandPattern.replace(/^["']|["']$/g, ''); + + // Add to excludedCommands + addToExcludedCommands(cleanPattern); + + // Get the local settings path and make it relative to cwd + const localSettingsPath = getSettingsFilePathForSource('localSettings'); + const relativePath = localSettingsPath ? relative(getCwdState(), localSettingsPath) : '.claude/settings.local.json'; + const message = color('success', themeName)(`Added "${cleanPattern}" to excluded commands in ${relativePath}`); + onDone(message); + return null; + } else { + // Unknown subcommand + const message = color('error', themeName)(`Error: Unknown subcommand "${subcommand}". Available subcommand: exclude`); + onDone(message); + return null; + } + } + + // Should never reach here since we handle all cases above + return null; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["relative","React","getCwdState","SandboxSettings","color","getPlatform","addToExcludedCommands","SandboxManager","getSettings_DEPRECATED","getSettingsFilePathForSource","ThemeName","call","onDone","result","_context","args","Promise","ReactNode","settings","themeName","theme","platform","isSupportedPlatform","errorMessage","message","depCheck","checkDependencies","isPlatformInEnabledList","areSandboxSettingsLockedByPolicy","trimmedArgs","trim","parts","split","subcommand","commandPattern","slice","length","cleanPattern","replace","localSettingsPath","relativePath"],"sources":["sandbox-toggle.tsx"],"sourcesContent":["import { relative } from 'path'\nimport React from 'react'\nimport { getCwdState } from '../../bootstrap/state.js'\nimport { SandboxSettings } from '../../components/sandbox/SandboxSettings.js'\nimport { color } from '../../ink.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport {\n  addToExcludedCommands,\n  SandboxManager,\n} from '../../utils/sandbox/sandbox-adapter.js'\nimport {\n  getSettings_DEPRECATED,\n  getSettingsFilePathForSource,\n} from '../../utils/settings/settings.js'\nimport type { ThemeName } from '../../utils/theme.js'\n\nexport async function call(\n  onDone: (result?: string) => void,\n  _context: unknown,\n  args?: string,\n): Promise<React.ReactNode | null> {\n  const settings = getSettings_DEPRECATED()\n  const themeName: ThemeName = (settings.theme as ThemeName) || 'light'\n\n  const platform = getPlatform()\n\n  if (!SandboxManager.isSupportedPlatform()) {\n    // WSL1 users will see this since isSupportedPlatform returns false for WSL1\n    const errorMessage =\n      platform === 'wsl'\n        ? 'Error: Sandboxing requires WSL2. WSL1 is not supported.'\n        : 'Error: Sandboxing is currently only supported on macOS, Linux, and WSL2.'\n    const message = color('error', themeName)(errorMessage)\n    onDone(message)\n    return null\n  }\n\n  // Check dependencies - get structured result with errors/warnings\n  const depCheck = SandboxManager.checkDependencies()\n\n  // Check if platform is in enabledPlatforms list (undocumented enterprise setting)\n  if (!SandboxManager.isPlatformInEnabledList()) {\n    const message = color(\n      'error',\n      themeName,\n    )(\n      `Error: Sandboxing is disabled for this platform (${platform}) via the enabledPlatforms setting.`,\n    )\n    onDone(message)\n    return null\n  }\n\n  // Check if sandbox settings are locked by higher-priority settings\n  if (SandboxManager.areSandboxSettingsLockedByPolicy()) {\n    const message = color(\n      'error',\n      themeName,\n    )(\n      'Error: Sandbox settings are overridden by a higher-priority configuration and cannot be changed locally.',\n    )\n    onDone(message)\n    return null\n  }\n\n  // Parse the arguments\n  const trimmedArgs = args?.trim() || ''\n\n  // If no args, show the interactive menu\n  if (!trimmedArgs) {\n    return <SandboxSettings onComplete={onDone} depCheck={depCheck} />\n  }\n\n  // Handle subcommands\n  if (trimmedArgs) {\n    const parts = trimmedArgs.split(' ')\n    const subcommand = parts[0]\n\n    if (subcommand === 'exclude') {\n      // Handle exclude subcommand\n      const commandPattern = trimmedArgs.slice('exclude '.length).trim()\n\n      if (!commandPattern) {\n        const message = color(\n          'error',\n          themeName,\n        )(\n          'Error: Please provide a command pattern to exclude (e.g., /sandbox exclude \"npm run test:*\")',\n        )\n        onDone(message)\n        return null\n      }\n\n      // Remove quotes if present\n      const cleanPattern = commandPattern.replace(/^[\"']|[\"']$/g, '')\n\n      // Add to excludedCommands\n      addToExcludedCommands(cleanPattern)\n\n      // Get the local settings path and make it relative to cwd\n      const localSettingsPath = getSettingsFilePathForSource('localSettings')\n      const relativePath = localSettingsPath\n        ? relative(getCwdState(), localSettingsPath)\n        : '.claude/settings.local.json'\n\n      const message = color(\n        'success',\n        themeName,\n      )(`Added \"${cleanPattern}\" to excluded commands in ${relativePath}`)\n\n      onDone(message)\n      return null\n    } else {\n      // Unknown subcommand\n      const message = color(\n        'error',\n        themeName,\n      )(\n        `Error: Unknown subcommand \"${subcommand}\". Available subcommand: exclude`,\n      )\n      onDone(message)\n      return null\n    }\n  }\n\n  // Should never reach here since we handle all cases above\n  return null\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/commands/session/index.ts b/src/commands/session/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..c66187806427e72b2d7e3d63bba26bc8ecc340ec --- /dev/null +++ b/src/commands/session/index.ts @@ -0,0 +1,16 @@ +import { getIsRemoteMode } from '../../bootstrap/state.js' +import type { Command } from '../../commands.js' + +const session = { + type: 'local-jsx', + name: 'session', + aliases: ['remote'], + description: 'Show remote session URL and QR code', + isEnabled: () => getIsRemoteMode(), + get isHidden() { + return !getIsRemoteMode() + }, + load: () => import('./session.js'), +} satisfies Command + +export default session diff --git a/src/commands/skills/index.ts b/src/commands/skills/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..90e1d7f3ccbfea980f1af8d8a1a3869c1b5f3803 --- /dev/null +++ b/src/commands/skills/index.ts @@ -0,0 +1,10 @@ +import type { Command } from '../../commands.js' + +const skills = { + type: 'local-jsx', + name: 'skills', + description: 'List available skills', + load: () => import('./skills.js'), +} satisfies Command + +export default skills diff --git a/src/commands/skills/skills.tsx b/src/commands/skills/skills.tsx new file mode 100644 index 0000000000000000000000000000000000000000..c9bf0e6cbae502bf43aebc4ef6c9c4b627a26126 --- /dev/null +++ b/src/commands/skills/skills.tsx @@ -0,0 +1,8 @@ +import * as React from 'react'; +import type { LocalJSXCommandContext } from '../../commands.js'; +import { SkillsMenu } from '../../components/skills/SkillsMenu.js'; +import type { LocalJSXCommandOnDone } from '../../types/command.js'; +export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext): Promise { + return ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkxvY2FsSlNYQ29tbWFuZENvbnRleHQiLCJTa2lsbHNNZW51IiwiTG9jYWxKU1hDb21tYW5kT25Eb25lIiwiY2FsbCIsIm9uRG9uZSIsImNvbnRleHQiLCJQcm9taXNlIiwiUmVhY3ROb2RlIiwib3B0aW9ucyIsImNvbW1hbmRzIl0sInNvdXJjZXMiOlsic2tpbGxzLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tICdyZWFjdCdcbmltcG9ydCB0eXBlIHsgTG9jYWxKU1hDb21tYW5kQ29udGV4dCB9IGZyb20gJy4uLy4uL2NvbW1hbmRzLmpzJ1xuaW1wb3J0IHsgU2tpbGxzTWVudSB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvc2tpbGxzL1NraWxsc01lbnUuanMnXG5pbXBvcnQgdHlwZSB7IExvY2FsSlNYQ29tbWFuZE9uRG9uZSB9IGZyb20gJy4uLy4uL3R5cGVzL2NvbW1hbmQuanMnXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBjYWxsKFxuICBvbkRvbmU6IExvY2FsSlNYQ29tbWFuZE9uRG9uZSxcbiAgY29udGV4dDogTG9jYWxKU1hDb21tYW5kQ29udGV4dCxcbik6IFByb21pc2U8UmVhY3QuUmVhY3ROb2RlPiB7XG4gIHJldHVybiA8U2tpbGxzTWVudSBvbkV4aXQ9e29uRG9uZX0gY29tbWFuZHM9e2NvbnRleHQub3B0aW9ucy5jb21tYW5kc30gLz5cbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLQSxLQUFLLE1BQU0sT0FBTztBQUM5QixjQUFjQyxzQkFBc0IsUUFBUSxtQkFBbUI7QUFDL0QsU0FBU0MsVUFBVSxRQUFRLHVDQUF1QztBQUNsRSxjQUFjQyxxQkFBcUIsUUFBUSx3QkFBd0I7QUFFbkUsT0FBTyxlQUFlQyxJQUFJQSxDQUN4QkMsTUFBTSxFQUFFRixxQkFBcUIsRUFDN0JHLE9BQU8sRUFBRUwsc0JBQXNCLENBQ2hDLEVBQUVNLE9BQU8sQ0FBQ1AsS0FBSyxDQUFDUSxTQUFTLENBQUMsQ0FBQztFQUMxQixPQUFPLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDSCxNQUFNLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQ0MsT0FBTyxDQUFDRyxPQUFPLENBQUNDLFFBQVEsQ0FBQyxHQUFHO0FBQzNFIiwiaWdub3JlTGlzdCI6W119 \ No newline at end of file diff --git a/src/commands/stickers/index.ts b/src/commands/stickers/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..ebca4530d310d91a8a3ee8dbfaa22800c931cd27 --- /dev/null +++ b/src/commands/stickers/index.ts @@ -0,0 +1,11 @@ +import type { Command } from '../../commands.js' + +const stickers = { + type: 'local', + name: 'stickers', + description: 'Order Claude Code stickers', + supportsNonInteractive: false, + load: () => import('./stickers.js'), +} satisfies Command + +export default stickers diff --git a/src/commands/stickers/stickers.ts b/src/commands/stickers/stickers.ts new file mode 100644 index 0000000000000000000000000000000000000000..ede51931ec6954866ca4e835ad42c0abc2543797 --- /dev/null +++ b/src/commands/stickers/stickers.ts @@ -0,0 +1,16 @@ +import type { LocalCommandResult } from '../../types/command.js' +import { openBrowser } from '../../utils/browser.js' + +export async function call(): Promise { + const url = 'https://www.stickermule.com/claudecode' + const success = await openBrowser(url) + + if (success) { + return { type: 'text', value: 'Opening sticker page in browser…' } + } else { + return { + type: 'text', + value: `Failed to open browser. Visit: ${url}`, + } + } +} diff --git a/src/commands/tag/index.ts b/src/commands/tag/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..8d0bd659b5208aad80296d4afb93b9aef57f8aa2 --- /dev/null +++ b/src/commands/tag/index.ts @@ -0,0 +1,12 @@ +import type { Command } from '../../commands.js' + +const tag = { + type: 'local-jsx', + name: 'tag', + description: 'Toggle a searchable tag on the current session', + isEnabled: () => process.env.USER_TYPE === 'ant', + argumentHint: '', + load: () => import('./tag.js'), +} satisfies Command + +export default tag diff --git a/src/commands/tag/tag.tsx b/src/commands/tag/tag.tsx new file mode 100644 index 0000000000000000000000000000000000000000..3809a995153c34a7f4af9d67b18a82ff5fcd2bfb --- /dev/null +++ b/src/commands/tag/tag.tsx @@ -0,0 +1,215 @@ +import { c as _c } from "react/compiler-runtime"; +import chalk from 'chalk'; +import type { UUID } from 'crypto'; +import * as React from 'react'; +import { getSessionId } from '../../bootstrap/state.js'; +import type { CommandResultDisplay } from '../../commands.js'; +import { Select } from '../../components/CustomSelect/select.js'; +import { Dialog } from '../../components/design-system/Dialog.js'; +import { COMMON_HELP_ARGS, COMMON_INFO_ARGS } from '../../constants/xml.js'; +import { Box, Text } from '../../ink.js'; +import { logEvent } from '../../services/analytics/index.js'; +import type { LocalJSXCommandOnDone } from '../../types/command.js'; +import { recursivelySanitizeUnicode } from '../../utils/sanitization.js'; +import { getCurrentSessionTag, getTranscriptPath, saveTag } from '../../utils/sessionStorage.js'; +function ConfirmRemoveTag(t0) { + const $ = _c(11); + const { + tagName, + onConfirm, + onCancel + } = t0; + const t1 = `Current tag: #${tagName}`; + let t2; + if ($[0] === Symbol.for("react.memo_cache_sentinel")) { + t2 = This will remove the tag from the current session.; + $[0] = t2; + } else { + t2 = $[0]; + } + let t3; + if ($[1] !== onCancel || $[2] !== onConfirm) { + t3 = value => value === "yes" ? onConfirm() : onCancel(); + $[1] = onCancel; + $[2] = onConfirm; + $[3] = t3; + } else { + t3 = $[3]; + } + let t4; + if ($[4] === Symbol.for("react.memo_cache_sentinel")) { + t4 = [{ + label: "Yes, remove tag", + value: "yes" + }, { + label: "No, keep tag", + value: "no" + }]; + $[4] = t4; + } else { + t4 = $[4]; + } + let t5; + if ($[5] !== t3) { + t5 = {t2} { + bb61: switch (value) { + case "install": + { + handleInstall(); + break bb61; + } + case "tmux": + { + handleUseTmux(); + break bb61; + } + case "cancel": + { + onDone("cancelled"); + } + } + }} onCancel={() => onDone("cancelled")} />; + } + function renderInstalling() { + return Installing it2 using {packageManager}…This may take a moment.; + } + function renderInstallFailed() { + const options_0 = [{ + label: "Try again", + value: "retry", + description: "Retry the installation" + }]; + if (tmuxAvailable) { + options_0.push({ + label: "Use tmux instead", + value: "tmux", + description: "Falls back to tmux for teammate panes" + }); + } + options_0.push({ + label: "Cancel", + value: "cancel", + description: "Skip teammate spawning for now" + }); + return Installation failed{error && {error}}You can try installing manually:{" "}{packageManager === "uvx" ? "uv tool install it2" : packageManager === "pipx" ? "pipx install it2" : "pip install --user it2"} { + bb115: switch (value_1) { + case "retry": + { + setStep("verifying"); + verifyIt2Setup().then(result_1 => { + if (result_1.success) { + markIt2SetupComplete(); + setStep("success"); + setTimeout(onDone, 1500, "installed" as const); + } else { + setError(result_1.error || "Verification failed"); + setStep("failed"); + } + }); + break bb115; + } + case "tmux": + { + handleUseTmux(); + break bb115; + } + case "cancel": + { + onDone("cancelled"); + } + } + }} onCancel={() => onDone("cancelled")} />; + } + T1 = Pane; + t14 = "permission"; + T0 = Box; + t9 = "column"; + t10 = 1; + t11 = 1; + if ($[28] === Symbol.for("react.memo_cache_sentinel")) { + t12 = iTerm2 Split Pane Setup; + $[28] = t12; + } else { + t12 = $[28]; + } + t13 = renderContent(); + $[13] = error; + $[14] = handleInstall; + $[15] = handleUseTmux; + $[16] = onDone; + $[17] = packageManager; + $[18] = step; + $[19] = tmuxAvailable; + $[20] = T0; + $[21] = T1; + $[22] = t10; + $[23] = t11; + $[24] = t12; + $[25] = t13; + $[26] = t14; + $[27] = t9; + } else { + T0 = $[20]; + T1 = $[21]; + t10 = $[22]; + t11 = $[23]; + t12 = $[24]; + t13 = $[25]; + t14 = $[26]; + t9 = $[27]; + } + let t15; + if ($[29] !== exitState || $[30] !== step) { + t15 = step !== "installing" && step !== "verifying" && step !== "success" && {exitState.pending ? <>Press {exitState.keyName} again to exit : <>Esc to cancel}; + $[29] = exitState; + $[30] = step; + $[31] = t15; + } else { + t15 = $[31]; + } + let t16; + if ($[32] !== T0 || $[33] !== t10 || $[34] !== t11 || $[35] !== t12 || $[36] !== t13 || $[37] !== t15 || $[38] !== t9) { + t16 = {t12}{t13}{t15}; + $[32] = T0; + $[33] = t10; + $[34] = t11; + $[35] = t12; + $[36] = t13; + $[37] = t15; + $[38] = t9; + $[39] = t16; + } else { + t16 = $[39]; + } + let t17; + if ($[40] !== T1 || $[41] !== t14 || $[42] !== t16) { + t17 = {t16}; + $[40] = T1; + $[41] = t14; + $[42] = t16; + $[43] = t17; + } else { + t17 = $[43]; + } + return t17; +} +function _temp(line, i) { + return {line}; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","OptionWithDescription","Select","Pane","Spinner","useExitOnCtrlCDWithKeybindings","Box","Text","useInput","useKeybinding","detectPythonPackageManager","getPythonApiInstructions","installIt2","markIt2SetupComplete","PythonPackageManager","setPreferTmuxOverIterm2","verifyIt2Setup","SetupStep","Props","onDone","result","tmuxAvailable","It2SetupPrompt","t0","$","_c","step","setStep","packageManager","setPackageManager","error","setError","exitState","t1","t2","Symbol","for","then","pm","t3","handleCancel","t4","t5","context","isActive","t6","_input","key","return","success","setTimeout","const","t7","handleInstall","result_0","t8","handleUseTmux","T0","T1","t10","t11","t12","t13","t14","t9","renderContent","renderInitialPrompt","renderInstalling","renderInstallFailed","renderApiInstructions","renderVerifying","renderSuccess","renderFailed","options","label","value","description","push","bb61","options_0","value_0","bb89","instructions","map","_temp","options_1","value_1","bb115","result_1","t15","pending","keyName","t16","t17","line","i"],"sources":["It2SetupPrompt.tsx"],"sourcesContent":["import React, { useCallback, useEffect, useState } from 'react'\nimport {\n  type OptionWithDescription,\n  Select,\n} from '../../components/CustomSelect/index.js'\nimport { Pane } from '../../components/design-system/Pane.js'\nimport { Spinner } from '../../components/Spinner.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- enter to proceed through setup steps\nimport { Box, Text, useInput } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport {\n  detectPythonPackageManager,\n  getPythonApiInstructions,\n  installIt2,\n  markIt2SetupComplete,\n  type PythonPackageManager,\n  setPreferTmuxOverIterm2,\n  verifyIt2Setup,\n} from './backends/it2Setup.js'\n\ntype SetupStep =\n  | 'initial'\n  | 'installing'\n  | 'install-failed'\n  | 'verify-api'\n  | 'api-instructions'\n  | 'verifying'\n  | 'success'\n  | 'failed'\n\ntype Props = {\n  onDone: (result: 'installed' | 'use-tmux' | 'cancelled') => void\n  tmuxAvailable: boolean\n}\n\nexport function It2SetupPrompt({\n  onDone,\n  tmuxAvailable,\n}: Props): React.ReactNode {\n  const [step, setStep] = useState<SetupStep>('initial')\n  const [packageManager, setPackageManager] =\n    useState<PythonPackageManager | null>(null)\n  const [error, setError] = useState<string | null>(null)\n  const exitState = useExitOnCtrlCDWithKeybindings()\n\n  // Detect package manager on mount\n  useEffect(() => {\n    void detectPythonPackageManager().then(pm => {\n      setPackageManager(pm)\n    })\n  }, [])\n\n  const handleCancel = useCallback(() => {\n    onDone('cancelled')\n  }, [onDone])\n\n  useKeybinding('confirm:no', handleCancel, {\n    context: 'Confirmation',\n    isActive: step !== 'installing' && step !== 'verifying',\n  })\n\n  // Handle keyboard input for verification step\n  useInput((_input, key) => {\n    if (step === 'api-instructions' && key.return) {\n      setStep('verifying')\n      void verifyIt2Setup().then(result => {\n        if (result.success) {\n          markIt2SetupComplete()\n          setStep('success')\n          setTimeout(onDone, 1500, 'installed' as const)\n        } else {\n          setError(result.error || 'Verification failed')\n          setStep('failed')\n        }\n      })\n    }\n  })\n\n  // Handle installation\n  async function handleInstall(): Promise<void> {\n    if (!packageManager) {\n      setError('No Python package manager found (uvx, pipx, or pip)')\n      setStep('failed')\n      return\n    }\n\n    setStep('installing')\n    const result = await installIt2(packageManager)\n\n    if (result.success) {\n      // Show Python API instructions\n      setStep('api-instructions')\n    } else {\n      setError(result.error || 'Installation failed')\n      setStep('install-failed')\n    }\n  }\n\n  // Handle using tmux instead\n  function handleUseTmux(): void {\n    setPreferTmuxOverIterm2(true)\n    onDone('use-tmux')\n  }\n\n  // Render based on current step\n  const renderContent = (): React.ReactNode => {\n    switch (step) {\n      case 'initial':\n        return renderInitialPrompt()\n      case 'installing':\n        return renderInstalling()\n      case 'install-failed':\n        return renderInstallFailed()\n      case 'api-instructions':\n        return renderApiInstructions()\n      case 'verifying':\n        return renderVerifying()\n      case 'success':\n        return renderSuccess()\n      case 'failed':\n        return renderFailed()\n      default:\n        return null\n    }\n  }\n\n  function renderInitialPrompt(): React.ReactNode {\n    const options: OptionWithDescription<string>[] = [\n      {\n        label: 'Install it2 now',\n        value: 'install',\n        description: packageManager\n          ? `Uses ${packageManager} to install the it2 CLI tool`\n          : 'Requires Python (uvx, pipx, or pip)',\n      },\n    ]\n\n    if (tmuxAvailable) {\n      options.push({\n        label: 'Use tmux instead',\n        value: 'tmux',\n        description: 'Opens teammates in a separate tmux session',\n      })\n    }\n\n    options.push({\n      label: 'Cancel',\n      value: 'cancel',\n      description: 'Skip teammate spawning for now',\n    })\n\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text>\n          To use native iTerm2 split panes for teammates, you need the{' '}\n          <Text bold>it2</Text> CLI tool.\n        </Text>\n        <Text dimColor>\n          This enables teammates to appear as split panes within your current\n          window.\n        </Text>\n        <Box marginTop={1}>\n          <Select\n            options={options}\n            onChange={value => {\n              switch (value) {\n                case 'install':\n                  void handleInstall()\n                  break\n                case 'tmux':\n                  handleUseTmux()\n                  break\n                case 'cancel':\n                  onDone('cancelled')\n                  break\n              }\n            }}\n            onCancel={() => onDone('cancelled')}\n          />\n        </Box>\n      </Box>\n    )\n  }\n\n  function renderInstalling(): React.ReactNode {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Box>\n          <Spinner />\n          <Text> Installing it2 using {packageManager}…</Text>\n        </Box>\n        <Text dimColor>This may take a moment.</Text>\n      </Box>\n    )\n  }\n\n  function renderInstallFailed(): React.ReactNode {\n    const options: OptionWithDescription<string>[] = [\n      {\n        label: 'Try again',\n        value: 'retry',\n        description: 'Retry the installation',\n      },\n    ]\n\n    if (tmuxAvailable) {\n      options.push({\n        label: 'Use tmux instead',\n        value: 'tmux',\n        description: 'Falls back to tmux for teammate panes',\n      })\n    }\n\n    options.push({\n      label: 'Cancel',\n      value: 'cancel',\n      description: 'Skip teammate spawning for now',\n    })\n\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"error\">Installation failed</Text>\n        {error && <Text dimColor>{error}</Text>}\n        <Text dimColor>\n          You can try installing manually:{' '}\n          {packageManager === 'uvx'\n            ? 'uv tool install it2'\n            : packageManager === 'pipx'\n              ? 'pipx install it2'\n              : 'pip install --user it2'}\n        </Text>\n        <Box marginTop={1}>\n          <Select\n            options={options}\n            onChange={value => {\n              switch (value) {\n                case 'retry':\n                  void handleInstall()\n                  break\n                case 'tmux':\n                  handleUseTmux()\n                  break\n                case 'cancel':\n                  onDone('cancelled')\n                  break\n              }\n            }}\n            onCancel={() => onDone('cancelled')}\n          />\n        </Box>\n      </Box>\n    )\n  }\n\n  function renderApiInstructions(): React.ReactNode {\n    const instructions = getPythonApiInstructions()\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"success\">✓ it2 installed successfully</Text>\n        <Box flexDirection=\"column\" marginTop={1}>\n          {instructions.map((line, i) => (\n            <Text key={i}>{line}</Text>\n          ))}\n        </Box>\n        <Box marginTop={1}>\n          <Text dimColor>Press Enter when ready to verify…</Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  function renderVerifying(): React.ReactNode {\n    return (\n      <Box>\n        <Spinner />\n        <Text> Verifying it2 can communicate with iTerm2…</Text>\n      </Box>\n    )\n  }\n\n  function renderSuccess(): React.ReactNode {\n    return (\n      <Box flexDirection=\"column\">\n        <Text color=\"success\">✓ iTerm2 split pane support is ready</Text>\n        <Text dimColor>Teammates will now appear as split panes.</Text>\n      </Box>\n    )\n  }\n\n  function renderFailed(): React.ReactNode {\n    const options: OptionWithDescription<string>[] = [\n      {\n        label: 'Try again',\n        value: 'retry',\n        description: 'Verify the connection again',\n      },\n    ]\n\n    if (tmuxAvailable) {\n      options.push({\n        label: 'Use tmux instead',\n        value: 'tmux',\n        description: 'Falls back to tmux for teammate panes',\n      })\n    }\n\n    options.push({\n      label: 'Cancel',\n      value: 'cancel',\n      description: 'Skip teammate spawning for now',\n    })\n\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"error\">Verification failed</Text>\n        {error && <Text dimColor>{error}</Text>}\n        <Text>Make sure:</Text>\n        <Box flexDirection=\"column\" paddingLeft={2}>\n          <Text>· Python API is enabled in iTerm2 preferences</Text>\n          <Text>· You may need to restart iTerm2 after enabling</Text>\n        </Box>\n        <Box marginTop={1}>\n          <Select\n            options={options}\n            onChange={value => {\n              switch (value) {\n                case 'retry':\n                  setStep('verifying')\n                  void verifyIt2Setup().then(result => {\n                    if (result.success) {\n                      markIt2SetupComplete()\n                      setStep('success')\n                      setTimeout(onDone, 1500, 'installed' as const)\n                    } else {\n                      setError(result.error || 'Verification failed')\n                      setStep('failed')\n                    }\n                  })\n                  break\n                case 'tmux':\n                  handleUseTmux()\n                  break\n                case 'cancel':\n                  onDone('cancelled')\n                  break\n              }\n            }}\n            onCancel={() => onDone('cancelled')}\n          />\n        </Box>\n      </Box>\n    )\n  }\n\n  return (\n    <Pane color=\"permission\">\n      <Box flexDirection=\"column\" gap={1} paddingBottom={1}>\n        <Text bold color=\"permission\">\n          iTerm2 Split Pane Setup\n        </Text>\n        {renderContent()}\n        {step !== 'installing' &&\n          step !== 'verifying' &&\n          step !== 'success' && (\n            <Text dimColor italic>\n              {exitState.pending ? (\n                <>Press {exitState.keyName} again to exit</>\n              ) : (\n                <>Esc to cancel</>\n              )}\n            </Text>\n          )}\n      </Box>\n    </Pane>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/utils/swarm/constants.ts b/src/utils/swarm/constants.ts new file mode 100644 index 0000000000000000000000000000000000000000..8ebfb194b81d78d6fec32e8de76e5968c3b7177b --- /dev/null +++ b/src/utils/swarm/constants.ts @@ -0,0 +1,33 @@ +export const TEAM_LEAD_NAME = 'team-lead' +export const SWARM_SESSION_NAME = 'claude-swarm' +export const SWARM_VIEW_WINDOW_NAME = 'swarm-view' +export const TMUX_COMMAND = 'tmux' +export const HIDDEN_SESSION_NAME = 'claude-hidden' + +/** + * Gets the socket name for external swarm sessions (when user is not in tmux). + * Uses a separate socket to isolate swarm operations from user's tmux sessions. + * Includes PID to ensure multiple Claude instances don't conflict. + */ +export function getSwarmSocketName(): string { + return `claude-swarm-${process.pid}` +} + +/** + * Environment variable to override the command used to spawn teammate instances. + * If not set, defaults to process.execPath (the current Claude binary). + * This allows customization for different environments or testing. + */ +export const TEAMMATE_COMMAND_ENV_VAR = 'CLAUDE_CODE_TEAMMATE_COMMAND' + +/** + * Environment variable set on spawned teammates to indicate their assigned color. + * Used for colored output and pane identification. + */ +export const TEAMMATE_COLOR_ENV_VAR = 'CLAUDE_CODE_AGENT_COLOR' + +/** + * Environment variable set on spawned teammates to require plan mode before implementation. + * When set to 'true', teammates must enter plan mode and get approval before writing code. + */ +export const PLAN_MODE_REQUIRED_ENV_VAR = 'CLAUDE_CODE_PLAN_MODE_REQUIRED' diff --git a/src/utils/swarm/inProcessRunner.ts b/src/utils/swarm/inProcessRunner.ts new file mode 100644 index 0000000000000000000000000000000000000000..c85d959e1ad2ccc4ff3c8ba99cb5b725ba746755 --- /dev/null +++ b/src/utils/swarm/inProcessRunner.ts @@ -0,0 +1,1552 @@ +/** + * In-process teammate runner + * + * Wraps runAgent() for in-process teammates, providing: + * - AsyncLocalStorage-based context isolation via runWithTeammateContext() + * - Progress tracking and AppState updates + * - Idle notification to leader when complete + * - Plan mode approval flow support + * - Cleanup on completion or abort + */ + +import { feature } from 'bun:bundle' +import type { ContentBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs' +import { getSystemPrompt } from '../../constants/prompts.js' +import { TEAMMATE_MESSAGE_TAG } from '../../constants/xml.js' +import type { CanUseToolFn } from '../../hooks/useCanUseTool.js' +import { + processMailboxPermissionResponse, + registerPermissionCallback, + unregisterPermissionCallback, +} from '../../hooks/useSwarmPermissionPoller.js' +import { + type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + logEvent, +} from '../../services/analytics/index.js' +import { getAutoCompactThreshold } from '../../services/compact/autoCompact.js' +import { + buildPostCompactMessages, + compactConversation, + ERROR_MESSAGE_USER_ABORT, +} from '../../services/compact/compact.js' +import { resetMicrocompactState } from '../../services/compact/microCompact.js' +import type { AppState } from '../../state/AppState.js' +import type { Tool, ToolUseContext } from '../../Tool.js' +import { appendTeammateMessage } from '../../tasks/InProcessTeammateTask/InProcessTeammateTask.js' +import type { + InProcessTeammateTaskState, + TeammateIdentity, +} from '../../tasks/InProcessTeammateTask/types.js' +import { appendCappedMessage } from '../../tasks/InProcessTeammateTask/types.js' +import { + createActivityDescriptionResolver, + createProgressTracker, + getProgressUpdate, + updateProgressFromMessage, +} from '../../tasks/LocalAgentTask/LocalAgentTask.js' +import type { CustomAgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js' +import { runAgent } from '../../tools/AgentTool/runAgent.js' +import { awaitClassifierAutoApproval } from '../../tools/BashTool/bashPermissions.js' +import { BASH_TOOL_NAME } from '../../tools/BashTool/toolName.js' +import { SEND_MESSAGE_TOOL_NAME } from '../../tools/SendMessageTool/constants.js' +import { TASK_CREATE_TOOL_NAME } from '../../tools/TaskCreateTool/constants.js' +import { TASK_GET_TOOL_NAME } from '../../tools/TaskGetTool/constants.js' +import { TASK_LIST_TOOL_NAME } from '../../tools/TaskListTool/constants.js' +import { TASK_UPDATE_TOOL_NAME } from '../../tools/TaskUpdateTool/constants.js' +import { TEAM_CREATE_TOOL_NAME } from '../../tools/TeamCreateTool/constants.js' +import { TEAM_DELETE_TOOL_NAME } from '../../tools/TeamDeleteTool/constants.js' +import type { Message } from '../../types/message.js' +import type { PermissionDecision } from '../../types/permissions.js' +import { + createAssistantAPIErrorMessage, + createUserMessage, +} from '../../utils/messages.js' +import { evictTaskOutput } from '../../utils/task/diskOutput.js' +import { evictTerminalTask } from '../../utils/task/framework.js' +import { tokenCountWithEstimation } from '../../utils/tokens.js' +import { createAbortController } from '../abortController.js' +import { type AgentContext, runWithAgentContext } from '../agentContext.js' +import { count } from '../array.js' +import { logForDebugging } from '../debug.js' +import { cloneFileStateCache } from '../fileStateCache.js' +import { + SUBAGENT_REJECT_MESSAGE, + SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX, +} from '../messages.js' +import type { ModelAlias } from '../model/aliases.js' +import { + applyPermissionUpdates, + persistPermissionUpdates, +} from '../permissions/PermissionUpdate.js' +import type { PermissionUpdate } from '../permissions/PermissionUpdateSchema.js' +import { hasPermissionsToUseTool } from '../permissions/permissions.js' +import { emitTaskTerminatedSdk } from '../sdkEventQueue.js' +import { sleep } from '../sleep.js' +import { jsonStringify } from '../slowOperations.js' +import { asSystemPrompt } from '../systemPromptType.js' +import { claimTask, listTasks, type Task, updateTask } from '../tasks.js' +import type { TeammateContext } from '../teammateContext.js' +import { runWithTeammateContext } from '../teammateContext.js' +import { + createIdleNotification, + getLastPeerDmSummary, + isPermissionResponse, + isShutdownRequest, + markMessageAsReadByIndex, + readMailbox, + writeToMailbox, +} from '../teammateMailbox.js' +import { unregisterAgent as unregisterPerfettoAgent } from '../telemetry/perfettoTracing.js' +import { createContentReplacementState } from '../toolResultStorage.js' +import { TEAM_LEAD_NAME } from './constants.js' +import { + getLeaderSetToolPermissionContext, + getLeaderToolUseConfirmQueue, +} from './leaderPermissionBridge.js' +import { + createPermissionRequest, + sendPermissionRequestViaMailbox, +} from './permissionSync.js' +import { TEAMMATE_SYSTEM_PROMPT_ADDENDUM } from './teammatePromptAddendum.js' + +type SetAppStateFn = (updater: (prev: AppState) => AppState) => void + +const PERMISSION_POLL_INTERVAL_MS = 500 + +/** + * Creates a canUseTool function for in-process teammates that properly resolves + * 'ask' permissions via the UI rather than treating them as denials. + * + * Always uses the leader's ToolUseConfirm dialog with a worker badge when + * the bridge is available, giving teammates the same tool-specific UI + * (BashPermissionRequest, FileEditToolDiff, etc.) as the leader's own tools. + * + * Falls back to the mailbox system when the bridge is unavailable: + * sends a permission request to the leader's inbox, waits for the response + * in the teammate's own mailbox. + */ +function createInProcessCanUseTool( + identity: TeammateIdentity, + abortController: AbortController, + onPermissionWaitMs?: (waitMs: number) => void, +): CanUseToolFn { + return async ( + tool, + input, + toolUseContext, + assistantMessage, + toolUseID, + forceDecision, + ) => { + const result = + forceDecision ?? + (await hasPermissionsToUseTool( + tool, + input, + toolUseContext, + assistantMessage, + toolUseID, + )) + + // Pass through allow/deny decisions directly + if (result.behavior !== 'ask') { + return result + } + + // For bash commands, try classifier auto-approval before showing leader dialog. + // Agents await the classifier result (rather than racing it against user + // interaction like the main agent). + if ( + feature('BASH_CLASSIFIER') && + tool.name === BASH_TOOL_NAME && + result.pendingClassifierCheck + ) { + const classifierDecision = await awaitClassifierAutoApproval( + result.pendingClassifierCheck, + abortController.signal, + toolUseContext.options.isNonInteractiveSession, + ) + if (classifierDecision) { + return { + behavior: 'allow', + updatedInput: input as Record, + decisionReason: classifierDecision, + } + } + } + + // Check if aborted before showing UI + if (abortController.signal.aborted) { + return { behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE } + } + + const appState = toolUseContext.getAppState() + + const description = await (tool as Tool).description(input as never, { + isNonInteractiveSession: toolUseContext.options.isNonInteractiveSession, + toolPermissionContext: appState.toolPermissionContext, + tools: toolUseContext.options.tools, + }) + + if (abortController.signal.aborted) { + return { behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE } + } + + const setToolUseConfirmQueue = getLeaderToolUseConfirmQueue() + + // Standard path: use ToolUseConfirm dialog with worker badge + if (setToolUseConfirmQueue) { + return new Promise(resolve => { + let decisionMade = false + const permissionStartMs = Date.now() + + // Report permission wait time to the caller so it can be + // subtracted from the displayed elapsed time. + const reportPermissionWait = () => { + onPermissionWaitMs?.(Date.now() - permissionStartMs) + } + + const onAbortListener = () => { + if (decisionMade) return + decisionMade = true + reportPermissionWait() + resolve({ behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE }) + setToolUseConfirmQueue(queue => + queue.filter(item => item.toolUseID !== toolUseID), + ) + } + + abortController.signal.addEventListener('abort', onAbortListener, { + once: true, + }) + + setToolUseConfirmQueue(queue => [ + ...queue, + { + assistantMessage, + tool: tool as Tool, + description, + input, + toolUseContext, + toolUseID, + permissionResult: result, + permissionPromptStartTimeMs: permissionStartMs, + workerBadge: identity.color + ? { name: identity.agentName, color: identity.color } + : undefined, + onUserInteraction() { + // No-op for teammates (no classifier auto-approval) + }, + onAbort() { + if (decisionMade) return + decisionMade = true + abortController.signal.removeEventListener( + 'abort', + onAbortListener, + ) + reportPermissionWait() + resolve({ behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE }) + }, + async onAllow( + updatedInput: Record, + permissionUpdates: PermissionUpdate[], + feedback?: string, + contentBlocks?: ContentBlockParam[], + ) { + if (decisionMade) return + decisionMade = true + abortController.signal.removeEventListener( + 'abort', + onAbortListener, + ) + reportPermissionWait() + persistPermissionUpdates(permissionUpdates) + // Write back permission updates to the leader's shared context + if (permissionUpdates.length > 0) { + const setToolPermissionContext = + getLeaderSetToolPermissionContext() + if (setToolPermissionContext) { + const currentAppState = toolUseContext.getAppState() + const updatedContext = applyPermissionUpdates( + currentAppState.toolPermissionContext, + permissionUpdates, + ) + // Preserve the leader's mode to prevent workers' + // transformed 'acceptEdits' context from leaking back + // to the coordinator + setToolPermissionContext(updatedContext, { + preserveMode: true, + }) + } + } + const trimmedFeedback = feedback?.trim() + resolve({ + behavior: 'allow', + updatedInput, + userModified: false, + acceptFeedback: trimmedFeedback || undefined, + ...(contentBlocks && + contentBlocks.length > 0 && { contentBlocks }), + }) + }, + onReject(feedback?: string, contentBlocks?: ContentBlockParam[]) { + if (decisionMade) return + decisionMade = true + abortController.signal.removeEventListener( + 'abort', + onAbortListener, + ) + reportPermissionWait() + const message = feedback + ? `${SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX}${feedback}` + : SUBAGENT_REJECT_MESSAGE + resolve({ behavior: 'ask', message, contentBlocks }) + }, + async recheckPermission() { + if (decisionMade) return + const freshResult = await hasPermissionsToUseTool( + tool, + input, + toolUseContext, + assistantMessage, + toolUseID, + ) + if (freshResult.behavior === 'allow') { + decisionMade = true + abortController.signal.removeEventListener( + 'abort', + onAbortListener, + ) + reportPermissionWait() + setToolUseConfirmQueue(queue => + queue.filter(item => item.toolUseID !== toolUseID), + ) + resolve({ + ...freshResult, + updatedInput: input, + userModified: false, + }) + } + }, + }, + ]) + }) + } + + // Fallback: use mailbox system when leader UI queue is unavailable + return new Promise(resolve => { + const request = createPermissionRequest({ + toolName: (tool as Tool).name, + toolUseId: toolUseID, + input, + description, + permissionSuggestions: result.suggestions, + workerId: identity.agentId, + workerName: identity.agentName, + workerColor: identity.color, + teamName: identity.teamName, + }) + + // Register callback to be invoked when the leader responds + registerPermissionCallback({ + requestId: request.id, + toolUseId: toolUseID, + onAllow( + updatedInput: Record | undefined, + permissionUpdates: PermissionUpdate[], + _feedback?: string, + contentBlocks?: ContentBlockParam[], + ) { + cleanup() + persistPermissionUpdates(permissionUpdates) + const finalInput = + updatedInput && Object.keys(updatedInput).length > 0 + ? updatedInput + : input + resolve({ + behavior: 'allow', + updatedInput: finalInput, + userModified: false, + ...(contentBlocks && contentBlocks.length > 0 && { contentBlocks }), + }) + }, + onReject(feedback?: string, contentBlocks?: ContentBlockParam[]) { + cleanup() + const message = feedback + ? `${SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX}${feedback}` + : SUBAGENT_REJECT_MESSAGE + resolve({ behavior: 'ask', message, contentBlocks }) + }, + }) + + // Send request to leader's mailbox + void sendPermissionRequestViaMailbox(request) + + // Poll teammate's mailbox for the response + const pollInterval = setInterval( + async (abortController, cleanup, resolve, identity, request) => { + if (abortController.signal.aborted) { + cleanup() + resolve({ behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE }) + return + } + + const allMessages = await readMailbox( + identity.agentName, + identity.teamName, + ) + for (let i = 0; i < allMessages.length; i++) { + const msg = allMessages[i] + if (msg && !msg.read) { + const parsed = isPermissionResponse(msg.text) + if (parsed && parsed.request_id === request.id) { + await markMessageAsReadByIndex( + identity.agentName, + identity.teamName, + i, + ) + if (parsed.subtype === 'success') { + processMailboxPermissionResponse({ + requestId: parsed.request_id, + decision: 'approved', + updatedInput: parsed.response?.updated_input, + permissionUpdates: parsed.response?.permission_updates, + }) + } else { + processMailboxPermissionResponse({ + requestId: parsed.request_id, + decision: 'rejected', + feedback: parsed.error, + }) + } + return // Callback already resolves the promise + } + } + } + }, + PERMISSION_POLL_INTERVAL_MS, + abortController, + cleanup, + resolve, + identity, + request, + ) + + const onAbortListener = () => { + cleanup() + resolve({ behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE }) + } + + abortController.signal.addEventListener('abort', onAbortListener, { + once: true, + }) + + function cleanup() { + clearInterval(pollInterval) + unregisterPermissionCallback(request.id) + abortController.signal.removeEventListener('abort', onAbortListener) + } + }) + } +} + +/** + * Formats a message as XML for injection into the conversation. + * This ensures the model sees messages in the same format as tmux teammates. + */ +function formatAsTeammateMessage( + from: string, + content: string, + color?: string, + summary?: string, +): string { + const colorAttr = color ? ` color="${color}"` : '' + const summaryAttr = summary ? ` summary="${summary}"` : '' + return `<${TEAMMATE_MESSAGE_TAG} teammate_id="${from}"${colorAttr}${summaryAttr}>\n${content}\n` +} + +/** + * Configuration for running an in-process teammate. + */ +export type InProcessRunnerConfig = { + /** Teammate identity for context */ + identity: TeammateIdentity + /** Task ID in AppState */ + taskId: string + /** Initial prompt for the teammate */ + prompt: string + /** Optional agent definition (for specialized agents) */ + agentDefinition?: CustomAgentDefinition + /** Teammate context for AsyncLocalStorage */ + teammateContext: TeammateContext + /** Parent's tool use context */ + toolUseContext: ToolUseContext + /** Abort controller linked to parent */ + abortController: AbortController + /** Optional model override for this teammate */ + model?: string + /** Optional system prompt override for this teammate */ + systemPrompt?: string + /** How to apply the system prompt: 'replace' or 'append' to default */ + systemPromptMode?: 'default' | 'replace' | 'append' + /** Tool permissions to auto-allow for this teammate */ + allowedTools?: string[] + /** Whether this teammate can show permission prompts for unlisted tools. + * When false (default), unlisted tools are auto-denied. */ + allowPermissionPrompts?: boolean + /** Short description of the task (used as summary for the initial prompt header) */ + description?: string + /** request_id of the API call that spawned this teammate, for lineage + * tracing on tengu_api_* events. */ + invokingRequestId?: string +} + +/** + * Result from running an in-process teammate. + */ +export type InProcessRunnerResult = { + /** Whether the run completed successfully */ + success: boolean + /** Error message if failed */ + error?: string + /** Messages produced by the agent */ + messages: Message[] +} + +/** + * Updates task state in AppState. + */ +function updateTaskState( + taskId: string, + updater: (task: InProcessTeammateTaskState) => InProcessTeammateTaskState, + setAppState: SetAppStateFn, +): void { + setAppState(prev => { + const task = prev.tasks[taskId] + if (!task || task.type !== 'in_process_teammate') { + return prev + } + const updated = updater(task) + if (updated === task) { + return prev + } + return { + ...prev, + tasks: { + ...prev.tasks, + [taskId]: updated, + }, + } + }) +} + +/** + * Sends a message to the leader's file-based mailbox. + * Uses the same mailbox system as tmux teammates for consistency. + */ +async function sendMessageToLeader( + from: string, + text: string, + color: string | undefined, + teamName: string, +): Promise { + await writeToMailbox( + TEAM_LEAD_NAME, + { + from, + text, + timestamp: new Date().toISOString(), + color, + }, + teamName, + ) +} + +/** + * Sends idle notification to the leader via file-based mailbox. + * Uses agentName (not agentId) for consistency with process-based teammates. + */ +async function sendIdleNotification( + agentName: string, + agentColor: string | undefined, + teamName: string, + options?: { + idleReason?: 'available' | 'interrupted' | 'failed' + summary?: string + completedTaskId?: string + completedStatus?: 'resolved' | 'blocked' | 'failed' + failureReason?: string + }, +): Promise { + const notification = createIdleNotification(agentName, options) + + await sendMessageToLeader( + agentName, + jsonStringify(notification), + agentColor, + teamName, + ) +} + +/** + * Find an available task from the team's task list. + * A task is available if it's pending, has no owner, and is not blocked. + */ +function findAvailableTask(tasks: Task[]): Task | undefined { + const unresolvedTaskIds = new Set( + tasks.filter(t => t.status !== 'completed').map(t => t.id), + ) + + return tasks.find(task => { + if (task.status !== 'pending') return false + if (task.owner) return false + return task.blockedBy.every(id => !unresolvedTaskIds.has(id)) + }) +} + +/** + * Format a task as a prompt for the teammate to work on. + */ +function formatTaskAsPrompt(task: Task): string { + let prompt = `Complete all open tasks. Start with task #${task.id}: \n\n ${task.subject}` + + if (task.description) { + prompt += `\n\n${task.description}` + } + + return prompt +} + +/** + * Try to claim an available task from the team's task list. + * Returns the formatted prompt if a task was claimed, or undefined if none available. + */ +async function tryClaimNextTask( + taskListId: string, + agentName: string, +): Promise { + try { + const tasks = await listTasks(taskListId) + const availableTask = findAvailableTask(tasks) + + if (!availableTask) { + return undefined + } + + const result = await claimTask(taskListId, availableTask.id, agentName) + + if (!result.success) { + logForDebugging( + `[inProcessRunner] Failed to claim task #${availableTask.id}: ${result.reason}`, + ) + return undefined + } + + // Also set status to in_progress so the UI reflects it immediately + await updateTask(taskListId, availableTask.id, { status: 'in_progress' }) + + logForDebugging( + `[inProcessRunner] Claimed task #${availableTask.id}: ${availableTask.subject}`, + ) + + return formatTaskAsPrompt(availableTask) + } catch (err) { + logForDebugging(`[inProcessRunner] Error checking task list: ${err}`) + return undefined + } +} + +/** + * Result of waiting for messages. + */ +type WaitResult = + | { + type: 'shutdown_request' + request: ReturnType + originalMessage: string + } + | { + type: 'new_message' + message: string + from: string + color?: string + summary?: string + } + | { + type: 'aborted' + } + +/** + * Waits for new prompts or shutdown request. + * Polls the teammate's mailbox every 500ms, checking for: + * - Shutdown request from leader (returned to caller for model decision) + * - New messages/prompts from leader + * - Abort signal + * + * This keeps the teammate alive in 'idle' state instead of terminating. + * Does NOT auto-approve shutdown - the model should make that decision. + */ +async function waitForNextPromptOrShutdown( + identity: TeammateIdentity, + abortController: AbortController, + taskId: string, + getAppState: () => AppState, + setAppState: SetAppStateFn, + taskListId: string, +): Promise { + const POLL_INTERVAL_MS = 500 + + logForDebugging( + `[inProcessRunner] ${identity.agentName} starting poll loop (abort=${abortController.signal.aborted})`, + ) + + let pollCount = 0 + while (!abortController.signal.aborted) { + // Check for in-memory pending messages on every iteration (from transcript viewing) + const appState = getAppState() + const task = appState.tasks[taskId] + if ( + task && + task.type === 'in_process_teammate' && + task.pendingUserMessages.length > 0 + ) { + const message = task.pendingUserMessages[0]! // Safe: checked length > 0 + // Pop the message from the queue + setAppState(prev => { + const prevTask = prev.tasks[taskId] + if (!prevTask || prevTask.type !== 'in_process_teammate') { + return prev + } + return { + ...prev, + tasks: { + ...prev.tasks, + [taskId]: { + ...prevTask, + pendingUserMessages: prevTask.pendingUserMessages.slice(1), + }, + }, + } + }) + logForDebugging( + `[inProcessRunner] ${identity.agentName} found pending user message (poll #${pollCount})`, + ) + return { + type: 'new_message', + message, + from: 'user', + } + } + + // Wait before next poll (skip on first iteration to check immediately) + if (pollCount > 0) { + await sleep(POLL_INTERVAL_MS) + } + pollCount++ + + // Check for abort + if (abortController.signal.aborted) { + logForDebugging( + `[inProcessRunner] ${identity.agentName} aborted while waiting (poll #${pollCount})`, + ) + return { type: 'aborted' } + } + + // Check for messages in mailbox + logForDebugging( + `[inProcessRunner] ${identity.agentName} poll #${pollCount}: checking mailbox`, + ) + try { + // Read all messages and scan unread for shutdown requests first. + // Shutdown requests are prioritized over regular messages to prevent + // starvation when peer-to-peer messages flood the queue. + const allMessages = await readMailbox( + identity.agentName, + identity.teamName, + ) + + // Scan all unread messages for shutdown requests (highest priority). + // readMailbox() already reads all messages from disk, so this scan + // adds only ~1-2ms of JSON parsing overhead. + let shutdownIndex = -1 + let shutdownParsed: ReturnType = null + for (let i = 0; i < allMessages.length; i++) { + const m = allMessages[i] + if (m && !m.read) { + const parsed = isShutdownRequest(m.text) + if (parsed) { + shutdownIndex = i + shutdownParsed = parsed + break + } + } + } + + if (shutdownIndex !== -1) { + const msg = allMessages[shutdownIndex]! + const skippedUnread = count( + allMessages.slice(0, shutdownIndex), + m => !m.read, + ) + logForDebugging( + `[inProcessRunner] ${identity.agentName} received shutdown request from ${shutdownParsed?.from} (prioritized over ${skippedUnread} unread messages)`, + ) + await markMessageAsReadByIndex( + identity.agentName, + identity.teamName, + shutdownIndex, + ) + return { + type: 'shutdown_request', + request: shutdownParsed, + originalMessage: msg.text, + } + } + + // No shutdown request found. Prioritize team-lead messages over peer + // messages — the leader represents user intent and coordination, so + // their messages should not be starved behind peer-to-peer chatter. + // Fall back to FIFO for peer messages. + let selectedIndex = -1 + + // Check for unread team-lead messages first + for (let i = 0; i < allMessages.length; i++) { + const m = allMessages[i] + if (m && !m.read && m.from === TEAM_LEAD_NAME) { + selectedIndex = i + break + } + } + + // Fall back to first unread message (any sender) + if (selectedIndex === -1) { + selectedIndex = allMessages.findIndex(m => !m.read) + } + + if (selectedIndex !== -1) { + const msg = allMessages[selectedIndex] + if (msg) { + logForDebugging( + `[inProcessRunner] ${identity.agentName} received new message from ${msg.from} (index ${selectedIndex})`, + ) + await markMessageAsReadByIndex( + identity.agentName, + identity.teamName, + selectedIndex, + ) + return { + type: 'new_message', + message: msg.text, + from: msg.from, + color: msg.color, + summary: msg.summary, + } + } + } + } catch (err) { + logForDebugging( + `[inProcessRunner] ${identity.agentName} poll error: ${err}`, + ) + // Continue polling even if one read fails + } + + // Check the team's task list for unclaimed tasks + const taskPrompt = await tryClaimNextTask(taskListId, identity.agentName) + if (taskPrompt) { + return { + type: 'new_message', + message: taskPrompt, + from: 'task-list', + } + } + } + + logForDebugging( + `[inProcessRunner] ${identity.agentName} exiting poll loop (abort=${abortController.signal.aborted}, polls=${pollCount})`, + ) + return { type: 'aborted' } +} + +/** + * Runs an in-process teammate with a continuous prompt loop. + * + * Executes runAgent() within the teammate's AsyncLocalStorage context, + * tracks progress, updates task state, sends idle notification on completion, + * then waits for new prompts or shutdown requests. + * + * Unlike background tasks, teammates stay alive and can receive multiple prompts. + * The loop only exits on abort or after shutdown is approved by the model. + * + * @param config - Runner configuration + * @returns Result with messages and success status + */ +export async function runInProcessTeammate( + config: InProcessRunnerConfig, +): Promise { + const { + identity, + taskId, + prompt, + description, + agentDefinition, + teammateContext, + toolUseContext, + abortController, + model, + systemPrompt, + systemPromptMode, + allowedTools, + allowPermissionPrompts, + invokingRequestId, + } = config + const { setAppState } = toolUseContext + + logForDebugging( + `[inProcessRunner] Starting agent loop for ${identity.agentId}`, + ) + + // Create AgentContext for analytics attribution + const agentContext: AgentContext = { + agentId: identity.agentId, + parentSessionId: identity.parentSessionId, + agentName: identity.agentName, + teamName: identity.teamName, + agentColor: identity.color, + planModeRequired: identity.planModeRequired, + isTeamLead: false, + agentType: 'teammate', + invokingRequestId, + invocationKind: 'spawn', + invocationEmitted: false, + } + + // Build system prompt based on systemPromptMode + let teammateSystemPrompt: string + if (systemPromptMode === 'replace' && systemPrompt) { + teammateSystemPrompt = systemPrompt + } else { + const fullSystemPromptParts = await getSystemPrompt( + toolUseContext.options.tools, + toolUseContext.options.mainLoopModel, + undefined, + toolUseContext.options.mcpClients, + ) + + const systemPromptParts = [ + ...fullSystemPromptParts, + TEAMMATE_SYSTEM_PROMPT_ADDENDUM, + ] + + // If custom agent definition provided, append its prompt + if (agentDefinition) { + const customPrompt = agentDefinition.getSystemPrompt() + if (customPrompt) { + systemPromptParts.push(`\n# Custom Agent Instructions\n${customPrompt}`) + } + + // Log agent memory loaded event for in-process teammates + if (agentDefinition.memory) { + logEvent('tengu_agent_memory_loaded', { + ...(process.env.USER_TYPE === 'ant' + ? { + agent_type: + agentDefinition.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + } + : {}), + scope: + agentDefinition.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + source: + 'in-process-teammate' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + }) + } + } + + // Append mode: add provided system prompt after default + if (systemPromptMode === 'append' && systemPrompt) { + systemPromptParts.push(systemPrompt) + } + + teammateSystemPrompt = systemPromptParts.join('\n') + } + + // Resolve agent definition - use full system prompt with teammate addendum + // IMPORTANT: Set permissionMode to 'default' so teammates always get full tool + // access regardless of the leader's permission mode. + const resolvedAgentDefinition: CustomAgentDefinition = { + agentType: identity.agentName, + whenToUse: `In-process teammate: ${identity.agentName}`, + getSystemPrompt: () => teammateSystemPrompt, + // Inject team-essential tools so teammates can always respond to + // shutdown requests, send messages, and coordinate via the task list, + // even with explicit tool lists + tools: agentDefinition?.tools + ? [ + ...new Set([ + ...agentDefinition.tools, + SEND_MESSAGE_TOOL_NAME, + TEAM_CREATE_TOOL_NAME, + TEAM_DELETE_TOOL_NAME, + TASK_CREATE_TOOL_NAME, + TASK_GET_TOOL_NAME, + TASK_LIST_TOOL_NAME, + TASK_UPDATE_TOOL_NAME, + ]), + ] + : ['*'], + source: 'projectSettings', + permissionMode: 'default', + // Propagate model from custom agent definition so getAgentModel() + // can use it as a fallback when no tool-level model is specified + ...(agentDefinition?.model ? { model: agentDefinition.model } : {}), + } + + // All messages across all prompts + const allMessages: Message[] = [] + // Wrap initial prompt with XML for proper styling in transcript view + const wrappedInitialPrompt = formatAsTeammateMessage( + 'team-lead', + prompt, + undefined, + description, + ) + let currentPrompt = wrappedInitialPrompt + let shouldExit = false + + // Try to claim an available task immediately so the UI can show activity + // from the very start. The idle loop handles claiming for subsequent tasks. + // Use parentSessionId as the task list ID since the leader creates tasks + // under its session ID, not the team name. + await tryClaimNextTask(identity.parentSessionId, identity.agentName) + + try { + // Add initial prompt to task.messages for display (wrapped with XML) + updateTaskState( + taskId, + task => ({ + ...task, + messages: appendCappedMessage( + task.messages, + createUserMessage({ content: wrappedInitialPrompt }), + ), + }), + setAppState, + ) + + // Per-teammate content replacement state. The while-loop below calls + // runAgent repeatedly over an accumulating `allMessages` buffer (which + // carries FULL original tool result content, not previews — query() yields + // originals, enforcement is non-mutating). Without persisting state across + // iterations, each call gets a fresh empty state from createSubagentContext + // and makes holistic replace-globally-largest decisions, diverging from + // earlier iterations' incremental frozen-first decisions → wire prefix + // differs → cache miss. Gated on parent to inherit feature-flag-off. + let teammateReplacementState = toolUseContext.contentReplacementState + ? createContentReplacementState() + : undefined + + // Main teammate loop - runs until abort or shutdown approved + while (!abortController.signal.aborted && !shouldExit) { + logForDebugging( + `[inProcessRunner] ${identity.agentId} processing prompt: ${currentPrompt.substring(0, 50)}...`, + ) + + // Create a per-turn abort controller for this iteration. + // This allows Escape to stop current work without killing the whole teammate. + // The lifecycle abortController still kills the whole teammate if needed. + const currentWorkAbortController = createAbortController() + + // Store the work controller in task state so UI can abort it + updateTaskState( + taskId, + task => ({ ...task, currentWorkAbortController }), + setAppState, + ) + + // Prepare prompt messages for this iteration + // For the first iteration, start fresh + // For subsequent iterations, pass accumulated messages as context + const userMessage = createUserMessage({ content: currentPrompt }) + const promptMessages: Message[] = [userMessage] + + // Check if compaction is needed before building context + let contextMessages = allMessages + const tokenCount = tokenCountWithEstimation(allMessages) + if ( + tokenCount > + getAutoCompactThreshold(toolUseContext.options.mainLoopModel) + ) { + logForDebugging( + `[inProcessRunner] ${identity.agentId} compacting history (${tokenCount} tokens)`, + ) + // Create an isolated copy of toolUseContext so that compaction + // does not clear the main session's readFileState cache or + // trigger the main session's UI callbacks. + const isolatedContext: ToolUseContext = { + ...toolUseContext, + readFileState: cloneFileStateCache(toolUseContext.readFileState), + onCompactProgress: undefined, + setStreamMode: undefined, + } + const compactedSummary = await compactConversation( + allMessages, + isolatedContext, + { + systemPrompt: asSystemPrompt([]), + userContext: {}, + systemContext: {}, + toolUseContext: isolatedContext, + forkContextMessages: [], + }, + true, // suppressFollowUpQuestions + undefined, // customInstructions + true, // isAutoCompact + ) + contextMessages = buildPostCompactMessages(compactedSummary) + // Reset microcompact state since full compact replaces all + // messages — old tool IDs are no longer relevant + resetMicrocompactState() + // Reset content replacement state — compact replaces all messages + // so old tool_use_ids are gone. Stale Map entries are harmless + // (UUID keys never match) but accumulate memory over long runs. + if (teammateReplacementState) { + teammateReplacementState = createContentReplacementState() + } + // Update allMessages in place with compacted version + allMessages.length = 0 + allMessages.push(...contextMessages) + + // Mirror compaction into task.messages — otherwise the AppState + // mirror grows unbounded (500 turns = 500+ messages, 10-50MB). + // Replace with the compacted messages, matching allMessages. + updateTaskState( + taskId, + task => ({ ...task, messages: [...contextMessages, userMessage] }), + setAppState, + ) + } + + // Pass previous messages as context to preserve conversation history + // allMessages accumulates all previous messages (user + assistant) from prior iterations + const forkContextMessages = + contextMessages.length > 0 ? [...contextMessages] : undefined + + // Add the user message to allMessages so it's included in future context + // This ensures the full conversation (user + assistant turns) is preserved + allMessages.push(userMessage) + + // Create fresh progress tracker for this prompt + const tracker = createProgressTracker() + const resolveActivity = createActivityDescriptionResolver( + toolUseContext.options.tools, + ) + const iterationMessages: Message[] = [] + + // Read current permission mode from task state (may have been cycled by leader via Shift+Tab) + const currentAppState = toolUseContext.getAppState() + const currentTask = currentAppState.tasks[taskId] + const currentPermissionMode = + currentTask && currentTask.type === 'in_process_teammate' + ? currentTask.permissionMode + : 'default' + const iterationAgentDefinition = { + ...resolvedAgentDefinition, + permissionMode: currentPermissionMode, + } + + // Track if this iteration was interrupted by work abort (not lifecycle abort) + let workWasAborted = false + + // Run agent within contexts + await runWithTeammateContext(teammateContext, async () => { + return runWithAgentContext(agentContext, async () => { + // Mark task as running (not idle) + updateTaskState( + taskId, + task => ({ ...task, status: 'running', isIdle: false }), + setAppState, + ) + + // Run the normal agent loop - same runAgent() used by AgentTool/subagents. + // This calls query() internally, so we share the core API infrastructure. + // Pass forkContextMessages to preserve conversation history across prompts. + // In-process teammates are async but run in the same process as the leader, + // so they CAN show permission prompts (unlike true background agents). + // Use currentWorkAbortController so Escape stops this turn only, not the teammate. + for await (const message of runAgent({ + agentDefinition: iterationAgentDefinition, + promptMessages, + toolUseContext, + canUseTool: createInProcessCanUseTool( + identity, + currentWorkAbortController, + (waitMs: number) => { + updateTaskState( + taskId, + task => ({ + ...task, + totalPausedMs: (task.totalPausedMs ?? 0) + waitMs, + }), + setAppState, + ) + }, + ), + isAsync: true, + canShowPermissionPrompts: allowPermissionPrompts ?? true, + forkContextMessages, + querySource: 'agent:custom', + override: { abortController: currentWorkAbortController }, + model: model as ModelAlias | undefined, + preserveToolUseResults: true, + availableTools: toolUseContext.options.tools, + allowedTools, + contentReplacementState: teammateReplacementState, + })) { + // Check lifecycle abort first (kills whole teammate) + if (abortController.signal.aborted) { + logForDebugging( + `[inProcessRunner] ${identity.agentId} lifecycle aborted`, + ) + break + } + + // Check work abort (stops current turn only) + if (currentWorkAbortController.signal.aborted) { + logForDebugging( + `[inProcessRunner] ${identity.agentId} current work aborted (Escape pressed)`, + ) + workWasAborted = true + break + } + + iterationMessages.push(message) + allMessages.push(message) + + updateProgressFromMessage( + tracker, + message, + resolveActivity, + toolUseContext.options.tools, + ) + const progress = getProgressUpdate(tracker) + + updateTaskState( + taskId, + task => { + // Track in-progress tool use IDs for animation in transcript view + let inProgressToolUseIDs = task.inProgressToolUseIDs + if (message.type === 'assistant') { + for (const block of message.message.content) { + if (block.type === 'tool_use') { + inProgressToolUseIDs = new Set([ + ...(inProgressToolUseIDs ?? []), + block.id, + ]) + } + } + } else if (message.type === 'user') { + const content = message.message.content + if (Array.isArray(content)) { + for (const block of content) { + if ( + typeof block === 'object' && + 'type' in block && + block.type === 'tool_result' + ) { + if (inProgressToolUseIDs) { + inProgressToolUseIDs = new Set(inProgressToolUseIDs) + inProgressToolUseIDs.delete(block.tool_use_id) + } + } + } + } + } + + return { + ...task, + progress, + messages: appendCappedMessage(task.messages, message), + inProgressToolUseIDs, + } + }, + setAppState, + ) + } + + return { success: true, messages: iterationMessages } + }) + }) + + // Clear the work controller from state (it's no longer valid) + updateTaskState( + taskId, + task => ({ ...task, currentWorkAbortController: undefined }), + setAppState, + ) + + // Check if lifecycle aborted during agent run (kills whole teammate) + if (abortController.signal.aborted) { + break + } + + // If work was aborted (Escape), log it and add interrupt message, then continue to idle state + if (workWasAborted) { + logForDebugging( + `[inProcessRunner] ${identity.agentId} work interrupted, returning to idle`, + ) + + // Add interrupt message to teammate's messages so it appears in their scrollback + const interruptMessage = createAssistantAPIErrorMessage({ + content: ERROR_MESSAGE_USER_ABORT, + }) + updateTaskState( + taskId, + task => ({ + ...task, + messages: appendCappedMessage(task.messages, interruptMessage), + }), + setAppState, + ) + } + + // Check if already idle before updating (to skip duplicate notification) + const prevAppState = toolUseContext.getAppState() + const prevTask = prevAppState.tasks[taskId] + const wasAlreadyIdle = + prevTask?.type === 'in_process_teammate' && prevTask.isIdle + + // Mark task as idle (NOT completed) and notify any waiters + updateTaskState( + taskId, + task => { + // Call any registered idle callbacks + task.onIdleCallbacks?.forEach(cb => cb()) + return { ...task, isIdle: true, onIdleCallbacks: [] } + }, + setAppState, + ) + + // Note: We do NOT automatically send the teammate's response to the leader. + // Teammates should use the Teammate tool to communicate with the leader. + // This matches process-based teammates where output is not visible to the leader. + + // Only send idle notification on transition to idle (not if already idle) + if (!wasAlreadyIdle) { + await sendIdleNotification( + identity.agentName, + identity.color, + identity.teamName, + { + idleReason: workWasAborted ? 'interrupted' : 'available', + summary: getLastPeerDmSummary(allMessages), + }, + ) + } else { + logForDebugging( + `[inProcessRunner] Skipping duplicate idle notification for ${identity.agentName}`, + ) + } + + logForDebugging( + `[inProcessRunner] ${identity.agentId} finished prompt, waiting for next`, + ) + + // Wait for next message or shutdown + const waitResult = await waitForNextPromptOrShutdown( + identity, + abortController, + taskId, + toolUseContext.getAppState, + setAppState, + identity.parentSessionId, + ) + + switch (waitResult.type) { + case 'shutdown_request': + // Pass shutdown request to model for decision + // Format as teammate-message for consistency with how tmux teammates receive it + // The model will use approveShutdown or rejectShutdown tool + logForDebugging( + `[inProcessRunner] ${identity.agentId} received shutdown request - passing to model`, + ) + currentPrompt = formatAsTeammateMessage( + waitResult.request?.from || 'team-lead', + waitResult.originalMessage, + ) + // Add shutdown request to task.messages for transcript display + appendTeammateMessage( + taskId, + createUserMessage({ content: currentPrompt }), + setAppState, + ) + break + + case 'new_message': + // New prompt from leader or teammate + logForDebugging( + `[inProcessRunner] ${identity.agentId} received new message from ${waitResult.from}`, + ) + // Messages from the user should be plain text (not wrapped in XML) + // Messages from other teammates get XML wrapper for identification + if (waitResult.from === 'user') { + currentPrompt = waitResult.message + } else { + currentPrompt = formatAsTeammateMessage( + waitResult.from, + waitResult.message, + waitResult.color, + waitResult.summary, + ) + // Add to task.messages for transcript display (only for non-user messages) + // Messages from 'user' come from pendingUserMessages which are already + // added by injectUserMessageToTeammate + appendTeammateMessage( + taskId, + createUserMessage({ content: currentPrompt }), + setAppState, + ) + } + break + + case 'aborted': + logForDebugging( + `[inProcessRunner] ${identity.agentId} aborted while waiting`, + ) + shouldExit = true + break + } + } + + // Mark as completed when exiting the loop + let alreadyTerminal = false + let toolUseId: string | undefined + updateTaskState( + taskId, + task => { + // killInProcessTeammate may have already set status:killed + + // notified:true + cleared fields. Don't overwrite (would flip + // killed → completed and double-emit the SDK bookend). + if (task.status !== 'running') { + alreadyTerminal = true + return task + } + toolUseId = task.toolUseId + task.onIdleCallbacks?.forEach(cb => cb()) + task.unregisterCleanup?.() + return { + ...task, + status: 'completed' as const, + notified: true, + endTime: Date.now(), + messages: task.messages?.length ? [task.messages.at(-1)!] : undefined, + pendingUserMessages: [], + inProgressToolUseIDs: undefined, + abortController: undefined, + unregisterCleanup: undefined, + currentWorkAbortController: undefined, + onIdleCallbacks: [], + } + }, + setAppState, + ) + void evictTaskOutput(taskId) + // Eagerly evict task from AppState since it's been consumed + evictTerminalTask(taskId, setAppState) + // notified:true pre-set → no XML notification → print.ts won't emit + // the SDK task_notification. Close the task_started bookend directly. + if (!alreadyTerminal) { + emitTaskTerminatedSdk(taskId, 'completed', { + toolUseId, + summary: identity.agentId, + }) + } + + unregisterPerfettoAgent(identity.agentId) + return { success: true, messages: allMessages } + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : 'Unknown error' + + logForDebugging( + `[inProcessRunner] Agent ${identity.agentId} failed: ${errorMessage}`, + ) + + // Mark task as failed and notify any waiters + let alreadyTerminal = false + let toolUseId: string | undefined + updateTaskState( + taskId, + task => { + if (task.status !== 'running') { + alreadyTerminal = true + return task + } + toolUseId = task.toolUseId + task.onIdleCallbacks?.forEach(cb => cb()) + task.unregisterCleanup?.() + return { + ...task, + status: 'failed' as const, + notified: true, + error: errorMessage, + isIdle: true, + endTime: Date.now(), + onIdleCallbacks: [], + messages: task.messages?.length ? [task.messages.at(-1)!] : undefined, + pendingUserMessages: [], + inProgressToolUseIDs: undefined, + abortController: undefined, + unregisterCleanup: undefined, + currentWorkAbortController: undefined, + } + }, + setAppState, + ) + void evictTaskOutput(taskId) + // Eagerly evict task from AppState since it's been consumed + evictTerminalTask(taskId, setAppState) + // notified:true pre-set → no XML notification → close SDK bookend directly. + if (!alreadyTerminal) { + emitTaskTerminatedSdk(taskId, 'failed', { + toolUseId, + summary: identity.agentId, + }) + } + + // Send idle notification with failure via file-based mailbox + await sendIdleNotification( + identity.agentName, + identity.color, + identity.teamName, + { + idleReason: 'failed', + completedStatus: 'failed', + failureReason: errorMessage, + }, + ) + + unregisterPerfettoAgent(identity.agentId) + return { + success: false, + error: errorMessage, + messages: allMessages, + } + } +} + +/** + * Starts an in-process teammate in the background. + * + * This is the main entry point called after spawn. It starts the agent + * execution loop in a fire-and-forget manner. + * + * @param config - Runner configuration + */ +export function startInProcessTeammate(config: InProcessRunnerConfig): void { + // Extract agentId before the closure so the catch handler doesn't retain + // the full config object (including toolUseContext) while the promise is + // pending - which can be hours for a long-running teammate. + const agentId = config.identity.agentId + void runInProcessTeammate(config).catch(error => { + logForDebugging(`[inProcessRunner] Unhandled error in ${agentId}: ${error}`) + }) +} diff --git a/src/utils/swarm/leaderPermissionBridge.ts b/src/utils/swarm/leaderPermissionBridge.ts new file mode 100644 index 0000000000000000000000000000000000000000..4405b7314ace0e85e3b318d31b261a3a797f9371 --- /dev/null +++ b/src/utils/swarm/leaderPermissionBridge.ts @@ -0,0 +1,54 @@ +/** + * Leader Permission Bridge + * + * Module-level bridge that allows the REPL to register its setToolUseConfirmQueue + * and setToolPermissionContext functions for in-process teammates to use. + * + * When an in-process teammate requests permissions, it uses the standard + * ToolUseConfirm dialog rather than the worker permission badge. This bridge + * makes the REPL's queue setter and permission context setter accessible + * from non-React code in the in-process runner. + */ + +import type { ToolUseConfirm } from '../../components/permissions/PermissionRequest.js' +import type { ToolPermissionContext } from '../../Tool.js' + +export type SetToolUseConfirmQueueFn = ( + updater: (prev: ToolUseConfirm[]) => ToolUseConfirm[], +) => void + +export type SetToolPermissionContextFn = ( + context: ToolPermissionContext, + options?: { preserveMode?: boolean }, +) => void + +let registeredSetter: SetToolUseConfirmQueueFn | null = null +let registeredPermissionContextSetter: SetToolPermissionContextFn | null = null + +export function registerLeaderToolUseConfirmQueue( + setter: SetToolUseConfirmQueueFn, +): void { + registeredSetter = setter +} + +export function getLeaderToolUseConfirmQueue(): SetToolUseConfirmQueueFn | null { + return registeredSetter +} + +export function unregisterLeaderToolUseConfirmQueue(): void { + registeredSetter = null +} + +export function registerLeaderSetToolPermissionContext( + setter: SetToolPermissionContextFn, +): void { + registeredPermissionContextSetter = setter +} + +export function getLeaderSetToolPermissionContext(): SetToolPermissionContextFn | null { + return registeredPermissionContextSetter +} + +export function unregisterLeaderSetToolPermissionContext(): void { + registeredPermissionContextSetter = null +} diff --git a/src/utils/swarm/permissionSync.ts b/src/utils/swarm/permissionSync.ts new file mode 100644 index 0000000000000000000000000000000000000000..001e7a264c61794af4228dbe49b619fa78c315c9 --- /dev/null +++ b/src/utils/swarm/permissionSync.ts @@ -0,0 +1,928 @@ +/** + * Synchronized Permission Prompts for Agent Swarms + * + * This module provides infrastructure for coordinating permission prompts across + * multiple agents in a swarm. When a worker agent needs permission for a tool use, + * it can forward the request to the team leader, who can then approve or deny it. + * + * The system uses the teammate mailbox for message passing: + * - Workers send permission requests to the leader's mailbox + * - Leaders send permission responses to the worker's mailbox + * + * Flow: + * 1. Worker agent encounters a permission prompt + * 2. Worker sends a permission_request message to the leader's mailbox + * 3. Leader polls for mailbox messages and detects permission requests + * 4. User approves/denies via the leader's UI + * 5. Leader sends a permission_response message to the worker's mailbox + * 6. Worker polls mailbox for responses and continues execution + */ + +import { mkdir, readdir, readFile, unlink, writeFile } from 'fs/promises' +import { join } from 'path' +import { z } from 'zod/v4' +import { logForDebugging } from '../debug.js' +import { getErrnoCode } from '../errors.js' +import { lazySchema } from '../lazySchema.js' +import * as lockfile from '../lockfile.js' +import { logError } from '../log.js' +import type { PermissionUpdate } from '../permissions/PermissionUpdateSchema.js' +import { jsonParse, jsonStringify } from '../slowOperations.js' +import { + getAgentId, + getAgentName, + getTeammateColor, + getTeamName, +} from '../teammate.js' +import { + createPermissionRequestMessage, + createPermissionResponseMessage, + createSandboxPermissionRequestMessage, + createSandboxPermissionResponseMessage, + writeToMailbox, +} from '../teammateMailbox.js' +import { getTeamDir, readTeamFileAsync } from './teamHelpers.js' + +/** + * Full request schema for a permission request from a worker to the leader + */ +export const SwarmPermissionRequestSchema = lazySchema(() => + z.object({ + /** Unique identifier for this request */ + id: z.string(), + /** Worker's CLAUDE_CODE_AGENT_ID */ + workerId: z.string(), + /** Worker's CLAUDE_CODE_AGENT_NAME */ + workerName: z.string(), + /** Worker's CLAUDE_CODE_AGENT_COLOR */ + workerColor: z.string().optional(), + /** Team name for routing */ + teamName: z.string(), + /** Tool name requiring permission (e.g., "Bash", "Edit") */ + toolName: z.string(), + /** Original toolUseID from worker's context */ + toolUseId: z.string(), + /** Human-readable description of the tool use */ + description: z.string(), + /** Serialized tool input */ + input: z.record(z.string(), z.unknown()), + /** Suggested permission rules from the permission result */ + permissionSuggestions: z.array(z.unknown()), + /** Status of the request */ + status: z.enum(['pending', 'approved', 'rejected']), + /** Who resolved the request */ + resolvedBy: z.enum(['worker', 'leader']).optional(), + /** Timestamp when resolved */ + resolvedAt: z.number().optional(), + /** Rejection feedback message */ + feedback: z.string().optional(), + /** Modified input if changed by resolver */ + updatedInput: z.record(z.string(), z.unknown()).optional(), + /** "Always allow" rules applied during resolution */ + permissionUpdates: z.array(z.unknown()).optional(), + /** Timestamp when request was created */ + createdAt: z.number(), + }), +) + +export type SwarmPermissionRequest = z.infer< + ReturnType +> + +/** + * Resolution data returned when leader/worker resolves a request + */ +export type PermissionResolution = { + /** Decision: approved or rejected */ + decision: 'approved' | 'rejected' + /** Who resolved it */ + resolvedBy: 'worker' | 'leader' + /** Optional feedback message if rejected */ + feedback?: string + /** Optional updated input if the resolver modified it */ + updatedInput?: Record + /** Permission updates to apply (e.g., "always allow" rules) */ + permissionUpdates?: PermissionUpdate[] +} + +/** + * Get the base directory for a team's permission requests + * Path: ~/.claude/teams/{teamName}/permissions/ + */ +export function getPermissionDir(teamName: string): string { + return join(getTeamDir(teamName), 'permissions') +} + +/** + * Get the pending directory for a team + */ +function getPendingDir(teamName: string): string { + return join(getPermissionDir(teamName), 'pending') +} + +/** + * Get the resolved directory for a team + */ +function getResolvedDir(teamName: string): string { + return join(getPermissionDir(teamName), 'resolved') +} + +/** + * Ensure the permissions directory structure exists (async) + */ +async function ensurePermissionDirsAsync(teamName: string): Promise { + const permDir = getPermissionDir(teamName) + const pendingDir = getPendingDir(teamName) + const resolvedDir = getResolvedDir(teamName) + + for (const dir of [permDir, pendingDir, resolvedDir]) { + await mkdir(dir, { recursive: true }) + } +} + +/** + * Get the path to a pending request file + */ +function getPendingRequestPath(teamName: string, requestId: string): string { + return join(getPendingDir(teamName), `${requestId}.json`) +} + +/** + * Get the path to a resolved request file + */ +function getResolvedRequestPath(teamName: string, requestId: string): string { + return join(getResolvedDir(teamName), `${requestId}.json`) +} + +/** + * Generate a unique request ID + */ +export function generateRequestId(): string { + return `perm-${Date.now()}-${Math.random().toString(36).substring(2, 9)}` +} + +/** + * Create a new SwarmPermissionRequest object + */ +export function createPermissionRequest(params: { + toolName: string + toolUseId: string + input: Record + description: string + permissionSuggestions?: unknown[] + teamName?: string + workerId?: string + workerName?: string + workerColor?: string +}): SwarmPermissionRequest { + const teamName = params.teamName || getTeamName() + const workerId = params.workerId || getAgentId() + const workerName = params.workerName || getAgentName() + const workerColor = params.workerColor || getTeammateColor() + + if (!teamName) { + throw new Error('Team name is required for permission requests') + } + if (!workerId) { + throw new Error('Worker ID is required for permission requests') + } + if (!workerName) { + throw new Error('Worker name is required for permission requests') + } + + return { + id: generateRequestId(), + workerId, + workerName, + workerColor, + teamName, + toolName: params.toolName, + toolUseId: params.toolUseId, + description: params.description, + input: params.input, + permissionSuggestions: params.permissionSuggestions || [], + status: 'pending', + createdAt: Date.now(), + } +} + +/** + * Write a permission request to the pending directory with file locking + * Called by worker agents when they need permission approval from the leader + * + * @returns The written request + */ +export async function writePermissionRequest( + request: SwarmPermissionRequest, +): Promise { + await ensurePermissionDirsAsync(request.teamName) + + const pendingPath = getPendingRequestPath(request.teamName, request.id) + const lockDir = getPendingDir(request.teamName) + + // Create a directory-level lock file for atomic writes + const lockFilePath = join(lockDir, '.lock') + await writeFile(lockFilePath, '', 'utf-8') + + let release: (() => Promise) | undefined + try { + release = await lockfile.lock(lockFilePath) + + // Write the request file + await writeFile(pendingPath, jsonStringify(request, null, 2), 'utf-8') + + logForDebugging( + `[PermissionSync] Wrote pending request ${request.id} from ${request.workerName} for ${request.toolName}`, + ) + + return request + } catch (error) { + logForDebugging( + `[PermissionSync] Failed to write permission request: ${error}`, + ) + logError(error) + throw error + } finally { + if (release) { + await release() + } + } +} + +/** + * Read all pending permission requests for a team + * Called by the team leader to see what requests need attention + */ +export async function readPendingPermissions( + teamName?: string, +): Promise { + const team = teamName || getTeamName() + if (!team) { + logForDebugging('[PermissionSync] No team name available') + return [] + } + + const pendingDir = getPendingDir(team) + + let files: string[] + try { + files = await readdir(pendingDir) + } catch (e: unknown) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + return [] + } + logForDebugging(`[PermissionSync] Failed to read pending requests: ${e}`) + logError(e) + return [] + } + + const jsonFiles = files.filter(f => f.endsWith('.json') && f !== '.lock') + + const results = await Promise.all( + jsonFiles.map(async file => { + const filePath = join(pendingDir, file) + try { + const content = await readFile(filePath, 'utf-8') + const parsed = SwarmPermissionRequestSchema().safeParse( + jsonParse(content), + ) + if (parsed.success) { + return parsed.data + } + logForDebugging( + `[PermissionSync] Invalid request file ${file}: ${parsed.error.message}`, + ) + return null + } catch (err) { + logForDebugging( + `[PermissionSync] Failed to read request file ${file}: ${err}`, + ) + return null + } + }), + ) + + const requests = results.filter(r => r !== null) + + // Sort by creation time (oldest first) + requests.sort((a, b) => a.createdAt - b.createdAt) + + return requests +} + +/** + * Read a resolved permission request by ID + * Called by workers to check if their request has been resolved + * + * @returns The resolved request, or null if not yet resolved + */ +export async function readResolvedPermission( + requestId: string, + teamName?: string, +): Promise { + const team = teamName || getTeamName() + if (!team) { + return null + } + + const resolvedPath = getResolvedRequestPath(team, requestId) + + try { + const content = await readFile(resolvedPath, 'utf-8') + const parsed = SwarmPermissionRequestSchema().safeParse(jsonParse(content)) + if (parsed.success) { + return parsed.data + } + logForDebugging( + `[PermissionSync] Invalid resolved request ${requestId}: ${parsed.error.message}`, + ) + return null + } catch (e: unknown) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + return null + } + logForDebugging( + `[PermissionSync] Failed to read resolved request ${requestId}: ${e}`, + ) + logError(e) + return null + } +} + +/** + * Resolve a permission request + * Called by the team leader (or worker in self-resolution cases) + * + * Writes the resolution to resolved/, removes from pending/ + */ +export async function resolvePermission( + requestId: string, + resolution: PermissionResolution, + teamName?: string, +): Promise { + const team = teamName || getTeamName() + if (!team) { + logForDebugging('[PermissionSync] No team name available') + return false + } + + await ensurePermissionDirsAsync(team) + + const pendingPath = getPendingRequestPath(team, requestId) + const resolvedPath = getResolvedRequestPath(team, requestId) + const lockFilePath = join(getPendingDir(team), '.lock') + + await writeFile(lockFilePath, '', 'utf-8') + + let release: (() => Promise) | undefined + try { + release = await lockfile.lock(lockFilePath) + + // Read the pending request + let content: string + try { + content = await readFile(pendingPath, 'utf-8') + } catch (e: unknown) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + logForDebugging( + `[PermissionSync] Pending request not found: ${requestId}`, + ) + return false + } + throw e + } + + const parsed = SwarmPermissionRequestSchema().safeParse(jsonParse(content)) + if (!parsed.success) { + logForDebugging( + `[PermissionSync] Invalid pending request ${requestId}: ${parsed.error.message}`, + ) + return false + } + + const request = parsed.data + + // Update the request with resolution data + const resolvedRequest: SwarmPermissionRequest = { + ...request, + status: resolution.decision === 'approved' ? 'approved' : 'rejected', + resolvedBy: resolution.resolvedBy, + resolvedAt: Date.now(), + feedback: resolution.feedback, + updatedInput: resolution.updatedInput, + permissionUpdates: resolution.permissionUpdates, + } + + // Write to resolved directory + await writeFile( + resolvedPath, + jsonStringify(resolvedRequest, null, 2), + 'utf-8', + ) + + // Remove from pending directory + await unlink(pendingPath) + + logForDebugging( + `[PermissionSync] Resolved request ${requestId} with ${resolution.decision}`, + ) + + return true + } catch (error) { + logForDebugging(`[PermissionSync] Failed to resolve request: ${error}`) + logError(error) + return false + } finally { + if (release) { + await release() + } + } +} + +/** + * Clean up old resolved permission files + * Called periodically to prevent file accumulation + * + * @param teamName - Team name + * @param maxAgeMs - Maximum age in milliseconds (default: 1 hour) + */ +export async function cleanupOldResolutions( + teamName?: string, + maxAgeMs = 3600000, +): Promise { + const team = teamName || getTeamName() + if (!team) { + return 0 + } + + const resolvedDir = getResolvedDir(team) + + let files: string[] + try { + files = await readdir(resolvedDir) + } catch (e: unknown) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + return 0 + } + logForDebugging(`[PermissionSync] Failed to cleanup resolutions: ${e}`) + logError(e) + return 0 + } + + const now = Date.now() + const jsonFiles = files.filter(f => f.endsWith('.json')) + + const cleanupResults = await Promise.all( + jsonFiles.map(async file => { + const filePath = join(resolvedDir, file) + try { + const content = await readFile(filePath, 'utf-8') + const request = jsonParse(content) as SwarmPermissionRequest + + // Check if the resolution is old enough to clean up + // Use >= to handle edge case where maxAgeMs is 0 (clean up everything) + const resolvedAt = request.resolvedAt || request.createdAt + if (now - resolvedAt >= maxAgeMs) { + await unlink(filePath) + logForDebugging(`[PermissionSync] Cleaned up old resolution: ${file}`) + return 1 + } + return 0 + } catch { + // If we can't parse it, clean it up anyway + try { + await unlink(filePath) + return 1 + } catch { + // Ignore deletion errors + return 0 + } + } + }), + ) + + const cleanedCount = cleanupResults.reduce((sum, n) => sum + n, 0) + + if (cleanedCount > 0) { + logForDebugging( + `[PermissionSync] Cleaned up ${cleanedCount} old resolutions`, + ) + } + + return cleanedCount +} + +/** + * Legacy response type for worker polling + * Used for backward compatibility with worker integration code + */ +export type PermissionResponse = { + /** ID of the request this responds to */ + requestId: string + /** Decision: approved or denied */ + decision: 'approved' | 'denied' + /** Timestamp when response was created */ + timestamp: string + /** Optional feedback message if denied */ + feedback?: string + /** Optional updated input if the resolver modified it */ + updatedInput?: Record + /** Permission updates to apply (e.g., "always allow" rules) */ + permissionUpdates?: unknown[] +} + +/** + * Poll for a permission response (worker-side convenience function) + * Converts the resolved request into a simpler response format + * + * @returns The permission response, or null if not yet resolved + */ +export async function pollForResponse( + requestId: string, + _agentName?: string, + teamName?: string, +): Promise { + const resolved = await readResolvedPermission(requestId, teamName) + if (!resolved) { + return null + } + + return { + requestId: resolved.id, + decision: resolved.status === 'approved' ? 'approved' : 'denied', + timestamp: resolved.resolvedAt + ? new Date(resolved.resolvedAt).toISOString() + : new Date(resolved.createdAt).toISOString(), + feedback: resolved.feedback, + updatedInput: resolved.updatedInput, + permissionUpdates: resolved.permissionUpdates, + } +} + +/** + * Remove a worker's response after processing + * This is an alias for deleteResolvedPermission for backward compatibility + */ +export async function removeWorkerResponse( + requestId: string, + _agentName?: string, + teamName?: string, +): Promise { + await deleteResolvedPermission(requestId, teamName) +} + +/** + * Check if the current agent is a team leader + */ +export function isTeamLeader(teamName?: string): boolean { + const team = teamName || getTeamName() + if (!team) { + return false + } + + // Team leaders don't have an agent ID set, or their ID is 'team-lead' + const agentId = getAgentId() + + return !agentId || agentId === 'team-lead' +} + +/** + * Check if the current agent is a worker in a swarm + */ +export function isSwarmWorker(): boolean { + const teamName = getTeamName() + const agentId = getAgentId() + + return !!teamName && !!agentId && !isTeamLeader() +} + +/** + * Delete a resolved permission file + * Called after a worker has processed the resolution + */ +export async function deleteResolvedPermission( + requestId: string, + teamName?: string, +): Promise { + const team = teamName || getTeamName() + if (!team) { + return false + } + + const resolvedPath = getResolvedRequestPath(team, requestId) + + try { + await unlink(resolvedPath) + logForDebugging( + `[PermissionSync] Deleted resolved permission: ${requestId}`, + ) + return true + } catch (e: unknown) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + return false + } + logForDebugging( + `[PermissionSync] Failed to delete resolved permission: ${e}`, + ) + logError(e) + return false + } +} + +/** + * Submit a permission request (alias for writePermissionRequest) + * Provided for backward compatibility with worker integration code + */ +export const submitPermissionRequest = writePermissionRequest + +// ============================================================================ +// Mailbox-Based Permission System +// ============================================================================ + +/** + * Get the leader's name from the team file + * This is needed to send permission requests to the leader's mailbox + */ +export async function getLeaderName(teamName?: string): Promise { + const team = teamName || getTeamName() + if (!team) { + return null + } + + const teamFile = await readTeamFileAsync(team) + if (!teamFile) { + logForDebugging(`[PermissionSync] Team file not found for team: ${team}`) + return null + } + + const leadMember = teamFile.members.find( + m => m.agentId === teamFile.leadAgentId, + ) + return leadMember?.name || 'team-lead' +} + +/** + * Send a permission request to the leader via mailbox. + * This is the new mailbox-based approach that replaces the file-based pending directory. + * + * @param request - The permission request to send + * @returns true if the message was sent successfully + */ +export async function sendPermissionRequestViaMailbox( + request: SwarmPermissionRequest, +): Promise { + const leaderName = await getLeaderName(request.teamName) + if (!leaderName) { + logForDebugging( + `[PermissionSync] Cannot send permission request: leader name not found`, + ) + return false + } + + try { + // Create the permission request message + const message = createPermissionRequestMessage({ + request_id: request.id, + agent_id: request.workerName, + tool_name: request.toolName, + tool_use_id: request.toolUseId, + description: request.description, + input: request.input, + permission_suggestions: request.permissionSuggestions, + }) + + // Send to leader's mailbox (routes to in-process or file-based based on recipient) + await writeToMailbox( + leaderName, + { + from: request.workerName, + text: jsonStringify(message), + timestamp: new Date().toISOString(), + color: request.workerColor, + }, + request.teamName, + ) + + logForDebugging( + `[PermissionSync] Sent permission request ${request.id} to leader ${leaderName} via mailbox`, + ) + return true + } catch (error) { + logForDebugging( + `[PermissionSync] Failed to send permission request via mailbox: ${error}`, + ) + logError(error) + return false + } +} + +/** + * Send a permission response to a worker via mailbox. + * This is the new mailbox-based approach that replaces the file-based resolved directory. + * + * @param workerName - The worker's name to send the response to + * @param resolution - The permission resolution + * @param requestId - The original request ID + * @param teamName - The team name + * @returns true if the message was sent successfully + */ +export async function sendPermissionResponseViaMailbox( + workerName: string, + resolution: PermissionResolution, + requestId: string, + teamName?: string, +): Promise { + const team = teamName || getTeamName() + if (!team) { + logForDebugging( + `[PermissionSync] Cannot send permission response: team name not found`, + ) + return false + } + + try { + // Create the permission response message + const message = createPermissionResponseMessage({ + request_id: requestId, + subtype: resolution.decision === 'approved' ? 'success' : 'error', + error: resolution.feedback, + updated_input: resolution.updatedInput, + permission_updates: resolution.permissionUpdates, + }) + + // Get the sender name (leader's name) + const senderName = getAgentName() || 'team-lead' + + // Send to worker's mailbox (routes to in-process or file-based based on recipient) + await writeToMailbox( + workerName, + { + from: senderName, + text: jsonStringify(message), + timestamp: new Date().toISOString(), + }, + team, + ) + + logForDebugging( + `[PermissionSync] Sent permission response for ${requestId} to worker ${workerName} via mailbox`, + ) + return true + } catch (error) { + logForDebugging( + `[PermissionSync] Failed to send permission response via mailbox: ${error}`, + ) + logError(error) + return false + } +} + +// ============================================================================ +// Sandbox Permission Mailbox System +// ============================================================================ + +/** + * Generate a unique sandbox permission request ID + */ +export function generateSandboxRequestId(): string { + return `sandbox-${Date.now()}-${Math.random().toString(36).substring(2, 9)}` +} + +/** + * Send a sandbox permission request to the leader via mailbox. + * Called by workers when sandbox runtime needs network access approval. + * + * @param host - The host requesting network access + * @param requestId - Unique ID for this request + * @param teamName - Optional team name + * @returns true if the message was sent successfully + */ +export async function sendSandboxPermissionRequestViaMailbox( + host: string, + requestId: string, + teamName?: string, +): Promise { + const team = teamName || getTeamName() + if (!team) { + logForDebugging( + `[PermissionSync] Cannot send sandbox permission request: team name not found`, + ) + return false + } + + const leaderName = await getLeaderName(team) + if (!leaderName) { + logForDebugging( + `[PermissionSync] Cannot send sandbox permission request: leader name not found`, + ) + return false + } + + const workerId = getAgentId() + const workerName = getAgentName() + const workerColor = getTeammateColor() + + if (!workerId || !workerName) { + logForDebugging( + `[PermissionSync] Cannot send sandbox permission request: worker ID or name not found`, + ) + return false + } + + try { + const message = createSandboxPermissionRequestMessage({ + requestId, + workerId, + workerName, + workerColor, + host, + }) + + // Send to leader's mailbox (routes to in-process or file-based based on recipient) + await writeToMailbox( + leaderName, + { + from: workerName, + text: jsonStringify(message), + timestamp: new Date().toISOString(), + color: workerColor, + }, + team, + ) + + logForDebugging( + `[PermissionSync] Sent sandbox permission request ${requestId} for host ${host} to leader ${leaderName} via mailbox`, + ) + return true + } catch (error) { + logForDebugging( + `[PermissionSync] Failed to send sandbox permission request via mailbox: ${error}`, + ) + logError(error) + return false + } +} + +/** + * Send a sandbox permission response to a worker via mailbox. + * Called by the leader when approving/denying a sandbox network access request. + * + * @param workerName - The worker's name to send the response to + * @param requestId - The original request ID + * @param host - The host that was approved/denied + * @param allow - Whether the connection is allowed + * @param teamName - Optional team name + * @returns true if the message was sent successfully + */ +export async function sendSandboxPermissionResponseViaMailbox( + workerName: string, + requestId: string, + host: string, + allow: boolean, + teamName?: string, +): Promise { + const team = teamName || getTeamName() + if (!team) { + logForDebugging( + `[PermissionSync] Cannot send sandbox permission response: team name not found`, + ) + return false + } + + try { + const message = createSandboxPermissionResponseMessage({ + requestId, + host, + allow, + }) + + const senderName = getAgentName() || 'team-lead' + + // Send to worker's mailbox (routes to in-process or file-based based on recipient) + await writeToMailbox( + workerName, + { + from: senderName, + text: jsonStringify(message), + timestamp: new Date().toISOString(), + }, + team, + ) + + logForDebugging( + `[PermissionSync] Sent sandbox permission response for ${requestId} (host: ${host}, allow: ${allow}) to worker ${workerName} via mailbox`, + ) + return true + } catch (error) { + logForDebugging( + `[PermissionSync] Failed to send sandbox permission response via mailbox: ${error}`, + ) + logError(error) + return false + } +} diff --git a/src/utils/swarm/reconnection.ts b/src/utils/swarm/reconnection.ts new file mode 100644 index 0000000000000000000000000000000000000000..62a38cc931b47afb1f7255c298efa3092ffb61c9 --- /dev/null +++ b/src/utils/swarm/reconnection.ts @@ -0,0 +1,119 @@ +/** + * Swarm Reconnection Module + * + * Handles initialization of swarm context for teammates. + * - Fresh spawns: Initialize from CLI args (set in main.tsx via dynamicTeamContext) + * - Resumed sessions: Initialize from teamName/agentName stored in the transcript + */ + +import type { AppState } from '../../state/AppState.js' +import { logForDebugging } from '../debug.js' +import { logError } from '../log.js' +import { getDynamicTeamContext } from '../teammate.js' +import { getTeamFilePath, readTeamFile } from './teamHelpers.js' + +/** + * Computes the initial teamContext for AppState. + * + * This is called synchronously in main.tsx to compute the teamContext + * BEFORE the first render, eliminating the need for useEffect workarounds. + * + * @returns The teamContext object to include in initialState, or undefined if not a teammate + */ +export function computeInitialTeamContext(): + | AppState['teamContext'] + | undefined { + // dynamicTeamContext is set in main.tsx from CLI args + const context = getDynamicTeamContext() + + if (!context?.teamName || !context?.agentName) { + logForDebugging( + '[Reconnection] computeInitialTeamContext: No teammate context set (not a teammate)', + ) + return undefined + } + + const { teamName, agentId, agentName } = context + + // Read team file to get lead agent ID + const teamFile = readTeamFile(teamName) + if (!teamFile) { + logError( + new Error( + `[computeInitialTeamContext] Could not read team file for ${teamName}`, + ), + ) + return undefined + } + + const teamFilePath = getTeamFilePath(teamName) + + const isLeader = !agentId + + logForDebugging( + `[Reconnection] Computed initial team context for ${isLeader ? 'leader' : `teammate ${agentName}`} in team ${teamName}`, + ) + + return { + teamName, + teamFilePath, + leadAgentId: teamFile.leadAgentId, + selfAgentId: agentId, + selfAgentName: agentName, + isLeader, + teammates: {}, + } +} + +/** + * Initialize teammate context from a resumed session. + * + * This is called when resuming a session that has teamName/agentName stored + * in the transcript. It sets up teamContext in AppState so that heartbeat + * and other swarm features work correctly. + */ +export function initializeTeammateContextFromSession( + setAppState: (updater: (prev: AppState) => AppState) => void, + teamName: string, + agentName: string, +): void { + // Read team file to get lead agent ID + const teamFile = readTeamFile(teamName) + if (!teamFile) { + logError( + new Error( + `[initializeTeammateContextFromSession] Could not read team file for ${teamName} (agent: ${agentName})`, + ), + ) + return + } + + // Find the member in the team file to get their agentId + const member = teamFile.members.find(m => m.name === agentName) + if (!member) { + logForDebugging( + `[Reconnection] Member ${agentName} not found in team ${teamName} - may have been removed`, + ) + } + const agentId = member?.agentId + + const teamFilePath = getTeamFilePath(teamName) + + // Set teamContext in AppState + setAppState(prev => ({ + ...prev, + teamContext: { + teamName, + teamFilePath, + leadAgentId: teamFile.leadAgentId, + selfAgentId: agentId, + selfAgentName: agentName, + isLeader: false, + teammates: {}, + }, + })) + + logForDebugging( + `[Reconnection] Initialized agent context from session for ${agentName} in team ${teamName}`, + ) +} diff --git a/src/utils/swarm/spawnInProcess.ts b/src/utils/swarm/spawnInProcess.ts new file mode 100644 index 0000000000000000000000000000000000000000..7f548f28aa22b817ef5da72f7fc897b840688612 --- /dev/null +++ b/src/utils/swarm/spawnInProcess.ts @@ -0,0 +1,328 @@ +/** + * In-process teammate spawning + * + * Creates and registers an in-process teammate task. Unlike process-based + * teammates (tmux/iTerm2), in-process teammates run in the same Node.js + * process using AsyncLocalStorage for context isolation. + * + * The actual agent execution loop is handled by InProcessTeammateTask + * component (Task #14). This module handles: + * 1. Creating TeammateContext + * 2. Creating linked AbortController + * 3. Registering InProcessTeammateTaskState in AppState + * 4. Returning spawn result for backend + */ + +import sample from 'lodash-es/sample.js' +import { getSessionId } from '../../bootstrap/state.js' +import { getSpinnerVerbs } from '../../constants/spinnerVerbs.js' +import { TURN_COMPLETION_VERBS } from '../../constants/turnCompletionVerbs.js' +import type { AppState } from '../../state/AppState.js' +import { createTaskStateBase, generateTaskId } from '../../Task.js' +import type { + InProcessTeammateTaskState, + TeammateIdentity, +} from '../../tasks/InProcessTeammateTask/types.js' +import { createAbortController } from '../abortController.js' +import { formatAgentId } from '../agentId.js' +import { registerCleanup } from '../cleanupRegistry.js' +import { logForDebugging } from '../debug.js' +import { emitTaskTerminatedSdk } from '../sdkEventQueue.js' +import { evictTaskOutput } from '../task/diskOutput.js' +import { + evictTerminalTask, + registerTask, + STOPPED_DISPLAY_MS, +} from '../task/framework.js' +import { createTeammateContext } from '../teammateContext.js' +import { + isPerfettoTracingEnabled, + registerAgent as registerPerfettoAgent, + unregisterAgent as unregisterPerfettoAgent, +} from '../telemetry/perfettoTracing.js' +import { removeMemberByAgentId } from './teamHelpers.js' + +type SetAppStateFn = (updater: (prev: AppState) => AppState) => void + +/** + * Minimal context required for spawning an in-process teammate. + * This is a subset of ToolUseContext - only what spawnInProcessTeammate actually uses. + */ +export type SpawnContext = { + setAppState: SetAppStateFn + toolUseId?: string +} + +/** + * Configuration for spawning an in-process teammate. + */ +export type InProcessSpawnConfig = { + /** Display name for the teammate, e.g., "researcher" */ + name: string + /** Team this teammate belongs to */ + teamName: string + /** Initial prompt/task for the teammate */ + prompt: string + /** Optional UI color for the teammate */ + color?: string + /** Whether teammate must enter plan mode before implementing */ + planModeRequired: boolean + /** Optional model override for this teammate */ + model?: string +} + +/** + * Result from spawning an in-process teammate. + */ +export type InProcessSpawnOutput = { + /** Whether spawn was successful */ + success: boolean + /** Full agent ID (format: "name@team") */ + agentId: string + /** Task ID for tracking in AppState */ + taskId?: string + /** AbortController for this teammate (linked to parent) */ + abortController?: AbortController + /** Teammate context for AsyncLocalStorage */ + teammateContext?: ReturnType + /** Error message if spawn failed */ + error?: string +} + +/** + * Spawns an in-process teammate. + * + * Creates the teammate's context, registers the task in AppState, and returns + * the spawn result. The actual agent execution is driven by the + * InProcessTeammateTask component which uses runWithTeammateContext() to + * execute the agent loop with proper identity isolation. + * + * @param config - Spawn configuration + * @param context - Context with setAppState for registering task + * @returns Spawn result with teammate info + */ +export async function spawnInProcessTeammate( + config: InProcessSpawnConfig, + context: SpawnContext, +): Promise { + const { name, teamName, prompt, color, planModeRequired, model } = config + const { setAppState } = context + + // Generate deterministic agent ID + const agentId = formatAgentId(name, teamName) + const taskId = generateTaskId('in_process_teammate') + + logForDebugging( + `[spawnInProcessTeammate] Spawning ${agentId} (taskId: ${taskId})`, + ) + + try { + // Create independent AbortController for this teammate + // Teammates should not be aborted when the leader's query is interrupted + const abortController = createAbortController() + + // Get parent session ID for transcript correlation + const parentSessionId = getSessionId() + + // Create teammate identity (stored as plain data in AppState) + const identity: TeammateIdentity = { + agentId, + agentName: name, + teamName, + color, + planModeRequired, + parentSessionId, + } + + // Create teammate context for AsyncLocalStorage + // This will be used by runWithTeammateContext() during agent execution + const teammateContext = createTeammateContext({ + agentId, + agentName: name, + teamName, + color, + planModeRequired, + parentSessionId, + abortController, + }) + + // Register agent in Perfetto trace for hierarchy visualization + if (isPerfettoTracingEnabled()) { + registerPerfettoAgent(agentId, name, parentSessionId) + } + + // Create task state + const description = `${name}: ${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}` + + const taskState: InProcessTeammateTaskState = { + ...createTaskStateBase( + taskId, + 'in_process_teammate', + description, + context.toolUseId, + ), + type: 'in_process_teammate', + status: 'running', + identity, + prompt, + model, + abortController, + awaitingPlanApproval: false, + spinnerVerb: sample(getSpinnerVerbs()), + pastTenseVerb: sample(TURN_COMPLETION_VERBS), + permissionMode: planModeRequired ? 'plan' : 'default', + isIdle: false, + shutdownRequested: false, + lastReportedToolCount: 0, + lastReportedTokenCount: 0, + pendingUserMessages: [], + messages: [], // Initialize to empty array so getDisplayedMessages works immediately + } + + // Register cleanup handler for graceful shutdown + const unregisterCleanup = registerCleanup(async () => { + logForDebugging(`[spawnInProcessTeammate] Cleanup called for ${agentId}`) + abortController.abort() + // Task state will be updated by the execution loop when it detects abort + }) + taskState.unregisterCleanup = unregisterCleanup + + // Register task in AppState + registerTask(taskState, setAppState) + + logForDebugging( + `[spawnInProcessTeammate] Registered ${agentId} in AppState`, + ) + + return { + success: true, + agentId, + taskId, + abortController, + teammateContext, + } + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : 'Unknown error during spawn' + logForDebugging( + `[spawnInProcessTeammate] Failed to spawn ${agentId}: ${errorMessage}`, + ) + return { + success: false, + agentId, + error: errorMessage, + } + } +} + +/** + * Kills an in-process teammate by aborting its controller. + * + * Note: This is the implementation called by InProcessBackend.kill(). + * + * @param taskId - Task ID of the teammate to kill + * @param setAppState - AppState setter + * @returns true if killed successfully + */ +export function killInProcessTeammate( + taskId: string, + setAppState: SetAppStateFn, +): boolean { + let killed = false + let teamName: string | null = null + let agentId: string | null = null + let toolUseId: string | undefined + let description: string | undefined + + setAppState((prev: AppState) => { + const task = prev.tasks[taskId] + if (!task || task.type !== 'in_process_teammate') { + return prev + } + + const teammateTask = task as InProcessTeammateTaskState + + if (teammateTask.status !== 'running') { + return prev + } + + // Capture identity for cleanup after state update + teamName = teammateTask.identity.teamName + agentId = teammateTask.identity.agentId + toolUseId = teammateTask.toolUseId + description = teammateTask.description + + // Abort the controller to stop execution + teammateTask.abortController?.abort() + + // Call cleanup handler + teammateTask.unregisterCleanup?.() + + // Update task state and remove from teamContext.teammates + killed = true + + // Call pending idle callbacks to unblock any waiters (e.g., engine.waitForIdle) + teammateTask.onIdleCallbacks?.forEach(cb => cb()) + + // Remove from teamContext.teammates using the agentId + let updatedTeamContext = prev.teamContext + if (prev.teamContext && prev.teamContext.teammates && agentId) { + const { [agentId]: _, ...remainingTeammates } = prev.teamContext.teammates + updatedTeamContext = { + ...prev.teamContext, + teammates: remainingTeammates, + } + } + + return { + ...prev, + teamContext: updatedTeamContext, + tasks: { + ...prev.tasks, + [taskId]: { + ...teammateTask, + status: 'killed' as const, + notified: true, + endTime: Date.now(), + onIdleCallbacks: [], // Clear callbacks to prevent stale references + messages: teammateTask.messages?.length + ? [teammateTask.messages[teammateTask.messages.length - 1]!] + : undefined, + pendingUserMessages: [], + inProgressToolUseIDs: undefined, + abortController: undefined, + unregisterCleanup: undefined, + currentWorkAbortController: undefined, + }, + }, + } + }) + + // Remove from team file (outside state updater to avoid file I/O in callback) + if (teamName && agentId) { + removeMemberByAgentId(teamName, agentId) + } + + if (killed) { + void evictTaskOutput(taskId) + // notified:true was pre-set so no XML notification fires; close the SDK + // task_started bookend directly. The in-process runner's own + // completion/failure emit guards on status==='running' so it won't + // double-emit after seeing status:killed. + emitTaskTerminatedSdk(taskId, 'stopped', { + toolUseId, + summary: description, + }) + setTimeout( + evictTerminalTask.bind(null, taskId, setAppState), + STOPPED_DISPLAY_MS, + ) + } + + // Release perfetto agent registry entry + if (agentId) { + unregisterPerfettoAgent(agentId) + } + + return killed +} diff --git a/src/utils/swarm/spawnUtils.ts b/src/utils/swarm/spawnUtils.ts new file mode 100644 index 0000000000000000000000000000000000000000..cfccdf5a22f520e8acb2c9411e809c84ab28ea2a --- /dev/null +++ b/src/utils/swarm/spawnUtils.ts @@ -0,0 +1,146 @@ +/** + * Shared utilities for spawning teammates across different backends. + */ + +import { + getChromeFlagOverride, + getFlagSettingsPath, + getInlinePlugins, + getMainLoopModelOverride, + getSessionBypassPermissionsMode, +} from '../../bootstrap/state.js' +import { quote } from '../bash/shellQuote.js' +import { isInBundledMode } from '../bundledMode.js' +import type { PermissionMode } from '../permissions/PermissionMode.js' +import { getTeammateModeFromSnapshot } from './backends/teammateModeSnapshot.js' +import { TEAMMATE_COMMAND_ENV_VAR } from './constants.js' + +/** + * Gets the command to use for spawning teammate processes. + * Uses TEAMMATE_COMMAND_ENV_VAR if set, otherwise falls back to the + * current process executable path. + */ +export function getTeammateCommand(): string { + if (process.env[TEAMMATE_COMMAND_ENV_VAR]) { + return process.env[TEAMMATE_COMMAND_ENV_VAR] + } + return isInBundledMode() ? process.execPath : process.argv[1]! +} + +/** + * Builds CLI flags to propagate from the current session to spawned teammates. + * This ensures teammates inherit important settings like permission mode, + * model selection, and plugin configuration from their parent. + * + * @param options.planModeRequired - If true, don't inherit bypass permissions (plan mode takes precedence) + * @param options.permissionMode - Permission mode to propagate + */ +export function buildInheritedCliFlags(options?: { + planModeRequired?: boolean + permissionMode?: PermissionMode +}): string { + const flags: string[] = [] + const { planModeRequired, permissionMode } = options || {} + + // Propagate permission mode to teammates, but NOT if plan mode is required + // Plan mode takes precedence over bypass permissions for safety + if (planModeRequired) { + // Don't inherit bypass permissions when plan mode is required + } else if ( + permissionMode === 'bypassPermissions' || + getSessionBypassPermissionsMode() + ) { + flags.push('--dangerously-skip-permissions') + } else if (permissionMode === 'acceptEdits') { + flags.push('--permission-mode acceptEdits') + } + + // Propagate --model if explicitly set via CLI + const modelOverride = getMainLoopModelOverride() + if (modelOverride) { + flags.push(`--model ${quote([modelOverride])}`) + } + + // Propagate --settings if set via CLI + const settingsPath = getFlagSettingsPath() + if (settingsPath) { + flags.push(`--settings ${quote([settingsPath])}`) + } + + // Propagate --plugin-dir for each inline plugin + const inlinePlugins = getInlinePlugins() + for (const pluginDir of inlinePlugins) { + flags.push(`--plugin-dir ${quote([pluginDir])}`) + } + + // Propagate --teammate-mode so tmux teammates use the same mode as leader + const sessionMode = getTeammateModeFromSnapshot() + flags.push(`--teammate-mode ${sessionMode}`) + + // Propagate --chrome / --no-chrome if explicitly set on the CLI + const chromeFlagOverride = getChromeFlagOverride() + if (chromeFlagOverride === true) { + flags.push('--chrome') + } else if (chromeFlagOverride === false) { + flags.push('--no-chrome') + } + + return flags.join(' ') +} + +/** + * Environment variables that must be explicitly forwarded to tmux-spawned + * teammates. Tmux may start a new login shell that doesn't inherit the + * parent's env, so we forward any that are set in the current process. + */ +const TEAMMATE_ENV_VARS = [ + // API provider selection — without these, teammates default to firstParty + // and send requests to the wrong endpoint (GitHub issue #23561) + 'CLAUDE_CODE_USE_BEDROCK', + 'CLAUDE_CODE_USE_VERTEX', + 'CLAUDE_CODE_USE_FOUNDRY', + // Custom API endpoint + 'ANTHROPIC_BASE_URL', + // Config directory override + 'CLAUDE_CONFIG_DIR', + // CCR marker — teammates need this for CCR-aware code paths. Auth finds + // its own way via /home/claude/.claude/remote/.oauth_token regardless; + // the FD env var wouldn't help (pipe FDs don't cross tmux). + 'CLAUDE_CODE_REMOTE', + // Auto-memory gate (memdir/paths.ts) checks REMOTE && !MEMORY_DIR to + // disable memory on ephemeral CCR filesystems. Forwarding REMOTE alone + // would flip teammates to memory-off when the parent has it on. + 'CLAUDE_CODE_REMOTE_MEMORY_DIR', + // Upstream proxy — the parent's MITM relay is reachable from teammates + // (same container network). Forward the proxy vars so teammates route + // customer-configured upstream traffic through the relay for credential + // injection. Without these, teammates bypass the proxy entirely. + 'HTTPS_PROXY', + 'https_proxy', + 'HTTP_PROXY', + 'http_proxy', + 'NO_PROXY', + 'no_proxy', + 'SSL_CERT_FILE', + 'NODE_EXTRA_CA_CERTS', + 'REQUESTS_CA_BUNDLE', + 'CURL_CA_BUNDLE', +] as const + +/** + * Builds the `env KEY=VALUE ...` string for teammate spawn commands. + * Always includes CLAUDECODE=1 and CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, + * plus any provider/config env vars that are set in the current process. + */ +export function buildInheritedEnvVars(): string { + const envVars = ['CLAUDECODE=1', 'CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1'] + + for (const key of TEAMMATE_ENV_VARS) { + const value = process.env[key] + if (value !== undefined && value !== '') { + envVars.push(`${key}=${quote([value])}`) + } + } + + return envVars.join(' ') +} diff --git a/src/utils/swarm/teamHelpers.ts b/src/utils/swarm/teamHelpers.ts new file mode 100644 index 0000000000000000000000000000000000000000..66508fd7a66bab7515e99b364febaf60e8d73d9e --- /dev/null +++ b/src/utils/swarm/teamHelpers.ts @@ -0,0 +1,683 @@ +import { mkdirSync, readFileSync, writeFileSync } from 'fs' +import { mkdir, readFile, rm, writeFile } from 'fs/promises' +import { join } from 'path' +import { z } from 'zod/v4' +import { getSessionCreatedTeams } from '../../bootstrap/state.js' +import { logForDebugging } from '../debug.js' +import { getTeamsDir } from '../envUtils.js' +import { errorMessage, getErrnoCode } from '../errors.js' +import { execFileNoThrowWithCwd } from '../execFileNoThrow.js' +import { gitExe } from '../git.js' +import { lazySchema } from '../lazySchema.js' +import type { PermissionMode } from '../permissions/PermissionMode.js' +import { jsonParse, jsonStringify } from '../slowOperations.js' +import { getTasksDir, notifyTasksUpdated } from '../tasks.js' +import { getAgentName, getTeamName, isTeammate } from '../teammate.js' +import { type BackendType, isPaneBackend } from './backends/types.js' +import { TEAM_LEAD_NAME } from './constants.js' + +export const inputSchema = lazySchema(() => + z.strictObject({ + operation: z + .enum(['spawnTeam', 'cleanup']) + .describe( + 'Operation: spawnTeam to create a team, cleanup to remove team and task directories.', + ), + agent_type: z + .string() + .optional() + .describe( + 'Type/role of the team lead (e.g., "researcher", "test-runner"). ' + + 'Used for team file and inter-agent coordination.', + ), + team_name: z + .string() + .optional() + .describe('Name for the new team to create (required for spawnTeam).'), + description: z + .string() + .optional() + .describe('Team description/purpose (only used with spawnTeam).'), + }), +) + +// Output types for different operations +export type SpawnTeamOutput = { + team_name: string + team_file_path: string + lead_agent_id: string +} + +export type CleanupOutput = { + success: boolean + message: string + team_name?: string +} + +export type TeamAllowedPath = { + path: string // Directory path (absolute) + toolName: string // The tool this applies to (e.g., "Edit", "Write") + addedBy: string // Agent name who added this rule + addedAt: number // Timestamp when added +} + +export type TeamFile = { + name: string + description?: string + createdAt: number + leadAgentId: string + leadSessionId?: string // Actual session UUID of the leader (for discovery) + hiddenPaneIds?: string[] // Pane IDs that are currently hidden from the UI + teamAllowedPaths?: TeamAllowedPath[] // Paths all teammates can edit without asking + members: Array<{ + agentId: string + name: string + agentType?: string + model?: string + prompt?: string + color?: string + planModeRequired?: boolean + joinedAt: number + tmuxPaneId: string + cwd: string + worktreePath?: string + sessionId?: string + subscriptions: string[] + backendType?: BackendType + isActive?: boolean // false when idle, undefined/true when active + mode?: PermissionMode // Current permission mode for this teammate + }> +} + +export type Input = z.infer> +// Export SpawnTeamOutput as Output for backward compatibility +export type Output = SpawnTeamOutput + +/** + * Sanitizes a name for use in tmux window names, worktree paths, and file paths. + * Replaces all non-alphanumeric characters with hyphens and lowercases. + */ +export function sanitizeName(name: string): string { + return name.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() +} + +/** + * Sanitizes an agent name for use in deterministic agent IDs. + * Replaces @ with - to prevent ambiguity in the agentName@teamName format. + */ +export function sanitizeAgentName(name: string): string { + return name.replace(/@/g, '-') +} + +/** + * Gets the path to a team's directory + */ +export function getTeamDir(teamName: string): string { + return join(getTeamsDir(), sanitizeName(teamName)) +} + +/** + * Gets the path to a team's config.json file + */ +export function getTeamFilePath(teamName: string): string { + return join(getTeamDir(teamName), 'config.json') +} + +/** + * Reads a team file by name (sync — for sync contexts like React render paths) + * @internal Exported for team discovery UI + */ +// sync IO: called from sync context +export function readTeamFile(teamName: string): TeamFile | null { + try { + const content = readFileSync(getTeamFilePath(teamName), 'utf-8') + return jsonParse(content) as TeamFile + } catch (e) { + if (getErrnoCode(e) === 'ENOENT') return null + logForDebugging( + `[TeammateTool] Failed to read team file for ${teamName}: ${errorMessage(e)}`, + ) + return null + } +} + +/** + * Reads a team file by name (async — for tool handlers and other async contexts) + */ +export async function readTeamFileAsync( + teamName: string, +): Promise { + try { + const content = await readFile(getTeamFilePath(teamName), 'utf-8') + return jsonParse(content) as TeamFile + } catch (e) { + if (getErrnoCode(e) === 'ENOENT') return null + logForDebugging( + `[TeammateTool] Failed to read team file for ${teamName}: ${errorMessage(e)}`, + ) + return null + } +} + +/** + * Writes a team file (sync — for sync contexts) + */ +// sync IO: called from sync context +function writeTeamFile(teamName: string, teamFile: TeamFile): void { + const teamDir = getTeamDir(teamName) + mkdirSync(teamDir, { recursive: true }) + writeFileSync(getTeamFilePath(teamName), jsonStringify(teamFile, null, 2)) +} + +/** + * Writes a team file (async — for tool handlers) + */ +export async function writeTeamFileAsync( + teamName: string, + teamFile: TeamFile, +): Promise { + const teamDir = getTeamDir(teamName) + await mkdir(teamDir, { recursive: true }) + await writeFile(getTeamFilePath(teamName), jsonStringify(teamFile, null, 2)) +} + +/** + * Removes a teammate from the team file by agent ID or name. + * Used by the leader when processing shutdown approvals. + */ +export function removeTeammateFromTeamFile( + teamName: string, + identifier: { agentId?: string; name?: string }, +): boolean { + const identifierStr = identifier.agentId || identifier.name + if (!identifierStr) { + logForDebugging( + '[TeammateTool] removeTeammateFromTeamFile called with no identifier', + ) + return false + } + + const teamFile = readTeamFile(teamName) + if (!teamFile) { + logForDebugging( + `[TeammateTool] Cannot remove teammate ${identifierStr}: failed to read team file for "${teamName}"`, + ) + return false + } + + const originalLength = teamFile.members.length + teamFile.members = teamFile.members.filter(m => { + if (identifier.agentId && m.agentId === identifier.agentId) return false + if (identifier.name && m.name === identifier.name) return false + return true + }) + + if (teamFile.members.length === originalLength) { + logForDebugging( + `[TeammateTool] Teammate ${identifierStr} not found in team file for "${teamName}"`, + ) + return false + } + + writeTeamFile(teamName, teamFile) + logForDebugging( + `[TeammateTool] Removed teammate from team file: ${identifierStr}`, + ) + return true +} + +/** + * Adds a pane ID to the hidden panes list in the team file. + * @param teamName - The name of the team + * @param paneId - The pane ID to hide + * @returns true if the pane was added to hidden list, false if team doesn't exist + */ +export function addHiddenPaneId(teamName: string, paneId: string): boolean { + const teamFile = readTeamFile(teamName) + if (!teamFile) { + return false + } + + const hiddenPaneIds = teamFile.hiddenPaneIds ?? [] + if (!hiddenPaneIds.includes(paneId)) { + hiddenPaneIds.push(paneId) + teamFile.hiddenPaneIds = hiddenPaneIds + writeTeamFile(teamName, teamFile) + logForDebugging( + `[TeammateTool] Added ${paneId} to hidden panes for team ${teamName}`, + ) + } + return true +} + +/** + * Removes a pane ID from the hidden panes list in the team file. + * @param teamName - The name of the team + * @param paneId - The pane ID to show (remove from hidden list) + * @returns true if the pane was removed from hidden list, false if team doesn't exist + */ +export function removeHiddenPaneId(teamName: string, paneId: string): boolean { + const teamFile = readTeamFile(teamName) + if (!teamFile) { + return false + } + + const hiddenPaneIds = teamFile.hiddenPaneIds ?? [] + const index = hiddenPaneIds.indexOf(paneId) + if (index !== -1) { + hiddenPaneIds.splice(index, 1) + teamFile.hiddenPaneIds = hiddenPaneIds + writeTeamFile(teamName, teamFile) + logForDebugging( + `[TeammateTool] Removed ${paneId} from hidden panes for team ${teamName}`, + ) + } + return true +} + +/** + * Removes a teammate from the team config file by pane ID. + * Also removes from hiddenPaneIds if present. + * @param teamName - The name of the team + * @param tmuxPaneId - The pane ID of the teammate to remove + * @returns true if the member was removed, false if team or member doesn't exist + */ +export function removeMemberFromTeam( + teamName: string, + tmuxPaneId: string, +): boolean { + const teamFile = readTeamFile(teamName) + if (!teamFile) { + return false + } + + const memberIndex = teamFile.members.findIndex( + m => m.tmuxPaneId === tmuxPaneId, + ) + if (memberIndex === -1) { + return false + } + + // Remove from members array + teamFile.members.splice(memberIndex, 1) + + // Also remove from hiddenPaneIds if present + if (teamFile.hiddenPaneIds) { + const hiddenIndex = teamFile.hiddenPaneIds.indexOf(tmuxPaneId) + if (hiddenIndex !== -1) { + teamFile.hiddenPaneIds.splice(hiddenIndex, 1) + } + } + + writeTeamFile(teamName, teamFile) + logForDebugging( + `[TeammateTool] Removed member with pane ${tmuxPaneId} from team ${teamName}`, + ) + return true +} + +/** + * Removes a teammate from a team's member list by agent ID. + * Use this for in-process teammates which all share the same tmuxPaneId. + * @param teamName - The name of the team + * @param agentId - The agent ID of the teammate to remove (e.g., "researcher@my-team") + * @returns true if the member was removed, false if team or member doesn't exist + */ +export function removeMemberByAgentId( + teamName: string, + agentId: string, +): boolean { + const teamFile = readTeamFile(teamName) + if (!teamFile) { + return false + } + + const memberIndex = teamFile.members.findIndex(m => m.agentId === agentId) + if (memberIndex === -1) { + return false + } + + // Remove from members array + teamFile.members.splice(memberIndex, 1) + + writeTeamFile(teamName, teamFile) + logForDebugging( + `[TeammateTool] Removed member ${agentId} from team ${teamName}`, + ) + return true +} + +/** + * Sets a team member's permission mode. + * Called when the team leader changes a teammate's mode via the TeamsDialog. + * @param teamName - The name of the team + * @param memberName - The name of the member to update + * @param mode - The new permission mode + */ +export function setMemberMode( + teamName: string, + memberName: string, + mode: PermissionMode, +): boolean { + const teamFile = readTeamFile(teamName) + if (!teamFile) { + return false + } + + const member = teamFile.members.find(m => m.name === memberName) + if (!member) { + logForDebugging( + `[TeammateTool] Cannot set member mode: member ${memberName} not found in team ${teamName}`, + ) + return false + } + + // Only write if the value is actually changing + if (member.mode === mode) { + return true + } + + // Create updated members array immutably + const updatedMembers = teamFile.members.map(m => + m.name === memberName ? { ...m, mode } : m, + ) + writeTeamFile(teamName, { ...teamFile, members: updatedMembers }) + logForDebugging( + `[TeammateTool] Set member ${memberName} in team ${teamName} to mode: ${mode}`, + ) + return true +} + +/** + * Sync the current teammate's mode to config.json so team lead sees it. + * No-op if not running as a teammate. + * @param mode - The permission mode to sync + * @param teamNameOverride - Optional team name override (uses env var if not provided) + */ +export function syncTeammateMode( + mode: PermissionMode, + teamNameOverride?: string, +): void { + if (!isTeammate()) return + const teamName = teamNameOverride ?? getTeamName() + const agentName = getAgentName() + if (teamName && agentName) { + setMemberMode(teamName, agentName, mode) + } +} + +/** + * Sets multiple team members' permission modes in a single atomic operation. + * Avoids race conditions when updating multiple teammates at once. + * @param teamName - The name of the team + * @param modeUpdates - Array of {memberName, mode} to update + */ +export function setMultipleMemberModes( + teamName: string, + modeUpdates: Array<{ memberName: string; mode: PermissionMode }>, +): boolean { + const teamFile = readTeamFile(teamName) + if (!teamFile) { + return false + } + + // Build a map of updates for efficient lookup + const updateMap = new Map(modeUpdates.map(u => [u.memberName, u.mode])) + + // Create updated members array immutably + let anyChanged = false + const updatedMembers = teamFile.members.map(member => { + const newMode = updateMap.get(member.name) + if (newMode !== undefined && member.mode !== newMode) { + anyChanged = true + return { ...member, mode: newMode } + } + return member + }) + + if (anyChanged) { + writeTeamFile(teamName, { ...teamFile, members: updatedMembers }) + logForDebugging( + `[TeammateTool] Set ${modeUpdates.length} member modes in team ${teamName}`, + ) + } + return true +} + +/** + * Sets a team member's active status. + * Called when a teammate becomes idle (isActive=false) or starts a new turn (isActive=true). + * @param teamName - The name of the team + * @param memberName - The name of the member to update + * @param isActive - Whether the member is active (true) or idle (false) + */ +export async function setMemberActive( + teamName: string, + memberName: string, + isActive: boolean, +): Promise { + const teamFile = await readTeamFileAsync(teamName) + if (!teamFile) { + logForDebugging( + `[TeammateTool] Cannot set member active: team ${teamName} not found`, + ) + return + } + + const member = teamFile.members.find(m => m.name === memberName) + if (!member) { + logForDebugging( + `[TeammateTool] Cannot set member active: member ${memberName} not found in team ${teamName}`, + ) + return + } + + // Only write if the value is actually changing + if (member.isActive === isActive) { + return + } + + member.isActive = isActive + await writeTeamFileAsync(teamName, teamFile) + logForDebugging( + `[TeammateTool] Set member ${memberName} in team ${teamName} to ${isActive ? 'active' : 'idle'}`, + ) +} + +/** + * Destroys a git worktree at the given path. + * First attempts to use `git worktree remove`, then falls back to rm -rf. + * Safe to call on non-existent paths. + */ +async function destroyWorktree(worktreePath: string): Promise { + // Read the .git file in the worktree to find the main repo + const gitFilePath = join(worktreePath, '.git') + let mainRepoPath: string | null = null + + try { + const gitFileContent = (await readFile(gitFilePath, 'utf-8')).trim() + // The .git file contains something like: gitdir: /path/to/repo/.git/worktrees/worktree-name + const match = gitFileContent.match(/^gitdir:\s*(.+)$/) + if (match && match[1]) { + // Extract the main repo .git directory (go up from .git/worktrees/name to .git) + const worktreeGitDir = match[1] + // Go up 2 levels from .git/worktrees/name to get to .git, then get parent for repo root + const mainGitDir = join(worktreeGitDir, '..', '..') + mainRepoPath = join(mainGitDir, '..') + } + } catch { + // Ignore errors reading .git file (path doesn't exist, not a file, etc.) + } + + // Try to remove using git worktree remove command + if (mainRepoPath) { + const result = await execFileNoThrowWithCwd( + gitExe(), + ['worktree', 'remove', '--force', worktreePath], + { cwd: mainRepoPath }, + ) + + if (result.code === 0) { + logForDebugging( + `[TeammateTool] Removed worktree via git: ${worktreePath}`, + ) + return + } + + // Check if the error is "not a working tree" (already removed) + if (result.stderr?.includes('not a working tree')) { + logForDebugging( + `[TeammateTool] Worktree already removed: ${worktreePath}`, + ) + return + } + + logForDebugging( + `[TeammateTool] git worktree remove failed, falling back to rm: ${result.stderr}`, + ) + } + + // Fallback: manually remove the directory + try { + await rm(worktreePath, { recursive: true, force: true }) + logForDebugging( + `[TeammateTool] Removed worktree directory manually: ${worktreePath}`, + ) + } catch (error) { + logForDebugging( + `[TeammateTool] Failed to remove worktree ${worktreePath}: ${errorMessage(error)}`, + ) + } +} + +/** + * Mark a team as created this session so it gets cleaned up on exit. + * Call this right after the initial writeTeamFile. TeamDelete should + * call unregisterTeamForSessionCleanup to prevent double-cleanup. + * Backing Set lives in bootstrap/state.ts so resetStateForTests() + * clears it between tests (avoids the PR #17615 cross-shard leak class). + */ +export function registerTeamForSessionCleanup(teamName: string): void { + getSessionCreatedTeams().add(teamName) +} + +/** + * Remove a team from session cleanup tracking (e.g., after explicit + * TeamDelete — already cleaned, don't try again on shutdown). + */ +export function unregisterTeamForSessionCleanup(teamName: string): void { + getSessionCreatedTeams().delete(teamName) +} + +/** + * Clean up all teams created this session that weren't explicitly deleted. + * Registered with gracefulShutdown from init.ts. + */ +export async function cleanupSessionTeams(): Promise { + const sessionCreatedTeams = getSessionCreatedTeams() + if (sessionCreatedTeams.size === 0) return + const teams = Array.from(sessionCreatedTeams) + logForDebugging( + `cleanupSessionTeams: removing ${teams.length} orphan team dir(s): ${teams.join(', ')}`, + ) + // Kill panes first — on SIGINT the teammate processes are still running; + // deleting directories alone would orphan them in open tmux/iTerm2 panes. + // (TeamDeleteTool's path doesn't need this — by then teammates have + // gracefully exited and useInboxPoller has already closed their panes.) + await Promise.allSettled(teams.map(name => killOrphanedTeammatePanes(name))) + await Promise.allSettled(teams.map(name => cleanupTeamDirectories(name))) + sessionCreatedTeams.clear() +} + +/** + * Best-effort kill of all pane-backed teammate panes for a team. + * Called from cleanupSessionTeams on ungraceful leader exit (SIGINT/SIGTERM). + * Dynamic imports avoid adding registry/detection to this module's static + * dep graph — this only runs at shutdown, so the import cost is irrelevant. + */ +async function killOrphanedTeammatePanes(teamName: string): Promise { + const teamFile = readTeamFile(teamName) + if (!teamFile) return + + const paneMembers = teamFile.members.filter( + m => + m.name !== TEAM_LEAD_NAME && + m.tmuxPaneId && + m.backendType && + isPaneBackend(m.backendType), + ) + if (paneMembers.length === 0) return + + const [{ ensureBackendsRegistered, getBackendByType }, { isInsideTmux }] = + await Promise.all([ + import('./backends/registry.js'), + import('./backends/detection.js'), + ]) + await ensureBackendsRegistered() + const useExternalSession = !(await isInsideTmux()) + + await Promise.allSettled( + paneMembers.map(async m => { + // filter above guarantees these; narrow for the type system + if (!m.tmuxPaneId || !m.backendType || !isPaneBackend(m.backendType)) { + return + } + const ok = await getBackendByType(m.backendType).killPane( + m.tmuxPaneId, + useExternalSession, + ) + logForDebugging( + `cleanupSessionTeams: killPane ${m.name} (${m.backendType} ${m.tmuxPaneId}) → ${ok}`, + ) + }), + ) +} + +/** + * Cleans up team and task directories for a given team name. + * Also cleans up git worktrees created for teammates. + * Called when a swarm session is terminated. + */ +export async function cleanupTeamDirectories(teamName: string): Promise { + const sanitizedName = sanitizeName(teamName) + + // Read team file to get worktree paths BEFORE deleting the team directory + const teamFile = readTeamFile(teamName) + const worktreePaths: string[] = [] + if (teamFile) { + for (const member of teamFile.members) { + if (member.worktreePath) { + worktreePaths.push(member.worktreePath) + } + } + } + + // Clean up worktrees first + for (const worktreePath of worktreePaths) { + await destroyWorktree(worktreePath) + } + + // Clean up team directory (~/.claude/teams/{team-name}/) + const teamDir = getTeamDir(teamName) + try { + await rm(teamDir, { recursive: true, force: true }) + logForDebugging(`[TeammateTool] Cleaned up team directory: ${teamDir}`) + } catch (error) { + logForDebugging( + `[TeammateTool] Failed to clean up team directory ${teamDir}: ${errorMessage(error)}`, + ) + } + + // Clean up tasks directory (~/.claude/tasks/{taskListId}/) + // The leader and teammates all store tasks under the sanitized team name. + const tasksDir = getTasksDir(sanitizedName) + try { + await rm(tasksDir, { recursive: true, force: true }) + logForDebugging(`[TeammateTool] Cleaned up tasks directory: ${tasksDir}`) + notifyTasksUpdated() + } catch (error) { + logForDebugging( + `[TeammateTool] Failed to clean up tasks directory ${tasksDir}: ${errorMessage(error)}`, + ) + } +} diff --git a/src/utils/swarm/teammateInit.ts b/src/utils/swarm/teammateInit.ts new file mode 100644 index 0000000000000000000000000000000000000000..db9cfb966905ced7ca9572664e85f49d439d8fdc --- /dev/null +++ b/src/utils/swarm/teammateInit.ts @@ -0,0 +1,129 @@ +/** + * Teammate Initialization Module + * + * Handles initialization for Claude Code instances running as teammates in a swarm. + * Registers a Stop hook to notify the team leader when the teammate becomes idle. + */ + +import type { AppState } from '../../state/AppState.js' +import { logForDebugging } from '../debug.js' +import { addFunctionHook } from '../hooks/sessionHooks.js' +import { applyPermissionUpdate } from '../permissions/PermissionUpdate.js' +import { jsonStringify } from '../slowOperations.js' +import { getTeammateColor } from '../teammate.js' +import { + createIdleNotification, + getLastPeerDmSummary, + writeToMailbox, +} from '../teammateMailbox.js' +import { readTeamFile, setMemberActive } from './teamHelpers.js' + +/** + * Initializes hooks for a teammate running in a swarm. + * Should be called early in session startup after AppState is available. + * + * Registers a Stop hook that sends an idle notification to the team leader + * when this teammate's session stops. + */ +export function initializeTeammateHooks( + setAppState: (updater: (prev: AppState) => AppState) => void, + sessionId: string, + teamInfo: { teamName: string; agentId: string; agentName: string }, +): void { + const { teamName, agentId, agentName } = teamInfo + + // Read team file to get leader ID + const teamFile = readTeamFile(teamName) + if (!teamFile) { + logForDebugging(`[TeammateInit] Team file not found for team: ${teamName}`) + return + } + + const leadAgentId = teamFile.leadAgentId + + // Apply team-wide allowed paths if any exist + if (teamFile.teamAllowedPaths && teamFile.teamAllowedPaths.length > 0) { + logForDebugging( + `[TeammateInit] Found ${teamFile.teamAllowedPaths.length} team-wide allowed path(s)`, + ) + + for (const allowedPath of teamFile.teamAllowedPaths) { + // For absolute paths (starting with /), prepend one / to create //path/** pattern + // For relative paths, just use path/** + const ruleContent = allowedPath.path.startsWith('/') + ? `/${allowedPath.path}/**` + : `${allowedPath.path}/**` + + logForDebugging( + `[TeammateInit] Applying team permission: ${allowedPath.toolName} allowed in ${allowedPath.path} (rule: ${ruleContent})`, + ) + + setAppState(prev => ({ + ...prev, + toolPermissionContext: applyPermissionUpdate( + prev.toolPermissionContext, + { + type: 'addRules', + rules: [ + { + toolName: allowedPath.toolName, + ruleContent, + }, + ], + behavior: 'allow', + destination: 'session', + }, + ), + })) + } + } + + // Find the leader's name from the members array + const leadMember = teamFile.members.find(m => m.agentId === leadAgentId) + const leadAgentName = leadMember?.name || 'team-lead' + + // Don't register hook if this agent is the leader + if (agentId === leadAgentId) { + logForDebugging( + '[TeammateInit] This agent is the team leader - skipping idle notification hook', + ) + return + } + + logForDebugging( + `[TeammateInit] Registering Stop hook for teammate ${agentName} to notify leader ${leadAgentName}`, + ) + + // Register Stop hook to notify leader when this teammate stops + addFunctionHook( + setAppState, + sessionId, + 'Stop', + '', // No matcher - applies to all Stop events + async (messages, _signal) => { + // Mark this teammate as idle in the team config (fire and forget) + void setMemberActive(teamName, agentName, false) + + // Send idle notification to the team leader using agent name (not UUID) + // Must await to ensure the write completes before process shutdown + const notification = createIdleNotification(agentName, { + idleReason: 'available', + summary: getLastPeerDmSummary(messages), + }) + await writeToMailbox(leadAgentName, { + from: agentName, + text: jsonStringify(notification), + timestamp: new Date().toISOString(), + color: getTeammateColor(), + }) + logForDebugging( + `[TeammateInit] Sent idle notification to leader ${leadAgentName}`, + ) + return true // Don't block the Stop + }, + 'Failed to send idle notification to team leader', + { + timeout: 10000, + }, + ) +} diff --git a/src/utils/swarm/teammateLayoutManager.ts b/src/utils/swarm/teammateLayoutManager.ts new file mode 100644 index 0000000000000000000000000000000000000000..2b26a3e17aecc2f7c6305173abab6533e30995fd --- /dev/null +++ b/src/utils/swarm/teammateLayoutManager.ts @@ -0,0 +1,107 @@ +import type { AgentColorName } from '../../tools/AgentTool/agentColorManager.js' +import { AGENT_COLORS } from '../../tools/AgentTool/agentColorManager.js' +import { detectAndGetBackend } from './backends/registry.js' +import type { PaneBackend } from './backends/types.js' + +// Track color assignments for teammates (persisted per session) +const teammateColorAssignments = new Map() +let colorIndex = 0 + +/** + * Gets the appropriate backend for the current environment. + * detectAndGetBackend() caches internally — no need for a second cache here. + */ +async function getBackend(): Promise { + return (await detectAndGetBackend()).backend +} + +/** + * Assigns a unique color to a teammate from the available palette. + * Colors are assigned in round-robin order. + */ +export function assignTeammateColor(teammateId: string): AgentColorName { + const existing = teammateColorAssignments.get(teammateId) + if (existing) { + return existing + } + + const color = AGENT_COLORS[colorIndex % AGENT_COLORS.length]! + teammateColorAssignments.set(teammateId, color) + colorIndex++ + + return color +} + +/** + * Gets the assigned color for a teammate, if any. + */ +export function getTeammateColor( + teammateId: string, +): AgentColorName | undefined { + return teammateColorAssignments.get(teammateId) +} + +/** + * Clears all teammate color assignments. + * Called during team cleanup to reset state for potential new teams. + */ +export function clearTeammateColors(): void { + teammateColorAssignments.clear() + colorIndex = 0 +} + +/** + * Checks if we're currently running inside a tmux session. + * Uses the detection module directly for this check. + */ +export async function isInsideTmux(): Promise { + const { isInsideTmux: checkTmux } = await import('./backends/detection.js') + return checkTmux() +} + +/** + * Creates a new teammate pane in the swarm view. + * Automatically selects the appropriate backend (tmux or iTerm2) based on environment. + * + * When running INSIDE tmux: + * - Uses TmuxBackend to split the current window + * - Leader stays on left (30%), teammates on right (70%) + * + * When running in iTerm2 (not in tmux) with it2 CLI: + * - Uses ITermBackend for native iTerm2 split panes + * + * When running OUTSIDE tmux/iTerm2: + * - Falls back to TmuxBackend with external claude-swarm session + */ +export async function createTeammatePaneInSwarmView( + teammateName: string, + teammateColor: AgentColorName, +): Promise<{ paneId: string; isFirstTeammate: boolean }> { + const backend = await getBackend() + return backend.createTeammatePaneInSwarmView(teammateName, teammateColor) +} + +/** + * Enables pane border status for a window (shows pane titles). + * Delegates to the detected backend. + */ +export async function enablePaneBorderStatus( + windowTarget?: string, + useSwarmSocket = false, +): Promise { + const backend = await getBackend() + return backend.enablePaneBorderStatus(windowTarget, useSwarmSocket) +} + +/** + * Sends a command to a specific pane. + * Delegates to the detected backend. + */ +export async function sendCommandToPane( + paneId: string, + command: string, + useSwarmSocket = false, +): Promise { + const backend = await getBackend() + return backend.sendCommandToPane(paneId, command, useSwarmSocket) +} diff --git a/src/utils/swarm/teammateModel.ts b/src/utils/swarm/teammateModel.ts new file mode 100644 index 0000000000000000000000000000000000000000..0a49009b2c739956c292c5f7112eff6771acbb5f --- /dev/null +++ b/src/utils/swarm/teammateModel.ts @@ -0,0 +1,10 @@ +import { CLAUDE_OPUS_4_6_CONFIG } from '../model/configs.js' +import { getAPIProvider } from '../model/providers.js' + +// @[MODEL LAUNCH]: Update the fallback model below. +// When the user has never set teammateDefaultModel in /config, new teammates +// use Opus 4.6. Must be provider-aware so Bedrock/Vertex/Foundry customers get +// the correct model ID. +export function getHardcodedTeammateModelFallback(): string { + return CLAUDE_OPUS_4_6_CONFIG[getAPIProvider()] +} diff --git a/src/utils/swarm/teammatePromptAddendum.ts b/src/utils/swarm/teammatePromptAddendum.ts new file mode 100644 index 0000000000000000000000000000000000000000..1a5e227474763bfa0c86f22c69517cdf84a936d7 --- /dev/null +++ b/src/utils/swarm/teammatePromptAddendum.ts @@ -0,0 +1,18 @@ +/** + * Teammate-specific system prompt addendum. + * + * This is appended to the full main agent system prompt for teammates. + * It explains visibility constraints and communication requirements. + */ + +export const TEAMMATE_SYSTEM_PROMPT_ADDENDUM = ` +# Agent Teammate Communication + +IMPORTANT: You are running as an agent in a team. To communicate with anyone on your team: +- Use the SendMessage tool with \`to: ""\` to send messages to specific teammates +- Use the SendMessage tool with \`to: "*"\` sparingly for team-wide broadcasts + +Just writing a response in text is not visible to others on your team - you MUST use the SendMessage tool. + +The user interacts primarily with the team lead. Your work is coordinated through the task system and teammate messaging. +` diff --git a/src/utils/task/TaskOutput.ts b/src/utils/task/TaskOutput.ts new file mode 100644 index 0000000000000000000000000000000000000000..67cf1af8048c4263a1026532b81d579bc20613ee --- /dev/null +++ b/src/utils/task/TaskOutput.ts @@ -0,0 +1,390 @@ +import { unlink } from 'fs/promises' +import { CircularBuffer } from '../CircularBuffer.js' +import { logForDebugging } from '../debug.js' +import { readFileRange, tailFile } from '../fsOperations.js' +import { getMaxOutputLength } from '../shell/outputLimits.js' +import { safeJoinLines } from '../stringUtils.js' +import { DiskTaskOutput, getTaskOutputPath } from './diskOutput.js' + +const DEFAULT_MAX_MEMORY = 8 * 1024 * 1024 // 8MB +const POLL_INTERVAL_MS = 1000 +const PROGRESS_TAIL_BYTES = 4096 + +type ProgressCallback = ( + lastLines: string, + allLines: string, + totalLines: number, + totalBytes: number, + isIncomplete: boolean, +) => void + +/** + * Single source of truth for a shell command's output. + * + * For bash commands (file mode): both stdout and stderr go directly to + * a file via stdio fds — neither enters JS. Progress is extracted by + * polling the file tail. getStderr() returns '' since stderr is + * interleaved in the output file. + * + * For hooks (pipe mode): data flows through writeStdout()/writeStderr() + * and is buffered in memory, spilling to disk if it exceeds the limit. + */ +export class TaskOutput { + readonly taskId: string + readonly path: string + /** True when stdout goes to a file fd (bypassing JS). False for pipe mode (hooks). */ + readonly stdoutToFile: boolean + #stdoutBuffer = '' + #stderrBuffer = '' + #disk: DiskTaskOutput | null = null + #recentLines = new CircularBuffer(1000) + #totalLines = 0 + #totalBytes = 0 + #maxMemory: number + #onProgress: ProgressCallback | null + /** Set by getStdout() — true when the file was fully read (≤ maxOutputLength). */ + #outputFileRedundant = false + /** Set by getStdout() — total file size in bytes. */ + #outputFileSize = 0 + + // --- Shared poller state --- + + /** Registry of all file-mode TaskOutput instances with onProgress callbacks. */ + static #registry = new Map() + /** Subset of #registry currently being polled (visibility-driven by React). */ + static #activePolling = new Map() + static #pollInterval: ReturnType | null = null + + constructor( + taskId: string, + onProgress: ProgressCallback | null, + stdoutToFile = false, + maxMemory: number = DEFAULT_MAX_MEMORY, + ) { + this.taskId = taskId + this.path = getTaskOutputPath(taskId) + this.stdoutToFile = stdoutToFile + this.#maxMemory = maxMemory + this.#onProgress = onProgress + + // Register for polling when stdout goes to a file and progress is needed. + // Actual polling is started/stopped by React via startPolling/stopPolling. + if (stdoutToFile && onProgress) { + TaskOutput.#registry.set(taskId, this) + } + } + + /** + * Begin polling the output file for progress. Called from React + * useEffect when the progress component mounts. + */ + static startPolling(taskId: string): void { + const instance = TaskOutput.#registry.get(taskId) + if (!instance || !instance.#onProgress) { + return + } + TaskOutput.#activePolling.set(taskId, instance) + if (!TaskOutput.#pollInterval) { + TaskOutput.#pollInterval = setInterval(TaskOutput.#tick, POLL_INTERVAL_MS) + TaskOutput.#pollInterval.unref() + } + } + + /** + * Stop polling the output file. Called from React useEffect cleanup + * when the progress component unmounts. + */ + static stopPolling(taskId: string): void { + TaskOutput.#activePolling.delete(taskId) + if (TaskOutput.#activePolling.size === 0 && TaskOutput.#pollInterval) { + clearInterval(TaskOutput.#pollInterval) + TaskOutput.#pollInterval = null + } + } + + /** + * Shared tick: reads the file tail for every actively-polled task. + * Non-async body (.then) to avoid stacking if I/O is slow. + */ + static #tick(): void { + for (const [, entry] of TaskOutput.#activePolling) { + if (!entry.#onProgress) { + continue + } + void tailFile(entry.path, PROGRESS_TAIL_BYTES).then( + ({ content, bytesRead, bytesTotal }) => { + if (!entry.#onProgress) { + return + } + // Always call onProgress even when content is empty, so the + // progress loop wakes up and can check for backgrounding. + // Commands like `git log -S` produce no output for long periods. + if (!content) { + entry.#onProgress('', '', entry.#totalLines, bytesTotal, false) + return + } + // Count all newlines in the tail and capture slice points for the + // last 5 and last 100 lines. Uncapped so extrapolation stays accurate + // for dense output (short lines → >100 newlines in 4KB). + let pos = content.length + let n5 = 0 + let n100 = 0 + let lineCount = 0 + while (pos > 0) { + pos = content.lastIndexOf('\n', pos - 1) + lineCount++ + if (lineCount === 5) n5 = pos <= 0 ? 0 : pos + 1 + if (lineCount === 100) n100 = pos <= 0 ? 0 : pos + 1 + } + // lineCount is exact when the whole file fits in PROGRESS_TAIL_BYTES. + // Otherwise extrapolate from the tail sample; monotone max keeps the + // counter from going backwards when the tail has longer lines on one tick. + const totalLines = + bytesRead >= bytesTotal + ? lineCount + : Math.max( + entry.#totalLines, + Math.round((bytesTotal / bytesRead) * lineCount), + ) + entry.#totalLines = totalLines + entry.#totalBytes = bytesTotal + entry.#onProgress( + content.slice(n5), + content.slice(n100), + totalLines, + bytesTotal, + bytesRead < bytesTotal, + ) + }, + () => { + // File may not exist yet + }, + ) + } + } + + /** Write stdout data (pipe mode only — used by hooks). */ + writeStdout(data: string): void { + this.#writeBuffered(data, false) + } + + /** Write stderr data (always piped). */ + writeStderr(data: string): void { + this.#writeBuffered(data, true) + } + + #writeBuffered(data: string, isStderr: boolean): void { + this.#totalBytes += data.length + + this.#updateProgress(data) + + // Write to disk if already overflowed + if (this.#disk) { + this.#disk.append(isStderr ? `[stderr] ${data}` : data) + return + } + + // Check if this chunk would exceed the in-memory limit + const totalMem = + this.#stdoutBuffer.length + this.#stderrBuffer.length + data.length + if (totalMem > this.#maxMemory) { + this.#spillToDisk(isStderr ? data : null, isStderr ? null : data) + return + } + + if (isStderr) { + this.#stderrBuffer += data + } else { + this.#stdoutBuffer += data + } + } + + /** + * Single backward pass: count all newlines (for totalLines) and extract + * the last few lines as flat copies (for the CircularBuffer / progress). + * Only used in pipe mode (hooks). File mode uses the shared poller. + */ + #updateProgress(data: string): void { + const MAX_PROGRESS_BYTES = 4096 + const MAX_PROGRESS_LINES = 100 + + let lineCount = 0 + const lines: string[] = [] + let extractedBytes = 0 + let pos = data.length + + while (pos > 0) { + const prev = data.lastIndexOf('\n', pos - 1) + if (prev === -1) { + break + } + lineCount++ + if ( + lines.length < MAX_PROGRESS_LINES && + extractedBytes < MAX_PROGRESS_BYTES + ) { + const lineLen = pos - prev - 1 + if (lineLen > 0 && lineLen <= MAX_PROGRESS_BYTES - extractedBytes) { + const line = data.slice(prev + 1, pos) + if (line.trim()) { + lines.push(Buffer.from(line).toString()) + extractedBytes += lineLen + } + } + } + pos = prev + } + + this.#totalLines += lineCount + + for (let i = lines.length - 1; i >= 0; i--) { + this.#recentLines.add(lines[i]!) + } + + if (this.#onProgress && lines.length > 0) { + const recent = this.#recentLines.getRecent(5) + this.#onProgress( + safeJoinLines(recent, '\n'), + safeJoinLines(this.#recentLines.getRecent(100), '\n'), + this.#totalLines, + this.#totalBytes, + this.#disk !== null, + ) + } + } + + #spillToDisk(stderrChunk: string | null, stdoutChunk: string | null): void { + this.#disk = new DiskTaskOutput(this.taskId) + + // Flush existing buffers + if (this.#stdoutBuffer) { + this.#disk.append(this.#stdoutBuffer) + this.#stdoutBuffer = '' + } + if (this.#stderrBuffer) { + this.#disk.append(`[stderr] ${this.#stderrBuffer}`) + this.#stderrBuffer = '' + } + + // Write the chunk that triggered overflow + if (stdoutChunk) { + this.#disk.append(stdoutChunk) + } + if (stderrChunk) { + this.#disk.append(`[stderr] ${stderrChunk}`) + } + } + + /** + * Get stdout. In file mode, reads from the output file. + * In pipe mode, returns the in-memory buffer or tail from CircularBuffer. + */ + async getStdout(): Promise { + if (this.stdoutToFile) { + return this.#readStdoutFromFile() + } + // Pipe mode (hooks) — use in-memory data + if (this.#disk) { + const recent = this.#recentLines.getRecent(5) + const tail = safeJoinLines(recent, '\n') + const sizeKB = Math.round(this.#totalBytes / 1024) + const notice = `\nOutput truncated (${sizeKB}KB total). Full output saved to: ${this.path}` + return tail ? tail + notice : notice.trimStart() + } + return this.#stdoutBuffer + } + + async #readStdoutFromFile(): Promise { + const maxBytes = getMaxOutputLength() + try { + const result = await readFileRange(this.path, 0, maxBytes) + if (!result) { + this.#outputFileRedundant = true + return '' + } + const { content, bytesRead, bytesTotal } = result + // If the file fits, it's fully captured inline and can be deleted. + // If not, return what we read — processToolResultBlock handles + // the formatting and persistence downstream. + this.#outputFileSize = bytesTotal + this.#outputFileRedundant = bytesTotal <= bytesRead + return content + } catch (err) { + // Surface the error instead of silently returning empty. An ENOENT here + // means the output file was deleted while the command was running + // (historically: cross-session startup cleanup in the same project dir). + // Returning a diagnostic string keeps the tool_result non-empty, which + // avoids reminder-only-at-tail confusion downstream and tells the model + // (and us, via the transcript) what actually happened. + const code = + err instanceof Error && 'code' in err ? String(err.code) : 'unknown' + logForDebugging( + `TaskOutput.#readStdoutFromFile: failed to read ${this.path} (${code}): ${err}`, + ) + return `` + } + } + + /** Sync getter for ExecResult.stderr */ + getStderr(): string { + if (this.#disk) { + return '' + } + return this.#stderrBuffer + } + + get isOverflowed(): boolean { + return this.#disk !== null + } + + get totalLines(): number { + return this.#totalLines + } + + get totalBytes(): number { + return this.#totalBytes + } + + /** + * True after getStdout() when the output file was fully read. + * The file content is redundant (fully in ExecResult.stdout) and can be deleted. + */ + get outputFileRedundant(): boolean { + return this.#outputFileRedundant + } + + /** Total file size in bytes, set after getStdout() reads the file. */ + get outputFileSize(): number { + return this.#outputFileSize + } + + /** Force all buffered content to disk. Call when backgrounding. */ + spillToDisk(): void { + if (!this.#disk) { + this.#spillToDisk(null, null) + } + } + + async flush(): Promise { + await this.#disk?.flush() + } + + /** Delete the output file (fire-and-forget safe). */ + async deleteOutputFile(): Promise { + try { + await unlink(this.path) + } catch { + // File may already be deleted or not exist + } + } + + clear(): void { + this.#stdoutBuffer = '' + this.#stderrBuffer = '' + this.#recentLines.clear() + this.#onProgress = null + this.#disk?.cancel() + TaskOutput.stopPolling(this.taskId) + TaskOutput.#registry.delete(this.taskId) + } +} diff --git a/src/utils/task/diskOutput.ts b/src/utils/task/diskOutput.ts new file mode 100644 index 0000000000000000000000000000000000000000..b22018dbdc882934969666e6cfc3ecf9fa7512b9 --- /dev/null +++ b/src/utils/task/diskOutput.ts @@ -0,0 +1,451 @@ +import { constants as fsConstants } from 'fs' +import { + type FileHandle, + mkdir, + open, + stat, + symlink, + unlink, +} from 'fs/promises' +import { join } from 'path' +import { getSessionId } from '../../bootstrap/state.js' +import { getErrnoCode } from '../errors.js' +import { readFileRange, tailFile } from '../fsOperations.js' +import { logError } from '../log.js' +import { getProjectTempDir } from '../permissions/filesystem.js' + +// SECURITY: O_NOFOLLOW prevents following symlinks when opening task output files. +// Without this, an attacker in the sandbox could create symlinks in the tasks directory +// pointing to arbitrary files, causing Claude Code on the host to write to those files. +// O_NOFOLLOW is not available on Windows, but the sandbox attack vector is Unix-only. +const O_NOFOLLOW = fsConstants.O_NOFOLLOW ?? 0 + +const DEFAULT_MAX_READ_BYTES = 8 * 1024 * 1024 // 8MB + +/** + * Disk cap for task output files. In file mode (bash), a watchdog polls + * file size and kills the process. In pipe mode (hooks), DiskTaskOutput + * drops chunks past this limit. Shared so both caps stay in sync. + */ +export const MAX_TASK_OUTPUT_BYTES = 5 * 1024 * 1024 * 1024 +export const MAX_TASK_OUTPUT_BYTES_DISPLAY = '5GB' + +/** + * Get the task output directory for this session. + * Uses project temp directory so reads are auto-allowed by checkReadableInternalPath. + * + * The session ID is included so concurrent sessions in the same project don't + * clobber each other's output files. Startup cleanup in one session previously + * unlinked in-flight output files from other sessions — the writing process's fd + * keeps the inode alive but reads via path fail ENOENT, and getStdout() returned + * empty string (inc-4586 / boris-20260309-060423). + * + * The session ID is captured at FIRST CALL, not re-read on every invocation. + * /clear calls regenerateSessionId(), which would otherwise cause + * ensureOutputDir() to create a new-session path while existing TaskOutput + * instances still hold old-session paths — open() would ENOENT. Background + * bash tasks surviving /clear need their output files to stay reachable. + */ +let _taskOutputDir: string | undefined +export function getTaskOutputDir(): string { + if (_taskOutputDir === undefined) { + _taskOutputDir = join(getProjectTempDir(), getSessionId(), 'tasks') + } + return _taskOutputDir +} + +/** Test helper — clears the memoized dir. */ +export function _resetTaskOutputDirForTest(): void { + _taskOutputDir = undefined +} + +/** + * Ensure the task output directory exists + */ +async function ensureOutputDir(): Promise { + await mkdir(getTaskOutputDir(), { recursive: true }) +} + +/** + * Get the output file path for a task + */ +export function getTaskOutputPath(taskId: string): string { + return join(getTaskOutputDir(), `${taskId}.output`) +} + +// Tracks fire-and-forget promises (initTaskOutput, initTaskOutputAsSymlink, +// evictTaskOutput, #drain) so tests can drain before teardown. Prevents the +// async-ENOENT-after-teardown flake class (#24957, #25065): a voided async +// resumes after preload's afterEach nuked the temp dir → ENOENT → unhandled +// rejection → flaky test failure. allSettled so a rejection doesn't short- +// circuit the drain and leave other ops racing the rmSync. +const _pendingOps = new Set>() +function track(p: Promise): Promise { + _pendingOps.add(p) + void p.finally(() => _pendingOps.delete(p)).catch(() => {}) + return p +} + +/** + * Encapsulates async disk writes for a single task's output. + * + * Uses a flat array as a write queue processed by a single drain loop, + * so each chunk can be GC'd immediately after its write completes. + * This avoids the memory retention problem of chained .then() closures + * where every reaction captures its data until the whole chain resolves. + */ +export class DiskTaskOutput { + #path: string + #fileHandle: FileHandle | null = null + #queue: string[] = [] + #bytesWritten = 0 + #capped = false + #flushPromise: Promise | null = null + #flushResolve: (() => void) | null = null + + constructor(taskId: string) { + this.#path = getTaskOutputPath(taskId) + } + + append(content: string): void { + if (this.#capped) { + return + } + // content.length (UTF-16 code units) undercounts UTF-8 bytes by at most ~3×. + // Acceptable for a coarse disk-fill guard — avoids re-scanning every chunk. + this.#bytesWritten += content.length + if (this.#bytesWritten > MAX_TASK_OUTPUT_BYTES) { + this.#capped = true + this.#queue.push( + `\n[output truncated: exceeded ${MAX_TASK_OUTPUT_BYTES_DISPLAY} disk cap]\n`, + ) + } else { + this.#queue.push(content) + } + if (!this.#flushPromise) { + this.#flushPromise = new Promise(resolve => { + this.#flushResolve = resolve + }) + void track(this.#drain()) + } + } + + flush(): Promise { + return this.#flushPromise ?? Promise.resolve() + } + + cancel(): void { + this.#queue.length = 0 + } + + async #drainAllChunks(): Promise { + while (true) { + try { + if (!this.#fileHandle) { + await ensureOutputDir() + this.#fileHandle = await open( + this.#path, + process.platform === 'win32' + ? 'a' + : fsConstants.O_WRONLY | + fsConstants.O_APPEND | + fsConstants.O_CREAT | + O_NOFOLLOW, + ) + } + while (true) { + await this.#writeAllChunks() + if (this.#queue.length === 0) { + break + } + } + } finally { + if (this.#fileHandle) { + const fileHandle = this.#fileHandle + this.#fileHandle = null + await fileHandle.close() + } + } + // you could have another .append() while we're waiting for the file to close, so we check the queue again before fully exiting + if (this.#queue.length) { + continue + } + + break + } + } + + #writeAllChunks(): Promise { + // This code is extremely precise. + // You **must not** add an await here!! That will cause memory to balloon as the queue grows. + // It's okay to add an `await` to the caller of this method (e.g. #drainAllChunks) because that won't cause Buffer[] to be kept alive in memory. + return this.#fileHandle!.appendFile( + // This variable needs to get GC'd ASAP. + this.#queueToBuffers(), + ) + } + + /** Keep this in a separate method so that GC doesn't keep it alive for any longer than it should. */ + #queueToBuffers(): Buffer { + // Use .splice to in-place mutate the array, informing the GC it can free it. + const queue = this.#queue.splice(0, this.#queue.length) + + let totalLength = 0 + for (const str of queue) { + totalLength += Buffer.byteLength(str, 'utf8') + } + + const buffer = Buffer.allocUnsafe(totalLength) + let offset = 0 + for (const str of queue) { + offset += buffer.write(str, offset, 'utf8') + } + + return buffer + } + + async #drain(): Promise { + try { + await this.#drainAllChunks() + } catch (e) { + // Transient fs errors (EMFILE on busy CI, EPERM on Windows pending- + // delete) previously rode up through `void this.#drain()` as an + // unhandled rejection while the flush promise resolved anyway — callers + // saw an empty file with no error. Retry once for the transient case + // (queue is intact if open() failed), then log and give up. + logError(e) + if (this.#queue.length > 0) { + try { + await this.#drainAllChunks() + } catch (e2) { + logError(e2) + } + } + } finally { + const resolve = this.#flushResolve! + this.#flushPromise = null + this.#flushResolve = null + resolve() + } + } +} + +const outputs = new Map() + +/** + * Test helper — cancel pending writes, await in-flight ops, clear the map. + * backgroundShells.test.ts and other task tests spawn real shells that + * write through this module without afterEach cleanup; their entries + * leak into diskOutput.test.ts on the same shard. + * + * Awaits all tracked promises until the set stabilizes — a settling promise + * may spawn another (initTaskOutputAsSymlink's catch → initTaskOutput). + * Call this in afterEach BEFORE rmSync to avoid async-ENOENT-after-teardown. + */ +export async function _clearOutputsForTest(): Promise { + for (const output of outputs.values()) { + output.cancel() + } + while (_pendingOps.size > 0) { + await Promise.allSettled([..._pendingOps]) + } + outputs.clear() +} + +function getOrCreateOutput(taskId: string): DiskTaskOutput { + let output = outputs.get(taskId) + if (!output) { + output = new DiskTaskOutput(taskId) + outputs.set(taskId, output) + } + return output +} + +/** + * Append output to a task's disk file asynchronously. + * Creates the file if it doesn't exist. + */ +export function appendTaskOutput(taskId: string, content: string): void { + getOrCreateOutput(taskId).append(content) +} + +/** + * Wait for all pending writes for a task to complete. + * Useful before reading output to ensure all data is flushed. + */ +export async function flushTaskOutput(taskId: string): Promise { + const output = outputs.get(taskId) + if (output) { + await output.flush() + } +} + +/** + * Evict a task's DiskTaskOutput from the in-memory map after flushing. + * Unlike cleanupTaskOutput, this does not delete the output file on disk. + * Call this when a task completes and its output has been consumed. + */ +export function evictTaskOutput(taskId: string): Promise { + return track( + (async () => { + const output = outputs.get(taskId) + if (output) { + await output.flush() + outputs.delete(taskId) + } + })(), + ) +} + +/** + * Get delta (new content) since last read. + * Reads only from the byte offset, up to maxBytes — never loads the full file. + */ +export async function getTaskOutputDelta( + taskId: string, + fromOffset: number, + maxBytes: number = DEFAULT_MAX_READ_BYTES, +): Promise<{ content: string; newOffset: number }> { + try { + const result = await readFileRange( + getTaskOutputPath(taskId), + fromOffset, + maxBytes, + ) + if (!result) { + return { content: '', newOffset: fromOffset } + } + return { + content: result.content, + newOffset: fromOffset + result.bytesRead, + } + } catch (e) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + return { content: '', newOffset: fromOffset } + } + logError(e) + return { content: '', newOffset: fromOffset } + } +} + +/** + * Get output for a task, reading the tail of the file. + * Caps at maxBytes to avoid loading multi-GB files into memory. + */ +export async function getTaskOutput( + taskId: string, + maxBytes: number = DEFAULT_MAX_READ_BYTES, +): Promise { + try { + const { content, bytesTotal, bytesRead } = await tailFile( + getTaskOutputPath(taskId), + maxBytes, + ) + if (bytesTotal > bytesRead) { + return `[${Math.round((bytesTotal - bytesRead) / 1024)}KB of earlier output omitted]\n${content}` + } + return content + } catch (e) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + return '' + } + logError(e) + return '' + } +} + +/** + * Get the current size (offset) of a task's output file. + */ +export async function getTaskOutputSize(taskId: string): Promise { + try { + return (await stat(getTaskOutputPath(taskId))).size + } catch (e) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + return 0 + } + logError(e) + return 0 + } +} + +/** + * Clean up a task's output file and write queue. + */ +export async function cleanupTaskOutput(taskId: string): Promise { + const output = outputs.get(taskId) + if (output) { + output.cancel() + outputs.delete(taskId) + } + + try { + await unlink(getTaskOutputPath(taskId)) + } catch (e) { + const code = getErrnoCode(e) + if (code === 'ENOENT') { + return + } + logError(e) + } +} + +/** + * Initialize output file for a new task. + * Creates an empty file to ensure the path exists. + */ +export function initTaskOutput(taskId: string): Promise { + return track( + (async () => { + await ensureOutputDir() + const outputPath = getTaskOutputPath(taskId) + // SECURITY: O_NOFOLLOW prevents symlink-following attacks from the sandbox. + // O_EXCL ensures we create a new file and fail if something already exists at this path. + // On Windows, use string flags — numeric O_EXCL can produce EINVAL through libuv. + const fh = await open( + outputPath, + process.platform === 'win32' + ? 'wx' + : fsConstants.O_WRONLY | + fsConstants.O_CREAT | + fsConstants.O_EXCL | + O_NOFOLLOW, + ) + await fh.close() + return outputPath + })(), + ) +} + +/** + * Initialize output file as a symlink to another file (e.g., agent transcript). + * Tries to create the symlink first; if a file already exists, removes it and retries. + */ +export function initTaskOutputAsSymlink( + taskId: string, + targetPath: string, +): Promise { + return track( + (async () => { + try { + await ensureOutputDir() + const outputPath = getTaskOutputPath(taskId) + + try { + await symlink(targetPath, outputPath) + } catch { + await unlink(outputPath) + await symlink(targetPath, outputPath) + } + + return outputPath + } catch (error) { + logError(error) + return initTaskOutput(taskId) + } + })(), + ) +} diff --git a/src/utils/task/framework.ts b/src/utils/task/framework.ts new file mode 100644 index 0000000000000000000000000000000000000000..7bb5099683d1f85c6a72bf4af66152e9bf244a55 --- /dev/null +++ b/src/utils/task/framework.ts @@ -0,0 +1,308 @@ +import { + OUTPUT_FILE_TAG, + STATUS_TAG, + SUMMARY_TAG, + TASK_ID_TAG, + TASK_NOTIFICATION_TAG, + TASK_TYPE_TAG, + TOOL_USE_ID_TAG, +} from '../../constants/xml.js' +import type { AppState } from '../../state/AppState.js' +import { + isTerminalTaskStatus, + type TaskStatus, + type TaskType, +} from '../../Task.js' +import type { TaskState } from '../../tasks/types.js' +import { enqueuePendingNotification } from '../messageQueueManager.js' +import { enqueueSdkEvent } from '../sdkEventQueue.js' +import { getTaskOutputDelta, getTaskOutputPath } from './diskOutput.js' + +// Standard polling interval for all tasks +export const POLL_INTERVAL_MS = 1000 + +// Duration to display killed tasks before eviction +export const STOPPED_DISPLAY_MS = 3_000 + +// Grace period for terminal local_agent tasks in the coordinator panel +export const PANEL_GRACE_MS = 30_000 + +// Attachment type for task status updates +export type TaskAttachment = { + type: 'task_status' + taskId: string + toolUseId?: string + taskType: TaskType + status: TaskStatus + description: string + deltaSummary: string | null // New output since last attachment +} + +type SetAppState = (updater: (prev: AppState) => AppState) => void + +/** + * Update a task's state in AppState. + * Helper function for task implementations. + * Generic to allow type-safe updates for specific task types. + */ +export function updateTaskState( + taskId: string, + setAppState: SetAppState, + updater: (task: T) => T, +): void { + setAppState(prev => { + const task = prev.tasks?.[taskId] as T | undefined + if (!task) { + return prev + } + const updated = updater(task) + if (updated === task) { + // Updater returned the same reference (early-return no-op). Skip the + // spread so s.tasks subscribers don't re-render on unchanged state. + return prev + } + return { + ...prev, + tasks: { + ...prev.tasks, + [taskId]: updated, + }, + } + }) +} + +/** + * Register a new task in AppState. + */ +export function registerTask(task: TaskState, setAppState: SetAppState): void { + let isReplacement = false + setAppState(prev => { + const existing = prev.tasks[task.id] + isReplacement = existing !== undefined + // Carry forward UI-held state on re-register (resumeAgentBackground + // replaces the task; user's retain shouldn't reset). startTime keeps + // the panel sort stable; messages + diskLoaded preserve the viewed + // transcript across the replace (the user's just-appended prompt lives + // in messages and isn't on disk yet). + const merged = + existing && 'retain' in existing + ? { + ...task, + retain: existing.retain, + startTime: existing.startTime, + messages: existing.messages, + diskLoaded: existing.diskLoaded, + pendingMessages: existing.pendingMessages, + } + : task + return { ...prev, tasks: { ...prev.tasks, [task.id]: merged } } + }) + + // Replacement (resume) — not a new start. Skip to avoid double-emit. + if (isReplacement) return + + enqueueSdkEvent({ + type: 'system', + subtype: 'task_started', + task_id: task.id, + tool_use_id: task.toolUseId, + description: task.description, + task_type: task.type, + workflow_name: + 'workflowName' in task + ? (task.workflowName as string | undefined) + : undefined, + prompt: 'prompt' in task ? (task.prompt as string) : undefined, + }) +} + +/** + * Eagerly evict a terminal task from AppState. + * The task must be in a terminal state (completed/failed/killed) with notified=true. + * This allows memory to be freed without waiting for the next query loop iteration. + * The lazy GC in generateTaskAttachments() remains as a safety net. + */ +export function evictTerminalTask( + taskId: string, + setAppState: SetAppState, +): void { + setAppState(prev => { + const task = prev.tasks?.[taskId] + if (!task) return prev + if (!isTerminalTaskStatus(task.status)) return prev + if (!task.notified) return prev + // Panel grace period — blocks eviction until deadline passes. + // 'retain' in task narrows to LocalAgentTaskState (the only type with + // that field); evictAfter is optional so 'evictAfter' in task would + // miss tasks that haven't had it set yet. + if ('retain' in task && (task.evictAfter ?? Infinity) > Date.now()) { + return prev + } + const { [taskId]: _, ...remainingTasks } = prev.tasks + return { ...prev, tasks: remainingTasks } + }) +} + +/** + * Get all running tasks. + */ +export function getRunningTasks(state: AppState): TaskState[] { + const tasks = state.tasks ?? {} + return Object.values(tasks).filter(task => task.status === 'running') +} + +/** + * Generate attachments for tasks with new output or status changes. + * Called by the framework to create push notifications. + */ +export async function generateTaskAttachments(state: AppState): Promise<{ + attachments: TaskAttachment[] + // Only the offset patch — NOT the full task. The task may transition to + // completed during getTaskOutputDelta's async disk read, and spreading the + // full stale snapshot would clobber that transition (zombifying the task). + updatedTaskOffsets: Record + evictedTaskIds: string[] +}> { + const attachments: TaskAttachment[] = [] + const updatedTaskOffsets: Record = {} + const evictedTaskIds: string[] = [] + const tasks = state.tasks ?? {} + + for (const taskState of Object.values(tasks)) { + if (taskState.notified) { + switch (taskState.status) { + case 'completed': + case 'failed': + case 'killed': + // Evict terminal tasks — they've been consumed and can be GC'd + evictedTaskIds.push(taskState.id) + continue + case 'pending': + // Keep in map — hasn't run yet, but parent already knows about it + continue + case 'running': + // Fall through to running logic below + break + } + } + + if (taskState.status === 'running') { + const delta = await getTaskOutputDelta( + taskState.id, + taskState.outputOffset, + ) + if (delta.content) { + updatedTaskOffsets[taskState.id] = delta.newOffset + } + } + + // Completed tasks are NOT notified here — each task type handles its own + // completion notification via enqueuePendingNotification(). Generating + // attachments here would race with those per-type callbacks, causing + // dual delivery (one inline attachment + one separate API turn). + } + + return { attachments, updatedTaskOffsets, evictedTaskIds } +} + +/** + * Apply the outputOffset patches and evictions from generateTaskAttachments. + * Merges patches against FRESH prev.tasks (not the stale pre-await snapshot), + * so concurrent status transitions aren't clobbered. + */ +export function applyTaskOffsetsAndEvictions( + setAppState: SetAppState, + updatedTaskOffsets: Record, + evictedTaskIds: string[], +): void { + const offsetIds = Object.keys(updatedTaskOffsets) + if (offsetIds.length === 0 && evictedTaskIds.length === 0) { + return + } + setAppState(prev => { + let changed = false + const newTasks = { ...prev.tasks } + for (const id of offsetIds) { + const fresh = newTasks[id] + // Re-check status on fresh state — task may have completed during the + // await. If it's no longer running, the offset update is moot. + if (fresh?.status === 'running') { + newTasks[id] = { ...fresh, outputOffset: updatedTaskOffsets[id]! } + changed = true + } + } + for (const id of evictedTaskIds) { + const fresh = newTasks[id] + // Re-check terminal+notified on fresh state (TOCTOU: resume may have + // replaced the task during the generateTaskAttachments await) + if (!fresh || !isTerminalTaskStatus(fresh.status) || !fresh.notified) { + continue + } + if ('retain' in fresh && (fresh.evictAfter ?? Infinity) > Date.now()) { + continue + } + delete newTasks[id] + changed = true + } + return changed ? { ...prev, tasks: newTasks } : prev + }) +} + +/** + * Poll all running tasks and check for updates. + * This is the main polling loop called by the framework. + */ +export async function pollTasks( + getAppState: () => AppState, + setAppState: SetAppState, +): Promise { + const state = getAppState() + const { attachments, updatedTaskOffsets, evictedTaskIds } = + await generateTaskAttachments(state) + + applyTaskOffsetsAndEvictions(setAppState, updatedTaskOffsets, evictedTaskIds) + + // Send notifications for completed tasks + for (const attachment of attachments) { + enqueueTaskNotification(attachment) + } +} + +/** + * Enqueue a task notification to the message queue. + */ +function enqueueTaskNotification(attachment: TaskAttachment): void { + const statusText = getStatusText(attachment.status) + + const outputPath = getTaskOutputPath(attachment.taskId) + const toolUseIdLine = attachment.toolUseId + ? `\n<${TOOL_USE_ID_TAG}>${attachment.toolUseId}` + : '' + const message = `<${TASK_NOTIFICATION_TAG}> +<${TASK_ID_TAG}>${attachment.taskId}${toolUseIdLine} +<${TASK_TYPE_TAG}>${attachment.taskType} +<${OUTPUT_FILE_TAG}>${outputPath} +<${STATUS_TAG}>${attachment.status} +<${SUMMARY_TAG}>Task "${attachment.description}" ${statusText} +` + + enqueuePendingNotification({ value: message, mode: 'task-notification' }) +} + +/** + * Get human-readable status text. + */ +function getStatusText(status: TaskStatus): string { + switch (status) { + case 'completed': + return 'completed successfully' + case 'failed': + return 'failed' + case 'killed': + return 'was stopped' + case 'running': + return 'is running' + case 'pending': + return 'is pending' + } +} diff --git a/src/utils/task/outputFormatting.ts b/src/utils/task/outputFormatting.ts new file mode 100644 index 0000000000000000000000000000000000000000..8cc99c92a57dbc02e16a2c0b7428aa9e72116ab8 --- /dev/null +++ b/src/utils/task/outputFormatting.ts @@ -0,0 +1,38 @@ +import { validateBoundedIntEnvVar } from '../envValidation.js' +import { getTaskOutputPath } from './diskOutput.js' + +export const TASK_MAX_OUTPUT_UPPER_LIMIT = 160_000 +export const TASK_MAX_OUTPUT_DEFAULT = 32_000 + +export function getMaxTaskOutputLength(): number { + const result = validateBoundedIntEnvVar( + 'TASK_MAX_OUTPUT_LENGTH', + process.env.TASK_MAX_OUTPUT_LENGTH, + TASK_MAX_OUTPUT_DEFAULT, + TASK_MAX_OUTPUT_UPPER_LIMIT, + ) + return result.effective +} + +/** + * Format task output for API consumption, truncating if too large. + * When truncated, includes a header with the file path and returns + * the last N characters that fit within the limit. + */ +export function formatTaskOutput( + output: string, + taskId: string, +): { content: string; wasTruncated: boolean } { + const maxLen = getMaxTaskOutputLength() + + if (output.length <= maxLen) { + return { content: output, wasTruncated: false } + } + + const filePath = getTaskOutputPath(taskId) + const header = `[Truncated. Full output: ${filePath}]\n\n` + const availableSpace = maxLen - header.length + const truncated = output.slice(-availableSpace) + + return { content: header + truncated, wasTruncated: true } +} diff --git a/src/utils/task/sdkProgress.ts b/src/utils/task/sdkProgress.ts new file mode 100644 index 0000000000000000000000000000000000000000..1430df2955c4d2a5200479425fd0a10b8ffc482a --- /dev/null +++ b/src/utils/task/sdkProgress.ts @@ -0,0 +1,36 @@ +import type { SdkWorkflowProgress } from '../../types/tools.js' +import { enqueueSdkEvent } from '../sdkEventQueue.js' + +/** + * Emit a `task_progress` SDK event. Shared by background agents (per tool_use + * in runAsyncAgentLifecycle) and workflows (per flushProgress batch). Accepts + * already-computed primitives so callers can derive them from their own state + * shapes (ProgressTracker for agents, LocalWorkflowTaskState for workflows). + */ +export function emitTaskProgress(params: { + taskId: string + toolUseId: string | undefined + description: string + startTime: number + totalTokens: number + toolUses: number + lastToolName?: string + summary?: string + workflowProgress?: SdkWorkflowProgress[] +}): void { + enqueueSdkEvent({ + type: 'system', + subtype: 'task_progress', + task_id: params.taskId, + tool_use_id: params.toolUseId, + description: params.description, + usage: { + total_tokens: params.totalTokens, + tool_uses: params.toolUses, + duration_ms: Date.now() - params.startTime, + }, + last_tool_name: params.lastToolName, + summary: params.summary, + workflow_progress: params.workflowProgress, + }) +} diff --git a/src/utils/telemetry/betaSessionTracing.ts b/src/utils/telemetry/betaSessionTracing.ts new file mode 100644 index 0000000000000000000000000000000000000000..6699721e2e045805b46e3b27d352cd9f5f01e5f4 --- /dev/null +++ b/src/utils/telemetry/betaSessionTracing.ts @@ -0,0 +1,491 @@ +/** + * Beta Session Tracing for Claude Code + * + * This module contains beta tracing features enabled when + * ENABLE_BETA_TRACING_DETAILED=1 and BETA_TRACING_ENDPOINT are set. + * + * For external users, tracing is enabled in SDK/headless mode, or in + * interactive mode when the org is allowlisted via the + * tengu_trace_lantern GrowthBook gate. + * For ant users, tracing is enabled in all modes. + * + * Visibility Rules: + * | Content | External | Ant | + * |------------------|----------|------| + * | System prompts | ✅ | ✅ | + * | Model output | ✅ | ✅ | + * | Thinking output | ❌ | ✅ | + * | Tools | ✅ | ✅ | + * | new_context | ✅ | ✅ | + * + * Features: + * - Per-agent message tracking with hash-based deduplication + * - System prompt logging (once per unique hash) + * - Hook execution spans + * - Detailed new_context attributes for LLM requests + */ + +import type { Span } from '@opentelemetry/api' +import { createHash } from 'crypto' +import { getIsNonInteractiveSession } from '../../bootstrap/state.js' +import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js' +import { sanitizeToolNameForAnalytics } from '../../services/analytics/metadata.js' +import type { AssistantMessage, UserMessage } from '../../types/message.js' +import { isEnvTruthy } from '../envUtils.js' +import { jsonParse, jsonStringify } from '../slowOperations.js' +import { logOTelEvent } from './events.js' + +// Message type for API calls (UserMessage or AssistantMessage) +type APIMessage = UserMessage | AssistantMessage + +/** + * Track hashes we've already logged this session (system prompts, tools, etc). + * + * WHY: System prompts and tool schemas are large and rarely change within a session. + * Sending full content on every request would be wasteful. Instead, we hash and + * only log the full content once per unique hash. + */ +const seenHashes = new Set() + +/** + * Track the last reported message hash per querySource (agent) for incremental context. + * + * WHY: When debugging traces, we want to see what NEW information was added each turn, + * not the entire conversation history (which can be huge). By tracking the last message + * we reported per agent, we can compute and send only the delta (new messages since + * the last request). This is tracked per-agent (querySource) because different agents + * (main thread, subagents, warmup requests) have independent conversation contexts. + */ +const lastReportedMessageHash = new Map() + +/** + * Clear tracking state after compaction. + * Old hashes are irrelevant once messages have been replaced. + */ +export function clearBetaTracingState(): void { + seenHashes.clear() + lastReportedMessageHash.clear() +} + +const MAX_CONTENT_SIZE = 60 * 1024 // 60KB (Honeycomb limit is 64KB, staying safe) + +/** + * Check if beta detailed tracing is enabled. + * - Requires ENABLE_BETA_TRACING_DETAILED=1 and BETA_TRACING_ENDPOINT + * - For external users, enabled in SDK/headless mode OR when org is + * allowlisted via the tengu_trace_lantern GrowthBook gate + */ +export function isBetaTracingEnabled(): boolean { + const baseEnabled = + isEnvTruthy(process.env.ENABLE_BETA_TRACING_DETAILED) && + Boolean(process.env.BETA_TRACING_ENDPOINT) + + if (!baseEnabled) { + return false + } + + // For external users, enable in SDK/headless mode OR when org is allowlisted. + // Gate reads from disk cache, so first run after allowlisting returns false; + // works from second run onward (same behavior as enhanced_telemetry_beta). + if (process.env.USER_TYPE !== 'ant') { + return ( + getIsNonInteractiveSession() || + getFeatureValue_CACHED_MAY_BE_STALE('tengu_trace_lantern', false) + ) + } + + return true +} + +/** + * Truncate content to fit within Honeycomb limits. + */ +export function truncateContent( + content: string, + maxSize: number = MAX_CONTENT_SIZE, +): { content: string; truncated: boolean } { + if (content.length <= maxSize) { + return { content, truncated: false } + } + + return { + content: + content.slice(0, maxSize) + + '\n\n[TRUNCATED - Content exceeds 60KB limit]', + truncated: true, + } +} + +/** + * Generate a short hash (first 12 hex chars of SHA-256). + */ +function shortHash(content: string): string { + return createHash('sha256').update(content).digest('hex').slice(0, 12) +} + +/** + * Generate a hash for a system prompt. + */ +function hashSystemPrompt(systemPrompt: string): string { + return `sp_${shortHash(systemPrompt)}` +} + +/** + * Generate a hash for a message based on its content. + */ +function hashMessage(message: APIMessage): string { + const content = jsonStringify(message.message.content) + return `msg_${shortHash(content)}` +} + +// Regex to detect content wrapped in tags +const SYSTEM_REMINDER_REGEX = + /^\n?([\s\S]*?)\n?<\/system-reminder>$/ + +/** + * Check if text is entirely a system reminder (wrapped in tags). + * Returns the inner content if it is, null otherwise. + */ +function extractSystemReminderContent(text: string): string | null { + const match = text.trim().match(SYSTEM_REMINDER_REGEX) + return match && match[1] ? match[1].trim() : null +} + +/** + * Result of formatting messages - separates regular content from system reminders. + */ +interface FormattedMessages { + contextParts: string[] + systemReminders: string[] +} + +/** + * Format user messages for new_context display, separating system reminders. + * Only handles user messages (assistant messages are filtered out before this is called). + */ +function formatMessagesForContext(messages: UserMessage[]): FormattedMessages { + const contextParts: string[] = [] + const systemReminders: string[] = [] + + for (const message of messages) { + const content = message.message.content + if (typeof content === 'string') { + const reminderContent = extractSystemReminderContent(content) + if (reminderContent) { + systemReminders.push(reminderContent) + } else { + contextParts.push(`[USER]\n${content}`) + } + } else if (Array.isArray(content)) { + for (const block of content) { + if (block.type === 'text') { + const reminderContent = extractSystemReminderContent(block.text) + if (reminderContent) { + systemReminders.push(reminderContent) + } else { + contextParts.push(`[USER]\n${block.text}`) + } + } else if (block.type === 'tool_result') { + const resultContent = + typeof block.content === 'string' + ? block.content + : jsonStringify(block.content) + // Tool results can also contain system reminders (e.g., malware warning) + const reminderContent = extractSystemReminderContent(resultContent) + if (reminderContent) { + systemReminders.push(reminderContent) + } else { + contextParts.push( + `[TOOL RESULT: ${block.tool_use_id}]\n${resultContent}`, + ) + } + } + } + } + } + + return { contextParts, systemReminders } +} + +export interface LLMRequestNewContext { + /** System prompt (typically only on first request or if changed) */ + systemPrompt?: string + /** Query source identifying the agent/purpose (e.g., 'repl_main_thread', 'agent:builtin') */ + querySource?: string + /** Tool schemas sent with the request */ + tools?: string +} + +/** + * Add beta attributes to an interaction span. + * Adds new_context with the user prompt. + */ +export function addBetaInteractionAttributes( + span: Span, + userPrompt: string, +): void { + if (!isBetaTracingEnabled()) { + return + } + + const { content: truncatedPrompt, truncated } = truncateContent( + `[USER PROMPT]\n${userPrompt}`, + ) + span.setAttributes({ + new_context: truncatedPrompt, + ...(truncated && { + new_context_truncated: true, + new_context_original_length: userPrompt.length, + }), + }) +} + +/** + * Add beta attributes to an LLM request span. + * Handles system prompt logging and new_context computation. + */ +export function addBetaLLMRequestAttributes( + span: Span, + newContext?: LLMRequestNewContext, + messagesForAPI?: APIMessage[], +): void { + if (!isBetaTracingEnabled()) { + return + } + + // Add system prompt info to the span + if (newContext?.systemPrompt) { + const promptHash = hashSystemPrompt(newContext.systemPrompt) + const preview = newContext.systemPrompt.slice(0, 500) + + // Always add hash, preview, and length to the span + span.setAttribute('system_prompt_hash', promptHash) + span.setAttribute('system_prompt_preview', preview) + span.setAttribute('system_prompt_length', newContext.systemPrompt.length) + + // Log the full system prompt only once per unique hash this session + if (!seenHashes.has(promptHash)) { + seenHashes.add(promptHash) + + // Truncate for the log if needed + const { content: truncatedPrompt, truncated } = truncateContent( + newContext.systemPrompt, + ) + + void logOTelEvent('system_prompt', { + system_prompt_hash: promptHash, + system_prompt: truncatedPrompt, + system_prompt_length: String(newContext.systemPrompt.length), + ...(truncated && { system_prompt_truncated: 'true' }), + }) + } + } + + // Add tools info to the span + if (newContext?.tools) { + try { + const toolsArray = jsonParse(newContext.tools) as Record< + string, + unknown + >[] + + // Build array of {name, hash} for each tool + const toolsWithHashes = toolsArray.map(tool => { + const toolJson = jsonStringify(tool) + const toolHash = shortHash(toolJson) + return { + name: typeof tool.name === 'string' ? tool.name : 'unknown', + hash: toolHash, + json: toolJson, + } + }) + + // Set span attribute with array of name/hash pairs + span.setAttribute( + 'tools', + jsonStringify( + toolsWithHashes.map(({ name, hash }) => ({ name, hash })), + ), + ) + span.setAttribute('tools_count', toolsWithHashes.length) + + // Log each tool's full description once per unique hash + for (const { name, hash, json } of toolsWithHashes) { + if (!seenHashes.has(`tool_${hash}`)) { + seenHashes.add(`tool_${hash}`) + + const { content: truncatedTool, truncated } = truncateContent(json) + + void logOTelEvent('tool', { + tool_name: sanitizeToolNameForAnalytics(name), + tool_hash: hash, + tool: truncatedTool, + ...(truncated && { tool_truncated: 'true' }), + }) + } + } + } catch { + // If parsing fails, log the raw tools string + span.setAttribute('tools_parse_error', true) + } + } + + // Add new_context using hash-based tracking (visible to all users) + if (messagesForAPI && messagesForAPI.length > 0 && newContext?.querySource) { + const querySource = newContext.querySource + const lastHash = lastReportedMessageHash.get(querySource) + + // Find where the last reported message is in the array + let startIndex = 0 + if (lastHash) { + for (let i = 0; i < messagesForAPI.length; i++) { + const msg = messagesForAPI[i] + if (msg && hashMessage(msg) === lastHash) { + startIndex = i + 1 // Start after the last reported message + break + } + } + // If lastHash not found, startIndex stays 0 (send everything) + } + + // Get new messages (filter out assistant messages - we only want user input/tool results) + const newMessages = messagesForAPI + .slice(startIndex) + .filter((m): m is UserMessage => m.type === 'user') + + if (newMessages.length > 0) { + // Format new messages, separating system reminders from regular content + const { contextParts, systemReminders } = + formatMessagesForContext(newMessages) + + // Set new_context (regular user content and tool results) + if (contextParts.length > 0) { + const fullContext = contextParts.join('\n\n---\n\n') + const { content: truncatedContext, truncated } = + truncateContent(fullContext) + + span.setAttributes({ + new_context: truncatedContext, + new_context_message_count: newMessages.length, + ...(truncated && { + new_context_truncated: true, + new_context_original_length: fullContext.length, + }), + }) + } + + // Set system_reminders as a separate attribute + if (systemReminders.length > 0) { + const fullReminders = systemReminders.join('\n\n---\n\n') + const { content: truncatedReminders, truncated: remindersTruncated } = + truncateContent(fullReminders) + + span.setAttributes({ + system_reminders: truncatedReminders, + system_reminders_count: systemReminders.length, + ...(remindersTruncated && { + system_reminders_truncated: true, + system_reminders_original_length: fullReminders.length, + }), + }) + } + + // Update last reported hash to the last message in the array + const lastMessage = messagesForAPI[messagesForAPI.length - 1] + if (lastMessage) { + lastReportedMessageHash.set(querySource, hashMessage(lastMessage)) + } + } + } +} + +/** + * Add beta attributes to endLLMRequestSpan. + * Handles model_output and thinking_output truncation. + */ +export function addBetaLLMResponseAttributes( + endAttributes: Record, + metadata?: { + modelOutput?: string + thinkingOutput?: string + }, +): void { + if (!isBetaTracingEnabled() || !metadata) { + return + } + + // Add model_output (text content) - visible to all users + if (metadata.modelOutput !== undefined) { + const { content: modelOutput, truncated: outputTruncated } = + truncateContent(metadata.modelOutput) + endAttributes['response.model_output'] = modelOutput + if (outputTruncated) { + endAttributes['response.model_output_truncated'] = true + endAttributes['response.model_output_original_length'] = + metadata.modelOutput.length + } + } + + // Add thinking_output - ant-only + if ( + process.env.USER_TYPE === 'ant' && + metadata.thinkingOutput !== undefined + ) { + const { content: thinkingOutput, truncated: thinkingTruncated } = + truncateContent(metadata.thinkingOutput) + endAttributes['response.thinking_output'] = thinkingOutput + if (thinkingTruncated) { + endAttributes['response.thinking_output_truncated'] = true + endAttributes['response.thinking_output_original_length'] = + metadata.thinkingOutput.length + } + } +} + +/** + * Add beta attributes to startToolSpan. + * Adds tool_input with the serialized tool input. + */ +export function addBetaToolInputAttributes( + span: Span, + toolName: string, + toolInput: string, +): void { + if (!isBetaTracingEnabled()) { + return + } + + const { content: truncatedInput, truncated } = truncateContent( + `[TOOL INPUT: ${toolName}]\n${toolInput}`, + ) + span.setAttributes({ + tool_input: truncatedInput, + ...(truncated && { + tool_input_truncated: true, + tool_input_original_length: toolInput.length, + }), + }) +} + +/** + * Add beta attributes to endToolSpan. + * Adds new_context with the tool result. + */ +export function addBetaToolResultAttributes( + endAttributes: Record, + toolName: string | number | boolean, + toolResult: string, +): void { + if (!isBetaTracingEnabled()) { + return + } + + const { content: truncatedResult, truncated } = truncateContent( + `[TOOL RESULT: ${toolName}]\n${toolResult}`, + ) + endAttributes['new_context'] = truncatedResult + if (truncated) { + endAttributes['new_context_truncated'] = true + endAttributes['new_context_original_length'] = toolResult.length + } +} diff --git a/src/utils/telemetry/bigqueryExporter.ts b/src/utils/telemetry/bigqueryExporter.ts new file mode 100644 index 0000000000000000000000000000000000000000..2f935c455a17efb74e854ad26c509ab525757416 --- /dev/null +++ b/src/utils/telemetry/bigqueryExporter.ts @@ -0,0 +1,252 @@ +import type { Attributes, HrTime } from '@opentelemetry/api' +import { type ExportResult, ExportResultCode } from '@opentelemetry/core' +import { + AggregationTemporality, + type MetricData, + type DataPoint as OTelDataPoint, + type PushMetricExporter, + type ResourceMetrics, +} from '@opentelemetry/sdk-metrics' +import axios from 'axios' +import { checkMetricsEnabled } from 'src/services/api/metricsOptOut.js' +import { getIsNonInteractiveSession } from '../../bootstrap/state.js' +import { getSubscriptionType, isClaudeAISubscriber } from '../auth.js' +import { checkHasTrustDialogAccepted } from '../config.js' +import { logForDebugging } from '../debug.js' +import { errorMessage, toError } from '../errors.js' +import { getAuthHeaders } from '../http.js' +import { logError } from '../log.js' +import { jsonStringify } from '../slowOperations.js' +import { getClaudeCodeUserAgent } from '../userAgent.js' + +type DataPoint = { + attributes: Record + value: number + timestamp: string +} + +type Metric = { + name: string + description?: string + unit?: string + data_points: DataPoint[] +} + +type InternalMetricsPayload = { + resource_attributes: Record + metrics: Metric[] +} + +export class BigQueryMetricsExporter implements PushMetricExporter { + private readonly endpoint: string + private readonly timeout: number + private pendingExports: Promise[] = [] + private isShutdown = false + + constructor(options: { timeout?: number } = {}) { + const defaultEndpoint = 'https://api.anthropic.com/api/claude_code/metrics' + + if ( + process.env.USER_TYPE === 'ant' && + process.env.ANT_CLAUDE_CODE_METRICS_ENDPOINT + ) { + this.endpoint = + process.env.ANT_CLAUDE_CODE_METRICS_ENDPOINT + + '/api/claude_code/metrics' + } else { + this.endpoint = defaultEndpoint + } + + this.timeout = options.timeout || 5000 + } + + async export( + metrics: ResourceMetrics, + resultCallback: (result: ExportResult) => void, + ): Promise { + if (this.isShutdown) { + resultCallback({ + code: ExportResultCode.FAILED, + error: new Error('Exporter has been shutdown'), + }) + return + } + + const exportPromise = this.doExport(metrics, resultCallback) + this.pendingExports.push(exportPromise) + + // Clean up completed exports + void exportPromise.finally(() => { + const index = this.pendingExports.indexOf(exportPromise) + if (index > -1) { + void this.pendingExports.splice(index, 1) + } + }) + } + + private async doExport( + metrics: ResourceMetrics, + resultCallback: (result: ExportResult) => void, + ): Promise { + try { + // Skip if trust not established in interactive mode + // This prevents triggering apiKeyHelper before trust dialog + const hasTrust = + checkHasTrustDialogAccepted() || getIsNonInteractiveSession() + if (!hasTrust) { + logForDebugging( + 'BigQuery metrics export: trust not established, skipping', + ) + resultCallback({ code: ExportResultCode.SUCCESS }) + return + } + + // Check organization-level metrics opt-out + const metricsStatus = await checkMetricsEnabled() + if (!metricsStatus.enabled) { + logForDebugging('Metrics export disabled by organization setting') + resultCallback({ code: ExportResultCode.SUCCESS }) + return + } + + const payload = this.transformMetricsForInternal(metrics) + + const authResult = getAuthHeaders() + if (authResult.error) { + logForDebugging(`Metrics export failed: ${authResult.error}`) + resultCallback({ + code: ExportResultCode.FAILED, + error: new Error(authResult.error), + }) + return + } + + const headers: Record = { + 'Content-Type': 'application/json', + 'User-Agent': getClaudeCodeUserAgent(), + ...authResult.headers, + } + + const response = await axios.post(this.endpoint, payload, { + timeout: this.timeout, + headers, + }) + + logForDebugging('BigQuery metrics exported successfully') + logForDebugging( + `BigQuery API Response: ${jsonStringify(response.data, null, 2)}`, + ) + resultCallback({ code: ExportResultCode.SUCCESS }) + } catch (error) { + logForDebugging(`BigQuery metrics export failed: ${errorMessage(error)}`) + logError(error) + resultCallback({ + code: ExportResultCode.FAILED, + error: toError(error), + }) + } + } + + private transformMetricsForInternal( + metrics: ResourceMetrics, + ): InternalMetricsPayload { + const attrs = metrics.resource.attributes + + const resourceAttributes: Record = { + 'service.name': (attrs['service.name'] as string) || 'claude-code', + 'service.version': (attrs['service.version'] as string) || 'unknown', + 'os.type': (attrs['os.type'] as string) || 'unknown', + 'os.version': (attrs['os.version'] as string) || 'unknown', + 'host.arch': (attrs['host.arch'] as string) || 'unknown', + 'aggregation.temporality': + this.selectAggregationTemporality() === AggregationTemporality.DELTA + ? 'delta' + : 'cumulative', + } + + // Only add wsl.version if it exists (omit instead of default) + if (attrs['wsl.version']) { + resourceAttributes['wsl.version'] = attrs['wsl.version'] as string + } + + // Add customer type and subscription type + if (isClaudeAISubscriber()) { + resourceAttributes['user.customer_type'] = 'claude_ai' + const subscriptionType = getSubscriptionType() + if (subscriptionType) { + resourceAttributes['user.subscription_type'] = subscriptionType + } + } else { + resourceAttributes['user.customer_type'] = 'api' + } + + const transformed = { + resource_attributes: resourceAttributes, + metrics: metrics.scopeMetrics.flatMap(scopeMetric => + scopeMetric.metrics.map(metric => ({ + name: metric.descriptor.name, + description: metric.descriptor.description, + unit: metric.descriptor.unit, + data_points: this.extractDataPoints(metric), + })), + ), + } + + return transformed + } + + private extractDataPoints(metric: MetricData): DataPoint[] { + const dataPoints = metric.dataPoints || [] + + return dataPoints + .filter( + (point): point is OTelDataPoint => + typeof point.value === 'number', + ) + .map(point => ({ + attributes: this.convertAttributes(point.attributes), + value: point.value, + timestamp: this.hrTimeToISOString( + point.endTime || point.startTime || [Date.now() / 1000, 0], + ), + })) + } + + async shutdown(): Promise { + this.isShutdown = true + await this.forceFlush() + logForDebugging('BigQuery metrics exporter shutdown complete') + } + + async forceFlush(): Promise { + await Promise.all(this.pendingExports) + logForDebugging('BigQuery metrics exporter flush complete') + } + + private convertAttributes( + attributes: Attributes | undefined, + ): Record { + const result: Record = {} + if (attributes) { + for (const [key, value] of Object.entries(attributes)) { + if (value !== undefined && value !== null) { + result[key] = String(value) + } + } + } + return result + } + + private hrTimeToISOString(hrTime: HrTime): string { + const [seconds, nanoseconds] = hrTime + const date = new Date(seconds * 1000 + nanoseconds / 1000000) + return date.toISOString() + } + + selectAggregationTemporality(): AggregationTemporality { + // DO NOT CHANGE THIS TO CUMULATIVE + // It would mess up the aggregation of metrics + // for CC Productivity metrics dashboard + return AggregationTemporality.DELTA + } +} diff --git a/src/utils/telemetry/events.ts b/src/utils/telemetry/events.ts new file mode 100644 index 0000000000000000000000000000000000000000..f93b8aaac0e57cb07a6142dfc3f66d2d5235c83a --- /dev/null +++ b/src/utils/telemetry/events.ts @@ -0,0 +1,75 @@ +import type { Attributes } from '@opentelemetry/api' +import { getEventLogger, getPromptId } from 'src/bootstrap/state.js' +import { logForDebugging } from '../debug.js' +import { isEnvTruthy } from '../envUtils.js' +import { getTelemetryAttributes } from '../telemetryAttributes.js' + +// Monotonically increasing counter for ordering events within a session +let eventSequence = 0 + +// Track whether we've already warned about a null event logger to avoid spamming +let hasWarnedNoEventLogger = false + +function isUserPromptLoggingEnabled() { + return isEnvTruthy(process.env.OTEL_LOG_USER_PROMPTS) +} + +export function redactIfDisabled(content: string): string { + return isUserPromptLoggingEnabled() ? content : '' +} + +export async function logOTelEvent( + eventName: string, + metadata: { [key: string]: string | undefined } = {}, +): Promise { + const eventLogger = getEventLogger() + if (!eventLogger) { + if (!hasWarnedNoEventLogger) { + hasWarnedNoEventLogger = true + logForDebugging( + `[3P telemetry] Event dropped (no event logger initialized): ${eventName}`, + { level: 'warn' }, + ) + } + return + } + + // Skip logging in test environment + if (process.env.NODE_ENV === 'test') { + return + } + + const attributes: Attributes = { + ...getTelemetryAttributes(), + 'event.name': eventName, + 'event.timestamp': new Date().toISOString(), + 'event.sequence': eventSequence++, + } + + // Add prompt ID to events (but not metrics, where it would cause unbounded cardinality) + const promptId = getPromptId() + if (promptId) { + attributes['prompt.id'] = promptId + } + + // Workspace directory from the desktop app (host path). Events only — + // filesystem paths are too high-cardinality for metric dimensions, and + // the BQ metrics pipeline must never see them. + const workspaceDir = process.env.CLAUDE_CODE_WORKSPACE_HOST_PATHS + if (workspaceDir) { + attributes['workspace.host_paths'] = workspaceDir.split('|') + } + + // Add metadata as attributes - all values are already strings + for (const [key, value] of Object.entries(metadata)) { + if (value !== undefined) { + attributes[key] = value + } + } + + // Emit log record as an event + eventLogger.emit({ + body: `claude_code.${eventName}`, + attributes, + }) +} diff --git a/src/utils/telemetry/instrumentation.ts b/src/utils/telemetry/instrumentation.ts new file mode 100644 index 0000000000000000000000000000000000000000..224f04815866aac847c5925673b72a7be245af9e --- /dev/null +++ b/src/utils/telemetry/instrumentation.ts @@ -0,0 +1,825 @@ +import { DiagLogLevel, diag, trace } from '@opentelemetry/api' +import { logs } from '@opentelemetry/api-logs' +// OTLP/Prometheus exporters are dynamically imported inside the protocol +// switch statements below. A process uses at most one protocol variant per +// signal, but static imports would load all 6 (~1.2MB) on every startup. +import { + envDetector, + hostDetector, + osDetector, + resourceFromAttributes, +} from '@opentelemetry/resources' +import { + BatchLogRecordProcessor, + ConsoleLogRecordExporter, + LoggerProvider, +} from '@opentelemetry/sdk-logs' +import { + ConsoleMetricExporter, + MeterProvider, + PeriodicExportingMetricReader, +} from '@opentelemetry/sdk-metrics' +import { + BasicTracerProvider, + BatchSpanProcessor, + ConsoleSpanExporter, +} from '@opentelemetry/sdk-trace-base' +import { + ATTR_SERVICE_NAME, + ATTR_SERVICE_VERSION, + SEMRESATTRS_HOST_ARCH, +} from '@opentelemetry/semantic-conventions' +import { HttpsProxyAgent } from 'https-proxy-agent' +import { + getLoggerProvider, + getMeterProvider, + getTracerProvider, + setEventLogger, + setLoggerProvider, + setMeterProvider, + setTracerProvider, +} from 'src/bootstrap/state.js' +import { + getOtelHeadersFromHelper, + getSubscriptionType, + is1PApiCustomer, + isClaudeAISubscriber, +} from 'src/utils/auth.js' +import { getPlatform, getWslVersion } from 'src/utils/platform.js' + +import { getCACertificates } from '../caCerts.js' +import { registerCleanup } from '../cleanupRegistry.js' +import { getHasFormattedOutput, logForDebugging } from '../debug.js' +import { isEnvTruthy } from '../envUtils.js' +import { errorMessage } from '../errors.js' +import { getMTLSConfig } from '../mtls.js' +import { getProxyUrl, shouldBypassProxy } from '../proxy.js' +import { getSettings_DEPRECATED } from '../settings/settings.js' +import { jsonStringify } from '../slowOperations.js' +import { profileCheckpoint } from '../startupProfiler.js' +import { isBetaTracingEnabled } from './betaSessionTracing.js' +import { BigQueryMetricsExporter } from './bigqueryExporter.js' +import { ClaudeCodeDiagLogger } from './logger.js' +import { initializePerfettoTracing } from './perfettoTracing.js' +import { + endInteractionSpan, + isEnhancedTelemetryEnabled, +} from './sessionTracing.js' + +const DEFAULT_METRICS_EXPORT_INTERVAL_MS = 60000 +const DEFAULT_LOGS_EXPORT_INTERVAL_MS = 5000 +const DEFAULT_TRACES_EXPORT_INTERVAL_MS = 5000 + +class TelemetryTimeoutError extends Error {} + +function telemetryTimeout(ms: number, message: string): Promise { + return new Promise((_, reject) => { + setTimeout( + (rej: (e: Error) => void, msg: string) => + rej(new TelemetryTimeoutError(msg)), + ms, + reject, + message, + ).unref() + }) +} + +export function bootstrapTelemetry() { + if (process.env.USER_TYPE === 'ant') { + // Read from ANT_ prefixed variables that are defined at build time + if (process.env.ANT_OTEL_METRICS_EXPORTER) { + process.env.OTEL_METRICS_EXPORTER = process.env.ANT_OTEL_METRICS_EXPORTER + } + if (process.env.ANT_OTEL_LOGS_EXPORTER) { + process.env.OTEL_LOGS_EXPORTER = process.env.ANT_OTEL_LOGS_EXPORTER + } + if (process.env.ANT_OTEL_TRACES_EXPORTER) { + process.env.OTEL_TRACES_EXPORTER = process.env.ANT_OTEL_TRACES_EXPORTER + } + if (process.env.ANT_OTEL_EXPORTER_OTLP_PROTOCOL) { + process.env.OTEL_EXPORTER_OTLP_PROTOCOL = + process.env.ANT_OTEL_EXPORTER_OTLP_PROTOCOL + } + if (process.env.ANT_OTEL_EXPORTER_OTLP_ENDPOINT) { + process.env.OTEL_EXPORTER_OTLP_ENDPOINT = + process.env.ANT_OTEL_EXPORTER_OTLP_ENDPOINT + } + if (process.env.ANT_OTEL_EXPORTER_OTLP_HEADERS) { + process.env.OTEL_EXPORTER_OTLP_HEADERS = + process.env.ANT_OTEL_EXPORTER_OTLP_HEADERS + } + } + + // Set default tempoality to 'delta' because it's the more sane default + if (!process.env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE) { + process.env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE = 'delta' + } +} + +// Per OTEL spec, "none" means "no automatically configured exporter for this signal". +// https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#exporter-selection +export function parseExporterTypes(value: string | undefined): string[] { + return (value || '') + .trim() + .split(',') + .filter(Boolean) + .map(t => t.trim()) + .filter(t => t !== 'none') +} + +async function getOtlpReaders() { + const exporterTypes = parseExporterTypes(process.env.OTEL_METRICS_EXPORTER) + const exportInterval = parseInt( + process.env.OTEL_METRIC_EXPORT_INTERVAL || + DEFAULT_METRICS_EXPORT_INTERVAL_MS.toString(), + ) + + const exporters = [] + for (const exporterType of exporterTypes) { + if (exporterType === 'console') { + // Custom console exporter that shows resource attributes + const consoleExporter = new ConsoleMetricExporter() + const originalExport = consoleExporter.export.bind(consoleExporter) + + consoleExporter.export = (metrics, callback) => { + // Log resource attributes once at the start + if (metrics.resource && metrics.resource.attributes) { + // The console exporter is for debugging, so console output is intentional here + + logForDebugging('\n=== Resource Attributes ===') + logForDebugging(jsonStringify(metrics.resource.attributes)) + logForDebugging('===========================\n') + } + + return originalExport(metrics, callback) + } + + exporters.push(consoleExporter) + } else if (exporterType === 'otlp') { + const protocol = + process.env.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL?.trim() || + process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim() + + const httpConfig = getOTLPExporterConfig() + + switch (protocol) { + case 'grpc': { + // Lazy-import to keep @grpc/grpc-js (~700KB) out of the telemetry chunk + // when the protocol is http/protobuf (ant default) or http/json. + const { OTLPMetricExporter } = await import( + '@opentelemetry/exporter-metrics-otlp-grpc' + ) + exporters.push(new OTLPMetricExporter()) + break + } + case 'http/json': { + const { OTLPMetricExporter } = await import( + '@opentelemetry/exporter-metrics-otlp-http' + ) + exporters.push(new OTLPMetricExporter(httpConfig)) + break + } + case 'http/protobuf': { + const { OTLPMetricExporter } = await import( + '@opentelemetry/exporter-metrics-otlp-proto' + ) + exporters.push(new OTLPMetricExporter(httpConfig)) + break + } + default: + throw new Error( + `Unknown protocol set in OTEL_EXPORTER_OTLP_METRICS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`, + ) + } + } else if (exporterType === 'prometheus') { + const { PrometheusExporter } = await import( + '@opentelemetry/exporter-prometheus' + ) + exporters.push(new PrometheusExporter()) + } else { + throw new Error( + `Unknown exporter type set in OTEL_EXPORTER_OTLP_METRICS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${exporterType}`, + ) + } + } + + return exporters.map(exporter => { + if ('export' in exporter) { + return new PeriodicExportingMetricReader({ + exporter, + exportIntervalMillis: exportInterval, + }) + } + return exporter + }) +} + +async function getOtlpLogExporters() { + const exporterTypes = parseExporterTypes(process.env.OTEL_LOGS_EXPORTER) + + const protocol = + process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL?.trim() || + process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim() + const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT + + logForDebugging( + `[3P telemetry] getOtlpLogExporters: types=${jsonStringify(exporterTypes)}, protocol=${protocol}, endpoint=${endpoint}`, + ) + + const exporters = [] + for (const exporterType of exporterTypes) { + if (exporterType === 'console') { + exporters.push(new ConsoleLogRecordExporter()) + } else if (exporterType === 'otlp') { + const httpConfig = getOTLPExporterConfig() + + switch (protocol) { + case 'grpc': { + const { OTLPLogExporter } = await import( + '@opentelemetry/exporter-logs-otlp-grpc' + ) + exporters.push(new OTLPLogExporter()) + break + } + case 'http/json': { + const { OTLPLogExporter } = await import( + '@opentelemetry/exporter-logs-otlp-http' + ) + exporters.push(new OTLPLogExporter(httpConfig)) + break + } + case 'http/protobuf': { + const { OTLPLogExporter } = await import( + '@opentelemetry/exporter-logs-otlp-proto' + ) + exporters.push(new OTLPLogExporter(httpConfig)) + break + } + default: + throw new Error( + `Unknown protocol set in OTEL_EXPORTER_OTLP_LOGS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`, + ) + } + } else { + throw new Error( + `Unknown exporter type set in OTEL_LOGS_EXPORTER env var: ${exporterType}`, + ) + } + } + + return exporters +} + +async function getOtlpTraceExporters() { + const exporterTypes = parseExporterTypes(process.env.OTEL_TRACES_EXPORTER) + + const exporters = [] + for (const exporterType of exporterTypes) { + if (exporterType === 'console') { + exporters.push(new ConsoleSpanExporter()) + } else if (exporterType === 'otlp') { + const protocol = + process.env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL?.trim() || + process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim() + + const httpConfig = getOTLPExporterConfig() + + switch (protocol) { + case 'grpc': { + const { OTLPTraceExporter } = await import( + '@opentelemetry/exporter-trace-otlp-grpc' + ) + exporters.push(new OTLPTraceExporter()) + break + } + case 'http/json': { + const { OTLPTraceExporter } = await import( + '@opentelemetry/exporter-trace-otlp-http' + ) + exporters.push(new OTLPTraceExporter(httpConfig)) + break + } + case 'http/protobuf': { + const { OTLPTraceExporter } = await import( + '@opentelemetry/exporter-trace-otlp-proto' + ) + exporters.push(new OTLPTraceExporter(httpConfig)) + break + } + default: + throw new Error( + `Unknown protocol set in OTEL_EXPORTER_OTLP_TRACES_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`, + ) + } + } else { + throw new Error( + `Unknown exporter type set in OTEL_TRACES_EXPORTER env var: ${exporterType}`, + ) + } + } + + return exporters +} + +export function isTelemetryEnabled() { + return isEnvTruthy(process.env.CLAUDE_CODE_ENABLE_TELEMETRY) +} + +function getBigQueryExportingReader() { + const bigqueryExporter = new BigQueryMetricsExporter() + return new PeriodicExportingMetricReader({ + exporter: bigqueryExporter, + exportIntervalMillis: 5 * 60 * 1000, // 5mins for BigQuery metrics exporter to reduce load + }) +} + +function isBigQueryMetricsEnabled() { + // BigQuery metrics are enabled for: + // 1. API customers (excluding Claude.ai subscribers and Bedrock/Vertex) + // 2. Claude for Enterprise (C4E) users + // 3. Claude for Teams users + const subscriptionType = getSubscriptionType() + const isC4EOrTeamUser = + isClaudeAISubscriber() && + (subscriptionType === 'enterprise' || subscriptionType === 'team') + + return is1PApiCustomer() || isC4EOrTeamUser +} + +/** + * Initialize beta tracing - a separate code path for detailed debugging. + * Uses BETA_TRACING_ENDPOINT instead of OTEL_EXPORTER_OTLP_ENDPOINT. + */ +async function initializeBetaTracing( + resource: ReturnType, +): Promise { + const endpoint = process.env.BETA_TRACING_ENDPOINT + if (!endpoint) { + return + } + + const [{ OTLPTraceExporter }, { OTLPLogExporter }] = await Promise.all([ + import('@opentelemetry/exporter-trace-otlp-http'), + import('@opentelemetry/exporter-logs-otlp-http'), + ]) + + const httpConfig = { + url: `${endpoint}/v1/traces`, + } + + const logHttpConfig = { + url: `${endpoint}/v1/logs`, + } + + // Initialize trace exporter + const traceExporter = new OTLPTraceExporter(httpConfig) + const spanProcessor = new BatchSpanProcessor(traceExporter, { + scheduledDelayMillis: DEFAULT_TRACES_EXPORT_INTERVAL_MS, + }) + + const tracerProvider = new BasicTracerProvider({ + resource, + spanProcessors: [spanProcessor], + }) + + trace.setGlobalTracerProvider(tracerProvider) + setTracerProvider(tracerProvider) + + // Initialize log exporter + const logExporter = new OTLPLogExporter(logHttpConfig) + const loggerProvider = new LoggerProvider({ + resource, + processors: [ + new BatchLogRecordProcessor(logExporter, { + scheduledDelayMillis: DEFAULT_LOGS_EXPORT_INTERVAL_MS, + }), + ], + }) + + logs.setGlobalLoggerProvider(loggerProvider) + setLoggerProvider(loggerProvider) + + // Initialize event logger + const eventLogger = logs.getLogger( + 'com.anthropic.claude_code.events', + MACRO.VERSION, + ) + setEventLogger(eventLogger) + + // Setup flush handlers - flush both logs AND traces + process.on('beforeExit', async () => { + await loggerProvider?.forceFlush() + await tracerProvider?.forceFlush() + }) + + process.on('exit', () => { + void loggerProvider?.forceFlush() + void tracerProvider?.forceFlush() + }) +} + +export async function initializeTelemetry() { + profileCheckpoint('telemetry_init_start') + bootstrapTelemetry() + + // Console exporters call console.dir on a timer (5s logs/traces, 60s + // metrics), writing pretty-printed objects to stdout. In stream-json + // mode stdout is the SDK message channel; the first line (`{`) breaks + // the SDK's line reader. Stripped here (not main.tsx) because init.ts + // re-runs applyConfigEnvironmentVariables() inside initializeTelemetry- + // AfterTrust for remote-managed-settings users, and bootstrapTelemetry + // above copies ANT_OTEL_* for ant users — both would undo an earlier strip. + if (getHasFormattedOutput()) { + for (const key of [ + 'OTEL_METRICS_EXPORTER', + 'OTEL_LOGS_EXPORTER', + 'OTEL_TRACES_EXPORTER', + ] as const) { + const v = process.env[key] + if (v?.includes('console')) { + process.env[key] = v + .split(',') + .map(s => s.trim()) + .filter(s => s !== 'console') + .join(',') + } + } + } + + diag.setLogger(new ClaudeCodeDiagLogger(), DiagLogLevel.ERROR) + + // Initialize Perfetto tracing (independent of OTEL) + // Enable via CLAUDE_CODE_PERFETTO_TRACE=1 or CLAUDE_CODE_PERFETTO_TRACE= + initializePerfettoTracing() + + const readers = [] + + // Add customer exporters (if enabled) + const telemetryEnabled = isTelemetryEnabled() + logForDebugging( + `[3P telemetry] isTelemetryEnabled=${telemetryEnabled} (CLAUDE_CODE_ENABLE_TELEMETRY=${process.env.CLAUDE_CODE_ENABLE_TELEMETRY})`, + ) + if (telemetryEnabled) { + readers.push(...(await getOtlpReaders())) + } + + // Add BigQuery exporter (for API customers, C4E users, and internal users) + if (isBigQueryMetricsEnabled()) { + readers.push(getBigQueryExportingReader()) + } + + // Create base resource with service attributes + const platform = getPlatform() + const baseAttributes: Record = { + [ATTR_SERVICE_NAME]: 'claude-code', + [ATTR_SERVICE_VERSION]: MACRO.VERSION, + } + + // Add WSL-specific attributes if running on WSL + if (platform === 'wsl') { + const wslVersion = getWslVersion() + if (wslVersion) { + baseAttributes['wsl.version'] = wslVersion + } + } + + const baseResource = resourceFromAttributes(baseAttributes) + + // Use OpenTelemetry detectors + const osResource = resourceFromAttributes( + osDetector.detect().attributes || {}, + ) + + // Extract only host.arch from hostDetector + const hostDetected = hostDetector.detect() + const hostArchAttributes = hostDetected.attributes?.[SEMRESATTRS_HOST_ARCH] + ? { + [SEMRESATTRS_HOST_ARCH]: hostDetected.attributes[SEMRESATTRS_HOST_ARCH], + } + : {} + const hostArchResource = resourceFromAttributes(hostArchAttributes) + + const envResource = resourceFromAttributes( + envDetector.detect().attributes || {}, + ) + + // Merge resources - later resources take precedence + const resource = baseResource + .merge(osResource) + .merge(hostArchResource) + .merge(envResource) + + // Check if beta tracing is enabled - this is a separate code path + // Available to all users who set ENABLE_BETA_TRACING_DETAILED=1 and BETA_TRACING_ENDPOINT + if (isBetaTracingEnabled()) { + void initializeBetaTracing(resource).catch(e => + logForDebugging(`Beta tracing init failed: ${e}`, { level: 'error' }), + ) + // Still set up meter provider for metrics (but skip regular logs/traces setup) + const meterProvider = new MeterProvider({ + resource, + views: [], + readers, + }) + setMeterProvider(meterProvider) + + // Register shutdown for beta tracing + const shutdownTelemetry = async () => { + const timeoutMs = parseInt( + process.env.CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS || '2000', + ) + try { + endInteractionSpan() + + // Force flush + shutdown together inside the timeout. Previously forceFlush + // was awaited unbounded BEFORE the race, blocking exit on slow OTLP endpoints. + // Each provider's flush→shutdown is chained independently so a slow logger + // flush doesn't delay meterProvider/tracerProvider shutdown (no waterfall). + const loggerProvider = getLoggerProvider() + const tracerProvider = getTracerProvider() + + const chains: Promise[] = [meterProvider.shutdown()] + if (loggerProvider) { + chains.push( + loggerProvider.forceFlush().then(() => loggerProvider.shutdown()), + ) + } + if (tracerProvider) { + chains.push( + tracerProvider.forceFlush().then(() => tracerProvider.shutdown()), + ) + } + + await Promise.race([ + Promise.all(chains), + telemetryTimeout(timeoutMs, 'OpenTelemetry shutdown timeout'), + ]) + } catch { + // Ignore shutdown errors + } + } + registerCleanup(shutdownTelemetry) + + return meterProvider.getMeter('com.anthropic.claude_code', MACRO.VERSION) + } + + const meterProvider = new MeterProvider({ + resource, + views: [], + readers, + }) + + // Store reference in state for flushing + setMeterProvider(meterProvider) + + // Initialize logs if telemetry is enabled + if (telemetryEnabled) { + const logExporters = await getOtlpLogExporters() + logForDebugging( + `[3P telemetry] Created ${logExporters.length} log exporter(s)`, + ) + + if (logExporters.length > 0) { + const loggerProvider = new LoggerProvider({ + resource, + // Add batch processors for each exporter + processors: logExporters.map( + exporter => + new BatchLogRecordProcessor(exporter, { + scheduledDelayMillis: parseInt( + process.env.OTEL_LOGS_EXPORT_INTERVAL || + DEFAULT_LOGS_EXPORT_INTERVAL_MS.toString(), + ), + }), + ), + }) + + // Register the logger provider globally + logs.setGlobalLoggerProvider(loggerProvider) + setLoggerProvider(loggerProvider) + + // Initialize event logger + const eventLogger = logs.getLogger( + 'com.anthropic.claude_code.events', + MACRO.VERSION, + ) + setEventLogger(eventLogger) + logForDebugging('[3P telemetry] Event logger set successfully') + + // 'beforeExit' is emitted when Node.js empties its event loop and has no additional work to schedule. + // Unlike 'exit', it allows us to perform async operations, so it works well for letting + // network requests complete before the process exits naturally. + process.on('beforeExit', async () => { + await loggerProvider?.forceFlush() + // Also flush traces - they use BatchSpanProcessor which needs explicit flush + const tracerProvider = getTracerProvider() + await tracerProvider?.forceFlush() + }) + + process.on('exit', () => { + // Final attempt to flush logs and traces + void loggerProvider?.forceFlush() + void getTracerProvider()?.forceFlush() + }) + } + } + + // Initialize tracing if enhanced telemetry is enabled (BETA) + if (telemetryEnabled && isEnhancedTelemetryEnabled()) { + const traceExporters = await getOtlpTraceExporters() + if (traceExporters.length > 0) { + // Create span processors for each exporter + const spanProcessors = traceExporters.map( + exporter => + new BatchSpanProcessor(exporter, { + scheduledDelayMillis: parseInt( + process.env.OTEL_TRACES_EXPORT_INTERVAL || + DEFAULT_TRACES_EXPORT_INTERVAL_MS.toString(), + ), + }), + ) + + const tracerProvider = new BasicTracerProvider({ + resource, + spanProcessors, + }) + + // Register the tracer provider globally + trace.setGlobalTracerProvider(tracerProvider) + setTracerProvider(tracerProvider) + } + } + + // Shutdown metrics and logs on exit (flushes and closes exporters) + const shutdownTelemetry = async () => { + const timeoutMs = parseInt( + process.env.CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS || '2000', + ) + + try { + // End any active interaction span before shutdown + endInteractionSpan() + + const shutdownPromises = [meterProvider.shutdown()] + const loggerProvider = getLoggerProvider() + if (loggerProvider) { + shutdownPromises.push(loggerProvider.shutdown()) + } + const tracerProvider = getTracerProvider() + if (tracerProvider) { + shutdownPromises.push(tracerProvider.shutdown()) + } + + await Promise.race([ + Promise.all(shutdownPromises), + telemetryTimeout(timeoutMs, 'OpenTelemetry shutdown timeout'), + ]) + } catch (error) { + if (error instanceof Error && error.message.includes('timeout')) { + logForDebugging( + ` +OpenTelemetry telemetry flush timed out after ${timeoutMs}ms + +To resolve this issue, you can: +1. Increase the timeout by setting CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS env var (e.g., 5000 for 5 seconds) +2. Check if your OpenTelemetry backend is experiencing scalability issues +3. Disable OpenTelemetry by unsetting CLAUDE_CODE_ENABLE_TELEMETRY env var + +Current timeout: ${timeoutMs}ms +`, + { level: 'error' }, + ) + } + throw error + } + } + + // Always register shutdown (internal metrics are always enabled) + registerCleanup(shutdownTelemetry) + + return meterProvider.getMeter('com.anthropic.claude_code', MACRO.VERSION) +} + +/** + * Flush all pending telemetry data immediately. + * This should be called before logout or org switching to prevent data leakage. + */ +export async function flushTelemetry(): Promise { + const meterProvider = getMeterProvider() + if (!meterProvider) { + return + } + + const timeoutMs = parseInt( + process.env.CLAUDE_CODE_OTEL_FLUSH_TIMEOUT_MS || '5000', + ) + + try { + const flushPromises = [meterProvider.forceFlush()] + const loggerProvider = getLoggerProvider() + if (loggerProvider) { + flushPromises.push(loggerProvider.forceFlush()) + } + const tracerProvider = getTracerProvider() + if (tracerProvider) { + flushPromises.push(tracerProvider.forceFlush()) + } + + await Promise.race([ + Promise.all(flushPromises), + telemetryTimeout(timeoutMs, 'OpenTelemetry flush timeout'), + ]) + + logForDebugging('Telemetry flushed successfully') + } catch (error) { + if (error instanceof TelemetryTimeoutError) { + logForDebugging( + `Telemetry flush timed out after ${timeoutMs}ms. Some metrics may not be exported.`, + { level: 'warn' }, + ) + } else { + logForDebugging(`Telemetry flush failed: ${errorMessage(error)}`, { + level: 'error', + }) + } + // Don't throw - allow logout to continue even if flush fails + } +} + +function parseOtelHeadersEnvVar(): Record { + const headers: Record = {} + const envHeaders = process.env.OTEL_EXPORTER_OTLP_HEADERS + if (envHeaders) { + for (const pair of envHeaders.split(',')) { + const [key, ...valueParts] = pair.split('=') + if (key && valueParts.length > 0) { + headers[key.trim()] = valueParts.join('=').trim() + } + } + } + return headers +} + +/** + * Get configuration for OTLP exporters including: + * - HTTP agent options (proxy, mTLS) + * - Dynamic headers via otelHeadersHelper or static headers from env var + */ +function getOTLPExporterConfig() { + const proxyUrl = getProxyUrl() + const mtlsConfig = getMTLSConfig() + const settings = getSettings_DEPRECATED() + + // Build base config + const config: Record = {} + + // Parse static headers from env var once (doesn't change at runtime) + const staticHeaders = parseOtelHeadersEnvVar() + + // If otelHeadersHelper is configured, use async headers function for dynamic refresh + // Otherwise just return static headers if any exist + if (settings?.otelHeadersHelper) { + config.headers = async (): Promise> => { + const dynamicHeaders = getOtelHeadersFromHelper() + return { ...staticHeaders, ...dynamicHeaders } + } + } else if (Object.keys(staticHeaders).length > 0) { + config.headers = async (): Promise> => staticHeaders + } + + // Check if we should bypass proxy for OTEL endpoint + const otelEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT + if (!proxyUrl || (otelEndpoint && shouldBypassProxy(otelEndpoint))) { + // No proxy configured or OTEL endpoint should bypass proxy + const caCerts = getCACertificates() + if (mtlsConfig || caCerts) { + config.httpAgentOptions = { + ...mtlsConfig, + ...(caCerts && { ca: caCerts }), + } + } + return config + } + + // Return an HttpAgentFactory function that creates our proxy agent + const caCerts = getCACertificates() + const agentFactory = (_protocol: string) => { + // Create and return the proxy agent with mTLS and CA cert config + const proxyAgent = + mtlsConfig || caCerts + ? new HttpsProxyAgent(proxyUrl, { + ...(mtlsConfig && { + cert: mtlsConfig.cert, + key: mtlsConfig.key, + passphrase: mtlsConfig.passphrase, + }), + ...(caCerts && { ca: caCerts }), + }) + : new HttpsProxyAgent(proxyUrl) + + return proxyAgent + } + + config.httpAgentOptions = agentFactory + return config +} diff --git a/src/utils/telemetry/logger.ts b/src/utils/telemetry/logger.ts new file mode 100644 index 0000000000000000000000000000000000000000..0f080f5846fb9b6d2e038fee24a6ffcb43c4d389 --- /dev/null +++ b/src/utils/telemetry/logger.ts @@ -0,0 +1,26 @@ +import type { DiagLogger } from '@opentelemetry/api' +import { logForDebugging } from '../debug.js' +import { logError } from '../log.js' +export class ClaudeCodeDiagLogger implements DiagLogger { + error(message: string, ..._: unknown[]) { + logError(new Error(message)) + logForDebugging(`[3P telemetry] OTEL diag error: ${message}`, { + level: 'error', + }) + } + warn(message: string, ..._: unknown[]) { + logError(new Error(message)) + logForDebugging(`[3P telemetry] OTEL diag warn: ${message}`, { + level: 'warn', + }) + } + info(_message: string, ..._args: unknown[]) { + return + } + debug(_message: string, ..._args: unknown[]) { + return + } + verbose(_message: string, ..._args: unknown[]) { + return + } +} diff --git a/src/utils/telemetry/perfettoTracing.ts b/src/utils/telemetry/perfettoTracing.ts new file mode 100644 index 0000000000000000000000000000000000000000..ce3a87233595b642fb7d8a354363fea97bb393c8 --- /dev/null +++ b/src/utils/telemetry/perfettoTracing.ts @@ -0,0 +1,1120 @@ +/** + * Perfetto Tracing for Claude Code (Ant-only) + * + * This module generates traces in the Chrome Trace Event format that can be + * viewed in ui.perfetto.dev or Chrome's chrome://tracing. + * + * NOTE: This feature is ant-only and eliminated from external builds. + * + * The trace file includes: + * - Agent hierarchy (parent-child relationships in a swarm) + * - API requests with TTFT, TTLT, prompt length, cache stats, msg ID, speculative flag + * - Tool executions with name, duration, and token usage + * - User input waiting time + * + * Usage: + * 1. Enable via CLAUDE_CODE_PERFETTO_TRACE=1 or CLAUDE_CODE_PERFETTO_TRACE= + * 2. Optionally set CLAUDE_CODE_PERFETTO_WRITE_INTERVAL_S= to write the + * trace file periodically (default: write only on exit). + * 3. Run Claude Code normally + * 4. Trace file is written to ~/.claude/traces/trace-.json + * or to the specified path + * 5. Open in ui.perfetto.dev to visualize + */ + +import { feature } from 'bun:bundle' +import { mkdirSync, writeFileSync } from 'fs' +import { mkdir, writeFile } from 'fs/promises' +import { dirname, join } from 'path' +import { getSessionId } from '../../bootstrap/state.js' +import { registerCleanup } from '../cleanupRegistry.js' +import { logForDebugging } from '../debug.js' +import { + getClaudeConfigHomeDir, + isEnvDefinedFalsy, + isEnvTruthy, +} from '../envUtils.js' +import { errorMessage } from '../errors.js' +import { djb2Hash } from '../hash.js' +import { jsonStringify } from '../slowOperations.js' +import { getAgentId, getAgentName, getParentSessionId } from '../teammate.js' + +/** + * Chrome Trace Event format types + * See: https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU + */ + +export type TraceEventPhase = + | 'B' // Begin duration event + | 'E' // End duration event + | 'X' // Complete event (with duration) + | 'i' // Instant event + | 'C' // Counter event + | 'b' // Async begin + | 'n' // Async instant + | 'e' // Async end + | 'M' // Metadata event + +export type TraceEvent = { + name: string + cat: string + ph: TraceEventPhase + ts: number // Timestamp in microseconds + pid: number // Process ID (we use 1 for main, agent IDs for subagents) + tid: number // Thread ID (we use numeric hash of agent name or 1 for main) + dur?: number // Duration in microseconds (for 'X' events) + args?: Record + id?: string // For async events + scope?: string +} + +/** + * Agent info for tracking hierarchy + */ +type AgentInfo = { + agentId: string + agentName: string + parentAgentId?: string + processId: number + threadId: number +} + +/** + * Pending span for tracking begin/end pairs + */ +type PendingSpan = { + name: string + category: string + startTime: number + agentInfo: AgentInfo + args: Record +} + +// Global state for the Perfetto tracer +let isEnabled = false +let tracePath: string | null = null +// Metadata events (ph: 'M' — process/thread names, parent links) are kept +// separate so they survive eviction — Perfetto UI needs them to label +// tracks. Bounded by agent count (~3 events per agent). +const metadataEvents: TraceEvent[] = [] +const events: TraceEvent[] = [] +// events[] cap. Cron-driven sessions run for days; 22 push sites × many +// turns would otherwise grow unboundedly (periodicWrite flushes to disk but +// does not truncate — it writes the full snapshot). At ~300B/event this is +// ~30MB, enough trace history for any debugging session. Eviction drops the +// oldest half when hit, amortized O(1). +const MAX_EVENTS = 100_000 +const pendingSpans = new Map() +const agentRegistry = new Map() +let totalAgentCount = 0 +let startTimeMs = 0 +let spanIdCounter = 0 +let traceWritten = false // Flag to avoid double writes + +// Map agent IDs to numeric process IDs (Perfetto requires numeric IDs) +let processIdCounter = 1 +const agentIdToProcessId = new Map() + +// Periodic write interval handle +let writeIntervalId: ReturnType | null = null + +const STALE_SPAN_TTL_MS = 30 * 60 * 1000 // 30 minutes +const STALE_SPAN_CLEANUP_INTERVAL_MS = 60 * 1000 // 1 minute +let staleSpanCleanupId: ReturnType | null = null + +/** + * Convert a string to a numeric hash for use as thread ID + */ +function stringToNumericHash(str: string): number { + return Math.abs(djb2Hash(str)) || 1 // Ensure non-zero +} + +/** + * Get or create a numeric process ID for an agent + */ +function getProcessIdForAgent(agentId: string): number { + const existing = agentIdToProcessId.get(agentId) + if (existing !== undefined) return existing + + processIdCounter++ + agentIdToProcessId.set(agentId, processIdCounter) + return processIdCounter +} + +/** + * Get current agent info + */ +function getCurrentAgentInfo(): AgentInfo { + const agentId = getAgentId() ?? getSessionId() + const agentName = getAgentName() ?? 'main' + const parentSessionId = getParentSessionId() + + // Check if we've already registered this agent + const existing = agentRegistry.get(agentId) + if (existing) return existing + + const info: AgentInfo = { + agentId, + agentName, + parentAgentId: parentSessionId, + processId: agentId === getSessionId() ? 1 : getProcessIdForAgent(agentId), + threadId: stringToNumericHash(agentName), + } + + agentRegistry.set(agentId, info) + totalAgentCount++ + return info +} + +/** + * Get timestamp in microseconds relative to trace start + */ +function getTimestamp(): number { + return (Date.now() - startTimeMs) * 1000 +} + +/** + * Generate a unique span ID + */ +function generateSpanId(): string { + return `span_${++spanIdCounter}` +} + +/** + * Evict pending spans older than STALE_SPAN_TTL_MS. + * Mirrors the TTL cleanup pattern in sessionTracing.ts. + */ +function evictStaleSpans(): void { + const now = getTimestamp() + const ttlUs = STALE_SPAN_TTL_MS * 1000 // Convert ms to microseconds + for (const [spanId, span] of pendingSpans) { + if (now - span.startTime > ttlUs) { + // Emit an end event so the span shows up in the trace as incomplete + events.push({ + name: span.name, + cat: span.category, + ph: 'E', + ts: now, + pid: span.agentInfo.processId, + tid: span.agentInfo.threadId, + args: { + ...span.args, + evicted: true, + duration_ms: (now - span.startTime) / 1000, + }, + }) + pendingSpans.delete(spanId) + } + } +} + +/** + * Build the full trace document (Chrome Trace JSON format). + */ +function buildTraceDocument(): string { + return jsonStringify({ + traceEvents: [...metadataEvents, ...events], + metadata: { + session_id: getSessionId(), + trace_start_time: new Date(startTimeMs).toISOString(), + agent_count: totalAgentCount, + total_event_count: metadataEvents.length + events.length, + }, + }) +} + +/** + * Drop the oldest half of events[] when over MAX_EVENTS. Called from the + * stale-span cleanup interval (60s). The half-batch splice keeps this + * amortized O(1) — we don't pay splice cost per-push. A synthetic marker + * is inserted so the gap is visible in ui.perfetto.dev. + */ +function evictOldestEvents(): void { + if (events.length < MAX_EVENTS) return + const dropped = events.splice(0, MAX_EVENTS / 2) + events.unshift({ + name: 'trace_truncated', + cat: '__metadata', + ph: 'i', + ts: dropped[dropped.length - 1]?.ts ?? 0, + pid: 1, + tid: 0, + args: { dropped_events: dropped.length }, + }) + logForDebugging( + `[Perfetto] Evicted ${dropped.length} oldest events (cap ${MAX_EVENTS})`, + ) +} + +/** + * Initialize Perfetto tracing + * Call this early in the application lifecycle + */ +export function initializePerfettoTracing(): void { + const envValue = process.env.CLAUDE_CODE_PERFETTO_TRACE + logForDebugging( + `[Perfetto] initializePerfettoTracing called, env value: ${envValue}`, + ) + + // Wrap in feature() for dead code elimination - entire block removed from external builds + if (feature('PERFETTO_TRACING')) { + if (!envValue || isEnvDefinedFalsy(envValue)) { + logForDebugging( + '[Perfetto] Tracing disabled (env var not set or disabled)', + ) + return + } + + isEnabled = true + startTimeMs = Date.now() + + // Determine trace file path + if (isEnvTruthy(envValue)) { + const tracesDir = join(getClaudeConfigHomeDir(), 'traces') + tracePath = join(tracesDir, `trace-${getSessionId()}.json`) + } else { + // Use the provided path + tracePath = envValue + } + + logForDebugging( + `[Perfetto] Tracing enabled, will write to: ${tracePath}, isEnabled=${isEnabled}`, + ) + + // Start periodic full-trace write if CLAUDE_CODE_PERFETTO_WRITE_INTERVAL_S is a positive integer + const intervalSec = parseInt( + process.env.CLAUDE_CODE_PERFETTO_WRITE_INTERVAL_S ?? '', + 10, + ) + if (intervalSec > 0) { + writeIntervalId = setInterval(() => { + void periodicWrite() + }, intervalSec * 1000) + // Don't let the interval keep the process alive on its own + if (writeIntervalId.unref) writeIntervalId.unref() + logForDebugging( + `[Perfetto] Periodic write enabled, interval: ${intervalSec}s`, + ) + } + + // Start stale span cleanup interval + staleSpanCleanupId = setInterval(() => { + evictStaleSpans() + evictOldestEvents() + }, STALE_SPAN_CLEANUP_INTERVAL_MS) + if (staleSpanCleanupId.unref) staleSpanCleanupId.unref() + + // Register cleanup to write final trace on exit + registerCleanup(async () => { + logForDebugging('[Perfetto] Cleanup callback invoked') + await writePerfettoTrace() + }) + + // Also register a beforeExit handler as a fallback + // This ensures the trace is written even if cleanup registry is not called + process.on('beforeExit', () => { + logForDebugging('[Perfetto] beforeExit handler invoked') + void writePerfettoTrace() + }) + + // Register a synchronous exit handler as a last resort + // This is the final fallback to ensure trace is written before process exits + process.on('exit', () => { + if (!traceWritten) { + logForDebugging( + '[Perfetto] exit handler invoked, writing trace synchronously', + ) + writePerfettoTraceSync() + } + }) + + // Emit process metadata events for main process + const mainAgent = getCurrentAgentInfo() + emitProcessMetadata(mainAgent) + } +} + +/** + * Emit metadata events for a process/agent + */ +function emitProcessMetadata(agentInfo: AgentInfo): void { + if (!isEnabled) return + + // Process name + metadataEvents.push({ + name: 'process_name', + cat: '__metadata', + ph: 'M', + ts: 0, + pid: agentInfo.processId, + tid: 0, + args: { name: agentInfo.agentName }, + }) + + // Thread name (same as process for now) + metadataEvents.push({ + name: 'thread_name', + cat: '__metadata', + ph: 'M', + ts: 0, + pid: agentInfo.processId, + tid: agentInfo.threadId, + args: { name: agentInfo.agentName }, + }) + + // Add parent info if available + if (agentInfo.parentAgentId) { + metadataEvents.push({ + name: 'parent_agent', + cat: '__metadata', + ph: 'M', + ts: 0, + pid: agentInfo.processId, + tid: 0, + args: { + parent_agent_id: agentInfo.parentAgentId, + }, + }) + } +} + +/** + * Check if Perfetto tracing is enabled + */ +export function isPerfettoTracingEnabled(): boolean { + return isEnabled +} + +/** + * Register a new agent in the trace + * Call this when a subagent/teammate is spawned + */ +export function registerAgent( + agentId: string, + agentName: string, + parentAgentId?: string, +): void { + if (!isEnabled) return + + const info: AgentInfo = { + agentId, + agentName, + parentAgentId, + processId: getProcessIdForAgent(agentId), + threadId: stringToNumericHash(agentName), + } + + agentRegistry.set(agentId, info) + totalAgentCount++ + emitProcessMetadata(info) +} + +/** + * Unregister an agent from the trace. + * Call this when an agent completes, fails, or is aborted to free memory. + */ +export function unregisterAgent(agentId: string): void { + if (!isEnabled) return + agentRegistry.delete(agentId) + agentIdToProcessId.delete(agentId) +} + +/** + * Start an API call span + */ +export function startLLMRequestPerfettoSpan(args: { + model: string + promptTokens?: number + messageId?: string + isSpeculative?: boolean + querySource?: string +}): string { + if (!isEnabled) return '' + + const spanId = generateSpanId() + const agentInfo = getCurrentAgentInfo() + + pendingSpans.set(spanId, { + name: 'API Call', + category: 'api', + startTime: getTimestamp(), + agentInfo, + args: { + model: args.model, + prompt_tokens: args.promptTokens, + message_id: args.messageId, + is_speculative: args.isSpeculative ?? false, + query_source: args.querySource, + }, + }) + + // Emit begin event + events.push({ + name: 'API Call', + cat: 'api', + ph: 'B', + ts: pendingSpans.get(spanId)!.startTime, + pid: agentInfo.processId, + tid: agentInfo.threadId, + args: pendingSpans.get(spanId)!.args, + }) + + return spanId +} + +/** + * End an API call span with response metadata + */ +export function endLLMRequestPerfettoSpan( + spanId: string, + metadata: { + ttftMs?: number + ttltMs?: number + promptTokens?: number + outputTokens?: number + cacheReadTokens?: number + cacheCreationTokens?: number + messageId?: string + success?: boolean + error?: string + /** Time spent in pre-request setup (client creation, retries) before the successful attempt */ + requestSetupMs?: number + /** Timestamps (Date.now()) of each attempt start — used to emit retry sub-spans */ + attemptStartTimes?: number[] + }, +): void { + if (!isEnabled || !spanId) return + + const pending = pendingSpans.get(spanId) + if (!pending) return + + const endTime = getTimestamp() + const duration = endTime - pending.startTime + + const promptTokens = + metadata.promptTokens ?? (pending.args.prompt_tokens as number | undefined) + const ttftMs = metadata.ttftMs + const ttltMs = metadata.ttltMs + const outputTokens = metadata.outputTokens + const cacheReadTokens = metadata.cacheReadTokens + + // Compute derived metrics + // ITPS: input tokens per second (prompt processing speed) + const itps = + ttftMs !== undefined && promptTokens !== undefined && ttftMs > 0 + ? Math.round((promptTokens / (ttftMs / 1000)) * 100) / 100 + : undefined + + // OTPS: output tokens per second (sampling speed) + const samplingMs = + ttltMs !== undefined && ttftMs !== undefined ? ttltMs - ttftMs : undefined + const otps = + samplingMs !== undefined && outputTokens !== undefined && samplingMs > 0 + ? Math.round((outputTokens / (samplingMs / 1000)) * 100) / 100 + : undefined + + // Cache hit rate: percentage of prompt tokens from cache + const cacheHitRate = + cacheReadTokens !== undefined && + promptTokens !== undefined && + promptTokens > 0 + ? Math.round((cacheReadTokens / promptTokens) * 10000) / 100 + : undefined + + const requestSetupMs = metadata.requestSetupMs + const attemptStartTimes = metadata.attemptStartTimes + + // Merge metadata with original args + const args = { + ...pending.args, + ttft_ms: ttftMs, + ttlt_ms: ttltMs, + prompt_tokens: promptTokens, + output_tokens: outputTokens, + cache_read_tokens: cacheReadTokens, + cache_creation_tokens: metadata.cacheCreationTokens, + message_id: metadata.messageId ?? pending.args.message_id, + success: metadata.success ?? true, + error: metadata.error, + duration_ms: duration / 1000, + request_setup_ms: requestSetupMs, + // Derived metrics + itps, + otps, + cache_hit_rate_pct: cacheHitRate, + } + + // Emit Request Setup sub-span when there was measurable setup time + // (client creation, param building, retries before the successful attempt) + const setupUs = + requestSetupMs !== undefined && requestSetupMs > 0 + ? requestSetupMs * 1000 + : 0 + if (setupUs > 0) { + const setupEndTs = pending.startTime + setupUs + + events.push({ + name: 'Request Setup', + cat: 'api,setup', + ph: 'B', + ts: pending.startTime, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args: { + request_setup_ms: requestSetupMs, + attempt_count: attemptStartTimes?.length ?? 1, + }, + }) + + // Emit retry attempt sub-spans within Request Setup. + // Each failed attempt runs from its start to the next attempt's start. + if (attemptStartTimes && attemptStartTimes.length > 1) { + // attemptStartTimes[0] is the reference point (first attempt). + // Convert wall-clock deltas into Perfetto-relative microseconds. + const baseWallMs = attemptStartTimes[0]! + for (let i = 0; i < attemptStartTimes.length - 1; i++) { + const attemptStartUs = + pending.startTime + (attemptStartTimes[i]! - baseWallMs) * 1000 + const attemptEndUs = + pending.startTime + (attemptStartTimes[i + 1]! - baseWallMs) * 1000 + + events.push({ + name: `Attempt ${i + 1} (retry)`, + cat: 'api,retry', + ph: 'B', + ts: attemptStartUs, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args: { attempt: i + 1 }, + }) + events.push({ + name: `Attempt ${i + 1} (retry)`, + cat: 'api,retry', + ph: 'E', + ts: attemptEndUs, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + }) + } + } + + events.push({ + name: 'Request Setup', + cat: 'api,setup', + ph: 'E', + ts: setupEndTs, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + }) + } + + // Emit sub-spans for First Token and Sampling phases (before API Call end) + // Using B/E pairs in proper nesting order for correct Perfetto visualization + if (ttftMs !== undefined) { + // First Token starts after request setup (if any) + const firstTokenStartTs = pending.startTime + setupUs + const firstTokenEndTs = firstTokenStartTs + ttftMs * 1000 + + // First Token phase: from successful attempt start to first token + events.push({ + name: 'First Token', + cat: 'api,ttft', + ph: 'B', + ts: firstTokenStartTs, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args: { + ttft_ms: ttftMs, + prompt_tokens: promptTokens, + itps, + cache_hit_rate_pct: cacheHitRate, + }, + }) + events.push({ + name: 'First Token', + cat: 'api,ttft', + ph: 'E', + ts: firstTokenEndTs, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + }) + + // Sampling phase: from first token to last token + // Note: samplingMs = ttltMs - ttftMs still includes setup time in ttltMs, + // so we compute the actual sampling duration for the span as the time from + // first token to API call end (endTime), not samplingMs directly. + const actualSamplingMs = + ttltMs !== undefined ? ttltMs - ttftMs - setupUs / 1000 : undefined + if (actualSamplingMs !== undefined && actualSamplingMs > 0) { + events.push({ + name: 'Sampling', + cat: 'api,sampling', + ph: 'B', + ts: firstTokenEndTs, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args: { + sampling_ms: actualSamplingMs, + output_tokens: outputTokens, + otps, + }, + }) + events.push({ + name: 'Sampling', + cat: 'api,sampling', + ph: 'E', + ts: firstTokenEndTs + actualSamplingMs * 1000, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + }) + } + } + + // Emit API Call end event (after sub-spans) + events.push({ + name: pending.name, + cat: pending.category, + ph: 'E', + ts: endTime, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args, + }) + + pendingSpans.delete(spanId) +} + +/** + * Start a tool execution span + */ +export function startToolPerfettoSpan( + toolName: string, + args?: Record, +): string { + if (!isEnabled) return '' + + const spanId = generateSpanId() + const agentInfo = getCurrentAgentInfo() + + pendingSpans.set(spanId, { + name: `Tool: ${toolName}`, + category: 'tool', + startTime: getTimestamp(), + agentInfo, + args: { + tool_name: toolName, + ...args, + }, + }) + + // Emit begin event + events.push({ + name: `Tool: ${toolName}`, + cat: 'tool', + ph: 'B', + ts: pendingSpans.get(spanId)!.startTime, + pid: agentInfo.processId, + tid: agentInfo.threadId, + args: pendingSpans.get(spanId)!.args, + }) + + return spanId +} + +/** + * End a tool execution span + */ +export function endToolPerfettoSpan( + spanId: string, + metadata?: { + success?: boolean + error?: string + resultTokens?: number + }, +): void { + if (!isEnabled || !spanId) return + + const pending = pendingSpans.get(spanId) + if (!pending) return + + const endTime = getTimestamp() + const duration = endTime - pending.startTime + + const args = { + ...pending.args, + success: metadata?.success ?? true, + error: metadata?.error, + result_tokens: metadata?.resultTokens, + duration_ms: duration / 1000, + } + + // Emit end event + events.push({ + name: pending.name, + cat: pending.category, + ph: 'E', + ts: endTime, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args, + }) + + pendingSpans.delete(spanId) +} + +/** + * Start a user input waiting span + */ +export function startUserInputPerfettoSpan(context?: string): string { + if (!isEnabled) return '' + + const spanId = generateSpanId() + const agentInfo = getCurrentAgentInfo() + + pendingSpans.set(spanId, { + name: 'Waiting for User Input', + category: 'user_input', + startTime: getTimestamp(), + agentInfo, + args: { + context, + }, + }) + + // Emit begin event + events.push({ + name: 'Waiting for User Input', + cat: 'user_input', + ph: 'B', + ts: pendingSpans.get(spanId)!.startTime, + pid: agentInfo.processId, + tid: agentInfo.threadId, + args: pendingSpans.get(spanId)!.args, + }) + + return spanId +} + +/** + * End a user input waiting span + */ +export function endUserInputPerfettoSpan( + spanId: string, + metadata?: { + decision?: string + source?: string + }, +): void { + if (!isEnabled || !spanId) return + + const pending = pendingSpans.get(spanId) + if (!pending) return + + const endTime = getTimestamp() + const duration = endTime - pending.startTime + + const args = { + ...pending.args, + decision: metadata?.decision, + source: metadata?.source, + duration_ms: duration / 1000, + } + + // Emit end event + events.push({ + name: pending.name, + cat: pending.category, + ph: 'E', + ts: endTime, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args, + }) + + pendingSpans.delete(spanId) +} + +/** + * Emit an instant event (marker) + */ +export function emitPerfettoInstant( + name: string, + category: string, + args?: Record, +): void { + if (!isEnabled) return + + const agentInfo = getCurrentAgentInfo() + + events.push({ + name, + cat: category, + ph: 'i', + ts: getTimestamp(), + pid: agentInfo.processId, + tid: agentInfo.threadId, + args, + }) +} + +/** + * Emit a counter event for tracking metrics over time + */ +export function emitPerfettoCounter( + name: string, + values: Record, +): void { + if (!isEnabled) return + + const agentInfo = getCurrentAgentInfo() + + events.push({ + name, + cat: 'counter', + ph: 'C', + ts: getTimestamp(), + pid: agentInfo.processId, + tid: agentInfo.threadId, + args: values, + }) +} + +/** + * Start an interaction span (wraps a full user request cycle) + */ +export function startInteractionPerfettoSpan(userPrompt?: string): string { + if (!isEnabled) return '' + + const spanId = generateSpanId() + const agentInfo = getCurrentAgentInfo() + + pendingSpans.set(spanId, { + name: 'Interaction', + category: 'interaction', + startTime: getTimestamp(), + agentInfo, + args: { + user_prompt_length: userPrompt?.length, + }, + }) + + // Emit begin event + events.push({ + name: 'Interaction', + cat: 'interaction', + ph: 'B', + ts: pendingSpans.get(spanId)!.startTime, + pid: agentInfo.processId, + tid: agentInfo.threadId, + args: pendingSpans.get(spanId)!.args, + }) + + return spanId +} + +/** + * End an interaction span + */ +export function endInteractionPerfettoSpan(spanId: string): void { + if (!isEnabled || !spanId) return + + const pending = pendingSpans.get(spanId) + if (!pending) return + + const endTime = getTimestamp() + const duration = endTime - pending.startTime + + // Emit end event + events.push({ + name: pending.name, + cat: pending.category, + ph: 'E', + ts: endTime, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args: { + ...pending.args, + duration_ms: duration / 1000, + }, + }) + + pendingSpans.delete(spanId) +} + +// --------------------------------------------------------------------------- +// Periodic write helpers +// --------------------------------------------------------------------------- + +/** + * Stop the periodic write timer. + */ +function stopWriteInterval(): void { + if (staleSpanCleanupId) { + clearInterval(staleSpanCleanupId) + staleSpanCleanupId = null + } + if (writeIntervalId) { + clearInterval(writeIntervalId) + writeIntervalId = null + } +} + +/** + * Force-close any remaining open spans at session end. + */ +function closeOpenSpans(): void { + for (const [spanId, pending] of pendingSpans) { + const endTime = getTimestamp() + events.push({ + name: pending.name, + cat: pending.category, + ph: 'E', + ts: endTime, + pid: pending.agentInfo.processId, + tid: pending.agentInfo.threadId, + args: { + ...pending.args, + incomplete: true, + duration_ms: (endTime - pending.startTime) / 1000, + }, + }) + pendingSpans.delete(spanId) + } +} + +/** + * Write the full trace to disk. Errors are logged but swallowed so that a + * transient I/O problem does not crash the session — the next periodic tick + * (or the final exit write) will retry with a complete snapshot. + */ +async function periodicWrite(): Promise { + if (!isEnabled || !tracePath || traceWritten) return + + try { + await mkdir(dirname(tracePath), { recursive: true }) + await writeFile(tracePath, buildTraceDocument()) + logForDebugging( + `[Perfetto] Periodic write: ${events.length} events to ${tracePath}`, + ) + } catch (error) { + logForDebugging( + `[Perfetto] Periodic write failed: ${errorMessage(error)}`, + { level: 'error' }, + ) + } +} + +/** + * Final async write: close open spans and write the complete trace. + * Idempotent — sets `traceWritten` on success so subsequent calls are no-ops. + */ +async function writePerfettoTrace(): Promise { + if (!isEnabled || !tracePath || traceWritten) { + logForDebugging( + `[Perfetto] Skipping final write: isEnabled=${isEnabled}, tracePath=${tracePath}, traceWritten=${traceWritten}`, + ) + return + } + + stopWriteInterval() + closeOpenSpans() + + logForDebugging( + `[Perfetto] writePerfettoTrace called: events=${events.length}`, + ) + + try { + await mkdir(dirname(tracePath), { recursive: true }) + await writeFile(tracePath, buildTraceDocument()) + traceWritten = true + logForDebugging(`[Perfetto] Trace finalized at: ${tracePath}`) + } catch (error) { + logForDebugging( + `[Perfetto] Failed to write final trace: ${errorMessage(error)}`, + { level: 'error' }, + ) + } +} + +/** + * Final synchronous write (fallback for process 'exit' handler where async is forbidden). + */ +function writePerfettoTraceSync(): void { + if (!isEnabled || !tracePath || traceWritten) { + logForDebugging( + `[Perfetto] Skipping final sync write: isEnabled=${isEnabled}, tracePath=${tracePath}, traceWritten=${traceWritten}`, + ) + return + } + + stopWriteInterval() + closeOpenSpans() + + logForDebugging( + `[Perfetto] writePerfettoTraceSync called: events=${events.length}`, + ) + + try { + const dir = dirname(tracePath) + // eslint-disable-next-line custom-rules/no-sync-fs -- Only called from process.on('exit') handler + mkdirSync(dir, { recursive: true }) + // eslint-disable-next-line custom-rules/no-sync-fs, eslint-plugin-n/no-sync -- Required for process 'exit' handler which doesn't support async + writeFileSync(tracePath, buildTraceDocument()) + traceWritten = true + logForDebugging(`[Perfetto] Trace finalized synchronously at: ${tracePath}`) + } catch (error) { + logForDebugging( + `[Perfetto] Failed to write final trace synchronously: ${errorMessage(error)}`, + { level: 'error' }, + ) + } +} + +/** + * Get all recorded events (for testing) + */ +export function getPerfettoEvents(): TraceEvent[] { + return [...metadataEvents, ...events] +} + +/** + * Reset the tracer state (for testing) + */ +export function resetPerfettoTracer(): void { + if (staleSpanCleanupId) { + clearInterval(staleSpanCleanupId) + staleSpanCleanupId = null + } + stopWriteInterval() + metadataEvents.length = 0 + events.length = 0 + pendingSpans.clear() + agentRegistry.clear() + agentIdToProcessId.clear() + totalAgentCount = 0 + processIdCounter = 1 + spanIdCounter = 0 + isEnabled = false + tracePath = null + startTimeMs = 0 + traceWritten = false +} + +/** + * Trigger a periodic write immediately (for testing) + */ +export async function triggerPeriodicWriteForTesting(): Promise { + await periodicWrite() +} + +/** + * Evict stale spans immediately (for testing) + */ +export function evictStaleSpansForTesting(): void { + evictStaleSpans() +} + +export const MAX_EVENTS_FOR_TESTING = MAX_EVENTS +export function evictOldestEventsForTesting(): void { + evictOldestEvents() +} diff --git a/src/utils/telemetry/pluginTelemetry.ts b/src/utils/telemetry/pluginTelemetry.ts new file mode 100644 index 0000000000000000000000000000000000000000..30600e74efc3dc099752de12636fad6568f30e10 --- /dev/null +++ b/src/utils/telemetry/pluginTelemetry.ts @@ -0,0 +1,289 @@ +/** + * Plugin telemetry helpers — shared field builders for plugin lifecycle events. + * + * Implements the twin-column privacy pattern: every user-defined-name field + * emits both a raw value (routed to PII-tagged _PROTO_* BQ columns) and a + * redacted twin (real name iff marketplace ∈ allowlist, else 'third-party'). + * + * plugin_id_hash provides an opaque per-plugin aggregation key with no privacy + * dependency — sha256(name@marketplace + FIXED_SALT) truncated to 16 chars. + * This answers distinct-count and per-plugin-trend questions that the + * redacted column can't, without exposing user-defined names. + */ + +import { createHash } from 'crypto' +import { sep } from 'path' +import { + type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + type AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, + logEvent, +} from '../../services/analytics/index.js' +import type { + LoadedPlugin, + PluginError, + PluginManifest, +} from '../../types/plugin.js' +import { + isOfficialMarketplaceName, + parsePluginIdentifier, +} from '../plugins/pluginIdentifier.js' + +// builtinPlugins.ts:BUILTIN_MARKETPLACE_NAME — inlined to avoid the cycle +// through commands.js. Marketplace schemas.ts enforces 'builtin' is reserved. +const BUILTIN_MARKETPLACE_NAME = 'builtin' + +// Fixed salt for plugin_id_hash. Same constant across all repos and emission +// sites. Not per-org, not rotated — per-org salt would defeat cross-org +// distinct-count, rotation would break trend lines. Customers can compute the +// same hash on their known plugin names to reverse-match their own telemetry. +const PLUGIN_ID_HASH_SALT = 'claude-plugin-telemetry-v1' + +/** + * Opaque per-plugin aggregation key. Input is the name@marketplace string as + * it appears in enabledPlugins keys, lowercased on the marketplace suffix for + * reproducibility. 16-char truncation keeps BQ GROUP BY cardinality manageable + * while making collisions negligible at projected 10k-plugin scale. Name case + * is preserved in both branches (enabledPlugins keys are case-sensitive). + */ +export function hashPluginId(name: string, marketplace?: string): string { + const key = marketplace ? `${name}@${marketplace.toLowerCase()}` : name + return createHash('sha256') + .update(key + PLUGIN_ID_HASH_SALT) + .digest('hex') + .slice(0, 16) +} + +/** + * 4-value scope enum for plugin origin. Distinct from PluginScope + * (managed/user/project/local) which is installation-target — this is + * marketplace-origin. + * + * - official: from an allowlisted Anthropic marketplace + * - default-bundle: ships with product (@builtin), auto-enabled + * - org: enterprise admin-pushed via managed settings (policySettings) + * - user-local: user added marketplace or local plugin + */ +export type TelemetryPluginScope = + | 'official' + | 'org' + | 'user-local' + | 'default-bundle' + +export function getTelemetryPluginScope( + name: string, + marketplace: string | undefined, + managedNames: Set | null, +): TelemetryPluginScope { + if (marketplace === BUILTIN_MARKETPLACE_NAME) return 'default-bundle' + if (isOfficialMarketplaceName(marketplace)) return 'official' + if (managedNames?.has(name)) return 'org' + return 'user-local' +} + +/** + * How a plugin arrived in the session. Splits self-selected from org-pushed + * — plugin_scope alone doesn't (an official plugin can be user-installed OR + * org-pushed; both are scope='official'). + */ +export type EnabledVia = + | 'user-install' + | 'org-policy' + | 'default-enable' + | 'seed-mount' + +/** How a skill/command invocation was triggered. */ +export type InvocationTrigger = + | 'user-slash' + | 'claude-proactive' + | 'nested-skill' + +/** Where a skill invocation executes. */ +export type SkillExecutionContext = 'fork' | 'inline' | 'remote' + +/** How a plugin install was initiated. */ +export type InstallSource = + | 'cli-explicit' + | 'ui-discover' + | 'ui-suggestion' + | 'deep-link' + +export function getEnabledVia( + plugin: LoadedPlugin, + managedNames: Set | null, + seedDirs: string[], +): EnabledVia { + if (plugin.isBuiltin) return 'default-enable' + if (managedNames?.has(plugin.name)) return 'org-policy' + // Trailing sep: /opt/plugins must not match /opt/plugins-extra + if ( + seedDirs.some(dir => + plugin.path.startsWith(dir.endsWith(sep) ? dir : dir + sep), + ) + ) { + return 'seed-mount' + } + return 'user-install' +} + +/** + * Common plugin telemetry fields keyed off name@marketplace. Returns the + * hash, scope enum, and the redacted-twin columns. Callers add the raw + * _PROTO_* fields separately (those require the PII-tagged marker type). + */ +export function buildPluginTelemetryFields( + name: string, + marketplace: string | undefined, + managedNames: Set | null = null, +): { + plugin_id_hash: AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS + plugin_scope: AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS + plugin_name_redacted: AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS + marketplace_name_redacted: AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS + is_official_plugin: boolean +} { + const scope = getTelemetryPluginScope(name, marketplace, managedNames) + // Both official marketplaces and builtin plugins are Anthropic-controlled + // — safe to expose real names in the redacted columns. + const isAnthropicControlled = + scope === 'official' || scope === 'default-bundle' + return { + plugin_id_hash: hashPluginId( + name, + marketplace, + ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + plugin_scope: + scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + plugin_name_redacted: (isAnthropicControlled + ? name + : 'third-party') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + marketplace_name_redacted: (isAnthropicControlled && marketplace + ? marketplace + : 'third-party') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + is_official_plugin: isAnthropicControlled, + } +} + +/** + * Per-invocation callers (SkillTool, processSlashCommand) pass + * managedNames=null — the session-level tengu_plugin_enabled_for_session + * event carries the authoritative plugin_scope, and per-invocation rows can + * join on plugin_id_hash to recover it. This keeps hot-path call sites free + * of the extra settings read. + */ +export function buildPluginCommandTelemetryFields( + pluginInfo: { pluginManifest: PluginManifest; repository: string }, + managedNames: Set | null = null, +): ReturnType { + const { marketplace } = parsePluginIdentifier(pluginInfo.repository) + return buildPluginTelemetryFields( + pluginInfo.pluginManifest.name, + marketplace, + managedNames, + ) +} + +/** + * Emit tengu_plugin_enabled_for_session once per enabled plugin at session + * start. Supplements tengu_skill_loaded (which still fires per-skill) — use + * this for plugin-level aggregates instead of DISTINCT-on-prefix hacks. + * A plugin with 5 skills emits 5 skill_loaded rows but 1 of these. + */ +export function logPluginsEnabledForSession( + plugins: LoadedPlugin[], + managedNames: Set | null, + seedDirs: string[], +): void { + for (const plugin of plugins) { + const { marketplace } = parsePluginIdentifier(plugin.repository) + + logEvent('tengu_plugin_enabled_for_session', { + _PROTO_plugin_name: + plugin.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, + ...(marketplace && { + _PROTO_marketplace_name: + marketplace as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, + }), + ...buildPluginTelemetryFields(plugin.name, marketplace, managedNames), + enabled_via: getEnabledVia( + plugin, + managedNames, + seedDirs, + ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + skill_path_count: + (plugin.skillsPath ? 1 : 0) + (plugin.skillsPaths?.length ?? 0), + command_path_count: + (plugin.commandsPath ? 1 : 0) + (plugin.commandsPaths?.length ?? 0), + has_mcp: plugin.manifest.mcpServers !== undefined, + has_hooks: plugin.hooksConfig !== undefined, + ...(plugin.manifest.version && { + version: plugin.manifest + .version as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + }), + }) + } +} + +/** + * Bounded-cardinality error bucket for CLI plugin operation failures. + * Maps free-form error messages to 5 stable categories so dashboard + * GROUP BY stays tractable. + */ +export type PluginCommandErrorCategory = + | 'network' + | 'not-found' + | 'permission' + | 'validation' + | 'unknown' + +export function classifyPluginCommandError( + error: unknown, +): PluginCommandErrorCategory { + const msg = String((error as { message?: unknown })?.message ?? error) + if ( + /ENOTFOUND|ECONNREFUSED|EAI_AGAIN|ETIMEDOUT|ECONNRESET|network|Could not resolve|Connection refused|timed out/i.test( + msg, + ) + ) { + return 'network' + } + if (/\b404\b|not found|does not exist|no such plugin/i.test(msg)) { + return 'not-found' + } + if (/\b40[13]\b|EACCES|EPERM|permission denied|unauthorized/i.test(msg)) { + return 'permission' + } + if (/invalid|malformed|schema|validation|parse error/i.test(msg)) { + return 'validation' + } + return 'unknown' +} + +/** + * Emit tengu_plugin_load_failed once per error surfaced by session-start + * plugin loading. Pairs with tengu_plugin_enabled_for_session so dashboards + * can compute a load-success rate. PluginError.type is already a bounded + * enum — use it directly as error_category. + */ +export function logPluginLoadErrors( + errors: PluginError[], + managedNames: Set | null, +): void { + for (const err of errors) { + const { name, marketplace } = parsePluginIdentifier(err.source) + // Not all PluginError variants carry a plugin name (some have pluginId, + // some are marketplace-level). Use the 'plugin' property if present, + // fall back to the name parsed from err.source. + const pluginName = 'plugin' in err && err.plugin ? err.plugin : name + logEvent('tengu_plugin_load_failed', { + error_category: + err.type as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + _PROTO_plugin_name: + pluginName as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, + ...(marketplace && { + _PROTO_marketplace_name: + marketplace as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, + }), + ...buildPluginTelemetryFields(pluginName, marketplace, managedNames), + }) + } +} diff --git a/src/utils/telemetry/sessionTracing.ts b/src/utils/telemetry/sessionTracing.ts new file mode 100644 index 0000000000000000000000000000000000000000..0ee4f38117cbc3ae4ed5206be07dfc08cd256a4e --- /dev/null +++ b/src/utils/telemetry/sessionTracing.ts @@ -0,0 +1,927 @@ +/** + * Session Tracing for Claude Code using OpenTelemetry (BETA) + * + * This module provides a high-level API for creating and managing spans + * to trace Claude Code workflows. Each user interaction creates a root + * interaction span, which contains operation spans (LLM requests, tool calls, etc.). + * + * Requirements: + * - Enhanced telemetry is enabled via feature('ENHANCED_TELEMETRY_BETA') + * - Configure OTEL_TRACES_EXPORTER (console, otlp, etc.) + */ + +import { feature } from 'bun:bundle' +import { context as otelContext, type Span, trace } from '@opentelemetry/api' +import { AsyncLocalStorage } from 'async_hooks' +import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js' +import type { AssistantMessage, UserMessage } from '../../types/message.js' +import { isEnvDefinedFalsy, isEnvTruthy } from '../envUtils.js' +import { getTelemetryAttributes } from '../telemetryAttributes.js' +import { + addBetaInteractionAttributes, + addBetaLLMRequestAttributes, + addBetaLLMResponseAttributes, + addBetaToolInputAttributes, + addBetaToolResultAttributes, + isBetaTracingEnabled, + type LLMRequestNewContext, + truncateContent, +} from './betaSessionTracing.js' +import { + endInteractionPerfettoSpan, + endLLMRequestPerfettoSpan, + endToolPerfettoSpan, + endUserInputPerfettoSpan, + isPerfettoTracingEnabled, + startInteractionPerfettoSpan, + startLLMRequestPerfettoSpan, + startToolPerfettoSpan, + startUserInputPerfettoSpan, +} from './perfettoTracing.js' + +// Re-export for callers +export type { Span } +export { isBetaTracingEnabled, type LLMRequestNewContext } + +// Message type for API calls (UserMessage or AssistantMessage) +type APIMessage = UserMessage | AssistantMessage + +type SpanType = + | 'interaction' + | 'llm_request' + | 'tool' + | 'tool.blocked_on_user' + | 'tool.execution' + | 'hook' + +interface SpanContext { + span: Span + startTime: number + attributes: Record + ended?: boolean + perfettoSpanId?: string +} + +// ALS stores SpanContext directly so it holds a strong reference while a span +// is active. With that, activeSpans can use WeakRef — when ALS is cleared +// (enterWith(undefined)) and no other code holds the SpanContext, GC can collect +// it and the WeakRef goes stale. +const interactionContext = new AsyncLocalStorage() +const toolContext = new AsyncLocalStorage() +const activeSpans = new Map>() +// Spans not stored in ALS (LLM request, blocked-on-user, tool execution, hook) +// need a strong reference to prevent GC from collecting the SpanContext before +// the corresponding end* function retrieves it. +const strongSpans = new Map() +let interactionSequence = 0 +let _cleanupIntervalStarted = false + +const SPAN_TTL_MS = 30 * 60 * 1000 // 30 minutes + +function getSpanId(span: Span): string { + return span.spanContext().spanId || '' +} + +/** + * Lazily start a background interval that evicts orphaned spans from activeSpans. + * + * Normal teardown calls endInteractionSpan / endToolSpan, which delete spans + * immediately. This interval is a safety net for spans that were never ended + * (e.g. aborted streams, uncaught exceptions mid-query) — without it they + * accumulate in activeSpans indefinitely, holding references to Span objects + * and the OpenTelemetry context chain. + * + * Initialized on the first startInteractionSpan call (not at module load) to + * avoid triggering the no-top-level-side-effects lint rule and to keep the + * interval from running in processes that never start a span. + * unref() prevents the timer from keeping the process alive after all other + * work is done. + */ +function ensureCleanupInterval(): void { + if (_cleanupIntervalStarted) return + _cleanupIntervalStarted = true + const interval = setInterval(() => { + const cutoff = Date.now() - SPAN_TTL_MS + for (const [spanId, weakRef] of activeSpans) { + const ctx = weakRef.deref() + if (ctx === undefined) { + activeSpans.delete(spanId) + strongSpans.delete(spanId) + } else if (ctx.startTime < cutoff) { + if (!ctx.ended) ctx.span.end() // flush any recorded attributes to the exporter + activeSpans.delete(spanId) + strongSpans.delete(spanId) + } + } + }, 60_000) + if (typeof interval.unref === 'function') { + interval.unref() // Node.js / Bun: don't block process exit + } +} + +/** + * Check if enhanced telemetry is enabled. + * Priority: env var override > ant build > GrowthBook gate + */ +export function isEnhancedTelemetryEnabled(): boolean { + if (feature('ENHANCED_TELEMETRY_BETA')) { + const env = + process.env.CLAUDE_CODE_ENHANCED_TELEMETRY_BETA ?? + process.env.ENABLE_ENHANCED_TELEMETRY_BETA + if (isEnvTruthy(env)) { + return true + } + if (isEnvDefinedFalsy(env)) { + return false + } + return ( + process.env.USER_TYPE === 'ant' || + getFeatureValue_CACHED_MAY_BE_STALE('enhanced_telemetry_beta', false) + ) + } + return false +} + +/** + * Check if any tracing is enabled (either standard enhanced telemetry OR beta tracing) + */ +function isAnyTracingEnabled(): boolean { + return isEnhancedTelemetryEnabled() || isBetaTracingEnabled() +} + +function getTracer() { + return trace.getTracer('com.anthropic.claude_code.tracing', '1.0.0') +} + +function createSpanAttributes( + spanType: SpanType, + customAttributes: Record = {}, +): Record { + const baseAttributes = getTelemetryAttributes() + + const attributes: Record = { + ...baseAttributes, + 'span.type': spanType, + ...customAttributes, + } + + return attributes +} + +/** + * Start an interaction span. This wraps a user request -> Claude response cycle. + * This is now a root span that includes all session-level attributes. + * Sets the interaction context for all subsequent operations. + */ +export function startInteractionSpan(userPrompt: string): Span { + ensureCleanupInterval() + + // Start Perfetto span regardless of OTel tracing state + const perfettoSpanId = isPerfettoTracingEnabled() + ? startInteractionPerfettoSpan(userPrompt) + : undefined + + if (!isAnyTracingEnabled()) { + // Still track Perfetto span even if OTel is disabled + if (perfettoSpanId) { + const dummySpan = trace.getActiveSpan() || getTracer().startSpan('dummy') + const spanId = getSpanId(dummySpan) + const spanContextObj: SpanContext = { + span: dummySpan, + startTime: Date.now(), + attributes: {}, + perfettoSpanId, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + interactionContext.enterWith(spanContextObj) + return dummySpan + } + return trace.getActiveSpan() || getTracer().startSpan('dummy') + } + + const tracer = getTracer() + const isUserPromptLoggingEnabled = isEnvTruthy( + process.env.OTEL_LOG_USER_PROMPTS, + ) + const promptToLog = isUserPromptLoggingEnabled ? userPrompt : '' + + interactionSequence++ + + const attributes = createSpanAttributes('interaction', { + user_prompt: promptToLog, + user_prompt_length: userPrompt.length, + 'interaction.sequence': interactionSequence, + }) + + const span = tracer.startSpan('claude_code.interaction', { + attributes, + }) + + // Add experimental attributes (new_context) + addBetaInteractionAttributes(span, userPrompt) + + const spanId = getSpanId(span) + const spanContextObj: SpanContext = { + span, + startTime: Date.now(), + attributes, + perfettoSpanId, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + + interactionContext.enterWith(spanContextObj) + + return span +} + +export function endInteractionSpan(): void { + const spanContext = interactionContext.getStore() + if (!spanContext) { + return + } + + if (spanContext.ended) { + return + } + + // End Perfetto span + if (spanContext.perfettoSpanId) { + endInteractionPerfettoSpan(spanContext.perfettoSpanId) + } + + if (!isAnyTracingEnabled()) { + spanContext.ended = true + activeSpans.delete(getSpanId(spanContext.span)) + // Clear the store so async continuations created after this point (timers, + // promise callbacks, I/O) do not inherit a reference to the ended span. + // enterWith(undefined) is intentional: exit(() => {}) is a no-op because it + // only suppresses the store inside the callback and returns immediately. + interactionContext.enterWith(undefined) + return + } + + const duration = Date.now() - spanContext.startTime + spanContext.span.setAttributes({ + 'interaction.duration_ms': duration, + }) + + spanContext.span.end() + spanContext.ended = true + activeSpans.delete(getSpanId(spanContext.span)) + interactionContext.enterWith(undefined) +} + +export function startLLMRequestSpan( + model: string, + newContext?: LLMRequestNewContext, + messagesForAPI?: APIMessage[], + fastMode?: boolean, +): Span { + // Start Perfetto span regardless of OTel tracing state + const perfettoSpanId = isPerfettoTracingEnabled() + ? startLLMRequestPerfettoSpan({ + model, + querySource: newContext?.querySource, + messageId: undefined, // Will be set in endLLMRequestSpan + }) + : undefined + + if (!isAnyTracingEnabled()) { + // Still track Perfetto span even if OTel is disabled + if (perfettoSpanId) { + const dummySpan = trace.getActiveSpan() || getTracer().startSpan('dummy') + const spanId = getSpanId(dummySpan) + const spanContextObj: SpanContext = { + span: dummySpan, + startTime: Date.now(), + attributes: { model }, + perfettoSpanId, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + strongSpans.set(spanId, spanContextObj) + return dummySpan + } + return trace.getActiveSpan() || getTracer().startSpan('dummy') + } + + const tracer = getTracer() + const parentSpanCtx = interactionContext.getStore() + + const attributes = createSpanAttributes('llm_request', { + model: model, + 'llm_request.context': parentSpanCtx ? 'interaction' : 'standalone', + speed: fastMode ? 'fast' : 'normal', + }) + + const ctx = parentSpanCtx + ? trace.setSpan(otelContext.active(), parentSpanCtx.span) + : otelContext.active() + const span = tracer.startSpan('claude_code.llm_request', { attributes }, ctx) + + // Add query_source (agent name) if provided + if (newContext?.querySource) { + span.setAttribute('query_source', newContext.querySource) + } + + // Add experimental attributes (system prompt, new_context) + addBetaLLMRequestAttributes(span, newContext, messagesForAPI) + + const spanId = getSpanId(span) + const spanContextObj: SpanContext = { + span, + startTime: Date.now(), + attributes, + perfettoSpanId, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + strongSpans.set(spanId, spanContextObj) + + return span +} + +/** + * End an LLM request span and attach response metadata. + * + * @param span - Optional. The exact span returned by startLLMRequestSpan(). + * IMPORTANT: When multiple LLM requests run in parallel (e.g., warmup requests, + * topic classifier, file path extractor, main thread), you MUST pass the specific span + * to ensure responses are attached to the correct request. Without it, responses may be + * incorrectly attached to whichever span happens to be "last" in the activeSpans map. + * + * If not provided, falls back to finding the most recent llm_request span (legacy behavior). + */ +export function endLLMRequestSpan( + span?: Span, + metadata?: { + inputTokens?: number + outputTokens?: number + cacheReadTokens?: number + cacheCreationTokens?: number + success?: boolean + statusCode?: number + error?: string + attempt?: number + modelResponse?: string + /** Text output from the model (non-thinking content) */ + modelOutput?: string + /** Thinking/reasoning output from the model */ + thinkingOutput?: string + /** Whether the output included tool calls (look at tool spans for details) */ + hasToolCall?: boolean + /** Time to first token in milliseconds */ + ttftMs?: number + /** Time spent in pre-request setup before the successful attempt */ + requestSetupMs?: number + /** Timestamps (Date.now()) of each attempt start — used to emit retry sub-spans */ + attemptStartTimes?: number[] + }, +): void { + let llmSpanContext: SpanContext | undefined + + if (span) { + // Use the provided span directly - this is the correct approach for parallel requests + const spanId = getSpanId(span) + llmSpanContext = activeSpans.get(spanId)?.deref() + } else { + // Legacy fallback: find the most recent llm_request span + // WARNING: This can cause mismatched responses when multiple requests are in flight + llmSpanContext = Array.from(activeSpans.values()) + .findLast(r => { + const ctx = r.deref() + return ( + ctx?.attributes['span.type'] === 'llm_request' || + ctx?.attributes['model'] + ) + }) + ?.deref() + } + + if (!llmSpanContext) { + // Span was already ended or never tracked + return + } + + const duration = Date.now() - llmSpanContext.startTime + + // End Perfetto span with full metadata + if (llmSpanContext.perfettoSpanId) { + endLLMRequestPerfettoSpan(llmSpanContext.perfettoSpanId, { + ttftMs: metadata?.ttftMs, + ttltMs: duration, // Time to last token is the total duration + promptTokens: metadata?.inputTokens, + outputTokens: metadata?.outputTokens, + cacheReadTokens: metadata?.cacheReadTokens, + cacheCreationTokens: metadata?.cacheCreationTokens, + success: metadata?.success, + error: metadata?.error, + requestSetupMs: metadata?.requestSetupMs, + attemptStartTimes: metadata?.attemptStartTimes, + }) + } + + if (!isAnyTracingEnabled()) { + const spanId = getSpanId(llmSpanContext.span) + activeSpans.delete(spanId) + strongSpans.delete(spanId) + return + } + + const endAttributes: Record = { + duration_ms: duration, + } + + if (metadata) { + if (metadata.inputTokens !== undefined) + endAttributes['input_tokens'] = metadata.inputTokens + if (metadata.outputTokens !== undefined) + endAttributes['output_tokens'] = metadata.outputTokens + if (metadata.cacheReadTokens !== undefined) + endAttributes['cache_read_tokens'] = metadata.cacheReadTokens + if (metadata.cacheCreationTokens !== undefined) + endAttributes['cache_creation_tokens'] = metadata.cacheCreationTokens + if (metadata.success !== undefined) + endAttributes['success'] = metadata.success + if (metadata.statusCode !== undefined) + endAttributes['status_code'] = metadata.statusCode + if (metadata.error !== undefined) endAttributes['error'] = metadata.error + if (metadata.attempt !== undefined) + endAttributes['attempt'] = metadata.attempt + if (metadata.hasToolCall !== undefined) + endAttributes['response.has_tool_call'] = metadata.hasToolCall + if (metadata.ttftMs !== undefined) + endAttributes['ttft_ms'] = metadata.ttftMs + + // Add experimental response attributes (model_output, thinking_output) + addBetaLLMResponseAttributes(endAttributes, metadata) + } + + llmSpanContext.span.setAttributes(endAttributes) + llmSpanContext.span.end() + + const spanId = getSpanId(llmSpanContext.span) + activeSpans.delete(spanId) + strongSpans.delete(spanId) +} + +export function startToolSpan( + toolName: string, + toolAttributes?: Record, + toolInput?: string, +): Span { + // Start Perfetto span regardless of OTel tracing state + const perfettoSpanId = isPerfettoTracingEnabled() + ? startToolPerfettoSpan(toolName, toolAttributes) + : undefined + + if (!isAnyTracingEnabled()) { + // Still track Perfetto span even if OTel is disabled + if (perfettoSpanId) { + const dummySpan = trace.getActiveSpan() || getTracer().startSpan('dummy') + const spanId = getSpanId(dummySpan) + const spanContextObj: SpanContext = { + span: dummySpan, + startTime: Date.now(), + attributes: { 'span.type': 'tool', tool_name: toolName }, + perfettoSpanId, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + toolContext.enterWith(spanContextObj) + return dummySpan + } + return trace.getActiveSpan() || getTracer().startSpan('dummy') + } + + const tracer = getTracer() + const parentSpanCtx = interactionContext.getStore() + + const attributes = createSpanAttributes('tool', { + tool_name: toolName, + ...toolAttributes, + }) + + const ctx = parentSpanCtx + ? trace.setSpan(otelContext.active(), parentSpanCtx.span) + : otelContext.active() + const span = tracer.startSpan('claude_code.tool', { attributes }, ctx) + + // Add experimental tool input attributes + if (toolInput) { + addBetaToolInputAttributes(span, toolName, toolInput) + } + + const spanId = getSpanId(span) + const spanContextObj: SpanContext = { + span, + startTime: Date.now(), + attributes, + perfettoSpanId, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + + toolContext.enterWith(spanContextObj) + + return span +} + +export function startToolBlockedOnUserSpan(): Span { + // Start Perfetto span regardless of OTel tracing state + const perfettoSpanId = isPerfettoTracingEnabled() + ? startUserInputPerfettoSpan('tool_permission') + : undefined + + if (!isAnyTracingEnabled()) { + // Still track Perfetto span even if OTel is disabled + if (perfettoSpanId) { + const dummySpan = trace.getActiveSpan() || getTracer().startSpan('dummy') + const spanId = getSpanId(dummySpan) + const spanContextObj: SpanContext = { + span: dummySpan, + startTime: Date.now(), + attributes: { 'span.type': 'tool.blocked_on_user' }, + perfettoSpanId, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + strongSpans.set(spanId, spanContextObj) + return dummySpan + } + return trace.getActiveSpan() || getTracer().startSpan('dummy') + } + + const tracer = getTracer() + const parentSpanCtx = toolContext.getStore() + + const attributes = createSpanAttributes('tool.blocked_on_user') + + const ctx = parentSpanCtx + ? trace.setSpan(otelContext.active(), parentSpanCtx.span) + : otelContext.active() + const span = tracer.startSpan( + 'claude_code.tool.blocked_on_user', + { attributes }, + ctx, + ) + + const spanId = getSpanId(span) + const spanContextObj: SpanContext = { + span, + startTime: Date.now(), + attributes, + perfettoSpanId, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + strongSpans.set(spanId, spanContextObj) + + return span +} + +export function endToolBlockedOnUserSpan( + decision?: string, + source?: string, +): void { + const blockedSpanContext = Array.from(activeSpans.values()) + .findLast( + r => r.deref()?.attributes['span.type'] === 'tool.blocked_on_user', + ) + ?.deref() + + if (!blockedSpanContext) { + return + } + + // End Perfetto span + if (blockedSpanContext.perfettoSpanId) { + endUserInputPerfettoSpan(blockedSpanContext.perfettoSpanId, { + decision, + source, + }) + } + + if (!isAnyTracingEnabled()) { + const spanId = getSpanId(blockedSpanContext.span) + activeSpans.delete(spanId) + strongSpans.delete(spanId) + return + } + + const duration = Date.now() - blockedSpanContext.startTime + const attributes: Record = { + duration_ms: duration, + } + + if (decision) { + attributes['decision'] = decision + } + if (source) { + attributes['source'] = source + } + + blockedSpanContext.span.setAttributes(attributes) + blockedSpanContext.span.end() + + const spanId = getSpanId(blockedSpanContext.span) + activeSpans.delete(spanId) + strongSpans.delete(spanId) +} + +export function startToolExecutionSpan(): Span { + if (!isAnyTracingEnabled()) { + return trace.getActiveSpan() || getTracer().startSpan('dummy') + } + + const tracer = getTracer() + const parentSpanCtx = toolContext.getStore() + + const attributes = createSpanAttributes('tool.execution') + + const ctx = parentSpanCtx + ? trace.setSpan(otelContext.active(), parentSpanCtx.span) + : otelContext.active() + const span = tracer.startSpan( + 'claude_code.tool.execution', + { attributes }, + ctx, + ) + + const spanId = getSpanId(span) + const spanContextObj: SpanContext = { + span, + startTime: Date.now(), + attributes, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + strongSpans.set(spanId, spanContextObj) + + return span +} + +export function endToolExecutionSpan(metadata?: { + success?: boolean + error?: string +}): void { + if (!isAnyTracingEnabled()) { + return + } + + const executionSpanContext = Array.from(activeSpans.values()) + .findLast(r => r.deref()?.attributes['span.type'] === 'tool.execution') + ?.deref() + + if (!executionSpanContext) { + return + } + + const duration = Date.now() - executionSpanContext.startTime + const attributes: Record = { + duration_ms: duration, + } + + if (metadata) { + if (metadata.success !== undefined) attributes['success'] = metadata.success + if (metadata.error !== undefined) attributes['error'] = metadata.error + } + + executionSpanContext.span.setAttributes(attributes) + executionSpanContext.span.end() + + const spanId = getSpanId(executionSpanContext.span) + activeSpans.delete(spanId) + strongSpans.delete(spanId) +} + +export function endToolSpan(toolResult?: string, resultTokens?: number): void { + const toolSpanContext = toolContext.getStore() + + if (!toolSpanContext) { + return + } + + // End Perfetto span + if (toolSpanContext.perfettoSpanId) { + endToolPerfettoSpan(toolSpanContext.perfettoSpanId, { + success: true, + resultTokens, + }) + } + + if (!isAnyTracingEnabled()) { + const spanId = getSpanId(toolSpanContext.span) + activeSpans.delete(spanId) + // Same reasoning as interactionContext above: clear so subsequent async + // work doesn't hold a stale reference to the ended tool span. + toolContext.enterWith(undefined) + return + } + + const duration = Date.now() - toolSpanContext.startTime + const endAttributes: Record = { + duration_ms: duration, + } + + // Add experimental tool result attributes (new_context) + if (toolResult) { + const toolName = toolSpanContext.attributes['tool_name'] || 'unknown' + addBetaToolResultAttributes(endAttributes, toolName, toolResult) + } + + if (resultTokens !== undefined) { + endAttributes['result_tokens'] = resultTokens + } + + toolSpanContext.span.setAttributes(endAttributes) + toolSpanContext.span.end() + + const spanId = getSpanId(toolSpanContext.span) + activeSpans.delete(spanId) + toolContext.enterWith(undefined) +} + +function isToolContentLoggingEnabled(): boolean { + return isEnvTruthy(process.env.OTEL_LOG_TOOL_CONTENT) +} + +/** + * Add a span event with tool content/output data. + * Only logs if OTEL_LOG_TOOL_CONTENT=1 is set. + * Truncates content if it exceeds MAX_CONTENT_SIZE. + */ +export function addToolContentEvent( + eventName: string, + attributes: Record, +): void { + if (!isAnyTracingEnabled() || !isToolContentLoggingEnabled()) { + return + } + + const currentSpanCtx = toolContext.getStore() + if (!currentSpanCtx) { + return + } + + // Truncate string attributes that might be large + const processedAttributes: Record = {} + for (const [key, value] of Object.entries(attributes)) { + if (typeof value === 'string') { + const { content, truncated } = truncateContent(value) + processedAttributes[key] = content + if (truncated) { + processedAttributes[`${key}_truncated`] = true + processedAttributes[`${key}_original_length`] = value.length + } + } else { + processedAttributes[key] = value + } + } + + currentSpanCtx.span.addEvent(eventName, processedAttributes) +} + +export function getCurrentSpan(): Span | null { + if (!isAnyTracingEnabled()) { + return null + } + + return ( + toolContext.getStore()?.span ?? interactionContext.getStore()?.span ?? null + ) +} + +export async function executeInSpan( + spanName: string, + fn: (span: Span) => Promise, + attributes?: Record, +): Promise { + if (!isAnyTracingEnabled()) { + return fn(trace.getActiveSpan() || getTracer().startSpan('dummy')) + } + + const tracer = getTracer() + const parentSpanCtx = toolContext.getStore() ?? interactionContext.getStore() + + const finalAttributes = createSpanAttributes('tool', { + ...attributes, + }) + + const ctx = parentSpanCtx + ? trace.setSpan(otelContext.active(), parentSpanCtx.span) + : otelContext.active() + const span = tracer.startSpan(spanName, { attributes: finalAttributes }, ctx) + + const spanId = getSpanId(span) + const spanContextObj: SpanContext = { + span, + startTime: Date.now(), + attributes: finalAttributes, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + strongSpans.set(spanId, spanContextObj) + + try { + const result = await fn(span) + span.end() + activeSpans.delete(spanId) + strongSpans.delete(spanId) + return result + } catch (error) { + if (error instanceof Error) { + span.recordException(error) + } + span.end() + activeSpans.delete(spanId) + strongSpans.delete(spanId) + throw error + } +} + +/** + * Start a hook execution span. + * Only creates a span when beta tracing is enabled. + * @param hookEvent The hook event type (e.g., 'PreToolUse', 'PostToolUse') + * @param hookName The full hook name (e.g., 'PreToolUse:Write') + * @param numHooks The number of hooks being executed + * @param hookDefinitions JSON string of hook definitions for tracing + * @returns The span (or a dummy span if tracing is disabled) + */ +export function startHookSpan( + hookEvent: string, + hookName: string, + numHooks: number, + hookDefinitions: string, +): Span { + if (!isBetaTracingEnabled()) { + return trace.getActiveSpan() || getTracer().startSpan('dummy') + } + + const tracer = getTracer() + const parentSpanCtx = toolContext.getStore() ?? interactionContext.getStore() + + const attributes = createSpanAttributes('hook', { + hook_event: hookEvent, + hook_name: hookName, + num_hooks: numHooks, + hook_definitions: hookDefinitions, + }) + + const ctx = parentSpanCtx + ? trace.setSpan(otelContext.active(), parentSpanCtx.span) + : otelContext.active() + const span = tracer.startSpan('claude_code.hook', { attributes }, ctx) + + const spanId = getSpanId(span) + const spanContextObj: SpanContext = { + span, + startTime: Date.now(), + attributes, + } + activeSpans.set(spanId, new WeakRef(spanContextObj)) + strongSpans.set(spanId, spanContextObj) + + return span +} + +/** + * End a hook execution span with outcome metadata. + * Only does work when beta tracing is enabled. + * @param span The span to end (returned from startHookSpan) + * @param metadata The outcome metadata for the hook execution + */ +export function endHookSpan( + span: Span, + metadata?: { + numSuccess?: number + numBlocking?: number + numNonBlockingError?: number + numCancelled?: number + }, +): void { + if (!isBetaTracingEnabled()) { + return + } + + const spanId = getSpanId(span) + const spanContext = activeSpans.get(spanId)?.deref() + + if (!spanContext) { + return + } + + const duration = Date.now() - spanContext.startTime + const endAttributes: Record = { + duration_ms: duration, + } + + if (metadata) { + if (metadata.numSuccess !== undefined) + endAttributes['num_success'] = metadata.numSuccess + if (metadata.numBlocking !== undefined) + endAttributes['num_blocking'] = metadata.numBlocking + if (metadata.numNonBlockingError !== undefined) + endAttributes['num_non_blocking_error'] = metadata.numNonBlockingError + if (metadata.numCancelled !== undefined) + endAttributes['num_cancelled'] = metadata.numCancelled + } + + spanContext.span.setAttributes(endAttributes) + spanContext.span.end() + activeSpans.delete(spanId) + strongSpans.delete(spanId) +} diff --git a/src/utils/telemetry/skillLoadedEvent.ts b/src/utils/telemetry/skillLoadedEvent.ts new file mode 100644 index 0000000000000000000000000000000000000000..a84a58bb6a5ad9dd5756998f1c5a9b40da9b8812 --- /dev/null +++ b/src/utils/telemetry/skillLoadedEvent.ts @@ -0,0 +1,39 @@ +import { getSkillToolCommands } from '../../commands.js' +import { + type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + type AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, + logEvent, +} from '../../services/analytics/index.js' +import { getCharBudget } from '../../tools/SkillTool/prompt.js' + +/** + * Logs a tengu_skill_loaded event for each skill available at session startup. + * This enables analytics on which skills are available across sessions. + */ +export async function logSkillsLoaded( + cwd: string, + contextWindowTokens: number, +): Promise { + const skills = await getSkillToolCommands(cwd) + const skillBudget = getCharBudget(contextWindowTokens) + + for (const skill of skills) { + if (skill.type !== 'prompt') continue + + logEvent('tengu_skill_loaded', { + // _PROTO_skill_name routes to the privileged skill_name BQ column. + // Unredacted names don't go in additional_metadata. + _PROTO_skill_name: + skill.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, + skill_source: + skill.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + skill_loaded_from: + skill.loadedFrom as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + skill_budget: skillBudget, + ...(skill.kind && { + skill_kind: + skill.kind as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + }), + }) + } +} diff --git a/src/utils/teleport/api.ts b/src/utils/teleport/api.ts new file mode 100644 index 0000000000000000000000000000000000000000..c3a666e218de1aac876ba5441047eacfc72c0b71 --- /dev/null +++ b/src/utils/teleport/api.ts @@ -0,0 +1,466 @@ +import axios, { type AxiosRequestConfig, type AxiosResponse } from 'axios' +import { randomUUID } from 'crypto' +import { getOauthConfig } from 'src/constants/oauth.js' +import { getOrganizationUUID } from 'src/services/oauth/client.js' +import z from 'zod/v4' +import { getClaudeAIOAuthTokens } from '../auth.js' +import { logForDebugging } from '../debug.js' +import { parseGitHubRepository } from '../detectRepository.js' +import { errorMessage, toError } from '../errors.js' +import { lazySchema } from '../lazySchema.js' +import { logError } from '../log.js' +import { sleep } from '../sleep.js' +import { jsonStringify } from '../slowOperations.js' + +// Retry configuration for teleport API requests +const TELEPORT_RETRY_DELAYS = [2000, 4000, 8000, 16000] // 4 retries with exponential backoff +const MAX_TELEPORT_RETRIES = TELEPORT_RETRY_DELAYS.length + +export const CCR_BYOC_BETA = 'ccr-byoc-2025-07-29' + +/** + * Checks if an axios error is a transient network error that should be retried + */ +export function isTransientNetworkError(error: unknown): boolean { + if (!axios.isAxiosError(error)) { + return false + } + + // Retry on network errors (no response received) + if (!error.response) { + return true + } + + // Retry on server errors (5xx) + if (error.response.status >= 500) { + return true + } + + // Don't retry on client errors (4xx) - they're not transient + return false +} + +/** + * Makes an axios GET request with automatic retry for transient network errors + * Uses exponential backoff: 2s, 4s, 8s, 16s (4 retries = 5 total attempts) + */ +export async function axiosGetWithRetry( + url: string, + config?: AxiosRequestConfig, +): Promise> { + let lastError: unknown + + for (let attempt = 0; attempt <= MAX_TELEPORT_RETRIES; attempt++) { + try { + return await axios.get(url, config) + } catch (error) { + lastError = error + + // Don't retry if this isn't a transient error + if (!isTransientNetworkError(error)) { + throw error + } + + // Don't retry if we've exhausted all retries + if (attempt >= MAX_TELEPORT_RETRIES) { + logForDebugging( + `Teleport request failed after ${attempt + 1} attempts: ${errorMessage(error)}`, + ) + throw error + } + + const delay = TELEPORT_RETRY_DELAYS[attempt] ?? 2000 + logForDebugging( + `Teleport request failed (attempt ${attempt + 1}/${MAX_TELEPORT_RETRIES + 1}), retrying in ${delay}ms: ${errorMessage(error)}`, + ) + await sleep(delay) + } + } + + throw lastError +} + +// Types matching the actual Sessions API response from api/schemas/sessions/sessions.py +export type SessionStatus = 'requires_action' | 'running' | 'idle' | 'archived' + +export type GitSource = { + type: 'git_repository' + url: string + revision?: string | null + allow_unrestricted_git_push?: boolean +} + +export type KnowledgeBaseSource = { + type: 'knowledge_base' + knowledge_base_id: string +} + +export type SessionContextSource = GitSource | KnowledgeBaseSource + +// Outcome types from api/schemas/sandbox.py +export type OutcomeGitInfo = { + type: 'github' + repo: string + branches: string[] +} + +export type GitRepositoryOutcome = { + type: 'git_repository' + git_info: OutcomeGitInfo +} + +export type Outcome = GitRepositoryOutcome + +export type SessionContext = { + sources: SessionContextSource[] + cwd: string + outcomes: Outcome[] | null + custom_system_prompt: string | null + append_system_prompt: string | null + model: string | null + // Seed filesystem with a git bundle on Files API + seed_bundle_file_id?: string + github_pr?: { owner: string; repo: string; number: number } + reuse_outcome_branches?: boolean +} + +export type SessionResource = { + type: 'session' + id: string + title: string | null + session_status: SessionStatus + environment_id: string + created_at: string + updated_at: string + session_context: SessionContext +} + +export type ListSessionsResponse = { + data: SessionResource[] + has_more: boolean + first_id: string | null + last_id: string | null +} + +export const CodeSessionSchema = lazySchema(() => + z.object({ + id: z.string(), + title: z.string(), + description: z.string(), + status: z.enum([ + 'idle', + 'working', + 'waiting', + 'completed', + 'archived', + 'cancelled', + 'rejected', + ]), + repo: z + .object({ + name: z.string(), + owner: z.object({ + login: z.string(), + }), + default_branch: z.string().optional(), + }) + .nullable(), + turns: z.array(z.string()), + created_at: z.string(), + updated_at: z.string(), + }), +) + +// Export the inferred type from the Zod schema +export type CodeSession = z.infer> + +/** + * Validates and prepares for API requests + * @returns Object containing access token and organization UUID + */ +export async function prepareApiRequest(): Promise<{ + accessToken: string + orgUUID: string +}> { + const accessToken = getClaudeAIOAuthTokens()?.accessToken + if (accessToken === undefined) { + throw new Error( + 'Claude Code web sessions require authentication with a Claude.ai account. API key authentication is not sufficient. Please run /login to authenticate, or check your authentication status with /status.', + ) + } + + const orgUUID = await getOrganizationUUID() + if (!orgUUID) { + throw new Error('Unable to get organization UUID') + } + + return { accessToken, orgUUID } +} + +/** + * Fetches code sessions from the new Sessions API (/v1/sessions) + * @returns Array of code sessions + */ +export async function fetchCodeSessionsFromSessionsAPI(): Promise< + CodeSession[] +> { + const { accessToken, orgUUID } = await prepareApiRequest() + + const url = `${getOauthConfig().BASE_API_URL}/v1/sessions` + + try { + const headers = { + ...getOAuthHeaders(accessToken), + 'anthropic-beta': 'ccr-byoc-2025-07-29', + 'x-organization-uuid': orgUUID, + } + + const response = await axiosGetWithRetry(url, { + headers, + }) + + if (response.status !== 200) { + throw new Error(`Failed to fetch code sessions: ${response.statusText}`) + } + + // Transform SessionResource[] to CodeSession[] format + const sessions: CodeSession[] = response.data.data.map(session => { + // Extract repository info from git sources + const gitSource = session.session_context.sources.find( + (source): source is GitSource => source.type === 'git_repository', + ) + + let repo: CodeSession['repo'] = null + if (gitSource?.url) { + // Parse GitHub URL using the existing utility function + const repoPath = parseGitHubRepository(gitSource.url) + if (repoPath) { + const [owner, name] = repoPath.split('/') + if (owner && name) { + repo = { + name, + owner: { + login: owner, + }, + default_branch: gitSource.revision || undefined, + } + } + } + } + + return { + id: session.id, + title: session.title || 'Untitled', + description: '', // SessionResource doesn't have description field + status: session.session_status as CodeSession['status'], // Map session_status to status + repo, + turns: [], // SessionResource doesn't have turns field + created_at: session.created_at, + updated_at: session.updated_at, + } + }) + + return sessions + } catch (error) { + const err = toError(error) + logError(err) + throw error + } +} + +/** + * Creates OAuth headers for API requests + * @param accessToken The OAuth access token + * @returns Headers object with Authorization, Content-Type, and anthropic-version + */ +export function getOAuthHeaders(accessToken: string): Record { + return { + Authorization: `Bearer ${accessToken}`, + 'Content-Type': 'application/json', + 'anthropic-version': '2023-06-01', + } +} + +/** + * Fetches a single session by ID from the Sessions API + * @param sessionId The session ID to fetch + * @returns The session resource + */ +export async function fetchSession( + sessionId: string, +): Promise { + const { accessToken, orgUUID } = await prepareApiRequest() + + const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}` + const headers = { + ...getOAuthHeaders(accessToken), + 'anthropic-beta': 'ccr-byoc-2025-07-29', + 'x-organization-uuid': orgUUID, + } + + const response = await axios.get(url, { + headers, + timeout: 15000, + validateStatus: status => status < 500, + }) + + if (response.status !== 200) { + // Extract error message from response if available + const errorData = response.data as { error?: { message?: string } } + const apiMessage = errorData?.error?.message + + if (response.status === 404) { + throw new Error(`Session not found: ${sessionId}`) + } + + if (response.status === 401) { + throw new Error('Session expired. Please run /login to sign in again.') + } + + throw new Error( + apiMessage || + `Failed to fetch session: ${response.status} ${response.statusText}`, + ) + } + + return response.data +} + +/** + * Extracts the first branch name from a session's git repository outcomes + * @param session The session resource to extract from + * @returns The first branch name, or undefined if none found + */ +export function getBranchFromSession( + session: SessionResource, +): string | undefined { + const gitOutcome = session.session_context.outcomes?.find( + (outcome): outcome is GitRepositoryOutcome => + outcome.type === 'git_repository', + ) + return gitOutcome?.git_info?.branches[0] +} + +/** + * Content for a remote session message. + * Accepts a plain string or an array of content blocks (text, image, etc.) + * following the Anthropic API messages spec. + */ +export type RemoteMessageContent = + | string + | Array<{ type: string; [key: string]: unknown }> + +/** + * Sends a user message event to an existing remote session via the Sessions API + * @param sessionId The session ID to send the event to + * @param messageContent The user message content (string or content blocks) + * @param opts.uuid Optional UUID for the event — callers that added a local + * UserMessage first should pass its UUID so echo filtering can dedup + * @returns Promise True if successful, false otherwise + */ +export async function sendEventToRemoteSession( + sessionId: string, + messageContent: RemoteMessageContent, + opts?: { uuid?: string }, +): Promise { + try { + const { accessToken, orgUUID } = await prepareApiRequest() + + const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/events` + const headers = { + ...getOAuthHeaders(accessToken), + 'anthropic-beta': 'ccr-byoc-2025-07-29', + 'x-organization-uuid': orgUUID, + } + + const userEvent = { + uuid: opts?.uuid ?? randomUUID(), + session_id: sessionId, + type: 'user', + parent_tool_use_id: null, + message: { + role: 'user', + content: messageContent, + }, + } + + const requestBody = { + events: [userEvent], + } + + logForDebugging( + `[sendEventToRemoteSession] Sending event to session ${sessionId}`, + ) + // The endpoint may block until the CCR worker is ready. Observed ~2.6s + // in normal cases; allow a generous margin for cold-start containers. + const response = await axios.post(url, requestBody, { + headers, + validateStatus: status => status < 500, + timeout: 30000, + }) + + if (response.status === 200 || response.status === 201) { + logForDebugging( + `[sendEventToRemoteSession] Successfully sent event to session ${sessionId}`, + ) + return true + } + + logForDebugging( + `[sendEventToRemoteSession] Failed with status ${response.status}: ${jsonStringify(response.data)}`, + ) + return false + } catch (error) { + logForDebugging(`[sendEventToRemoteSession] Error: ${errorMessage(error)}`) + return false + } +} + +/** + * Updates the title of an existing remote session via the Sessions API + * @param sessionId The session ID to update + * @param title The new title for the session + * @returns Promise True if successful, false otherwise + */ +export async function updateSessionTitle( + sessionId: string, + title: string, +): Promise { + try { + const { accessToken, orgUUID } = await prepareApiRequest() + + const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}` + const headers = { + ...getOAuthHeaders(accessToken), + 'anthropic-beta': 'ccr-byoc-2025-07-29', + 'x-organization-uuid': orgUUID, + } + + logForDebugging( + `[updateSessionTitle] Updating title for session ${sessionId}: "${title}"`, + ) + const response = await axios.patch( + url, + { title }, + { + headers, + validateStatus: status => status < 500, + }, + ) + + if (response.status === 200) { + logForDebugging( + `[updateSessionTitle] Successfully updated title for session ${sessionId}`, + ) + return true + } + + logForDebugging( + `[updateSessionTitle] Failed with status ${response.status}: ${jsonStringify(response.data)}`, + ) + return false + } catch (error) { + logForDebugging(`[updateSessionTitle] Error: ${errorMessage(error)}`) + return false + } +} diff --git a/src/utils/teleport/environmentSelection.ts b/src/utils/teleport/environmentSelection.ts new file mode 100644 index 0000000000000000000000000000000000000000..8b1f0dff49fae297ff886dee498a1d484666628f --- /dev/null +++ b/src/utils/teleport/environmentSelection.ts @@ -0,0 +1,77 @@ +import { SETTING_SOURCES, type SettingSource } from '../settings/constants.js' +import { + getSettings_DEPRECATED, + getSettingsForSource, +} from '../settings/settings.js' +import { type EnvironmentResource, fetchEnvironments } from './environments.js' + +export type EnvironmentSelectionInfo = { + availableEnvironments: EnvironmentResource[] + selectedEnvironment: EnvironmentResource | null + selectedEnvironmentSource: SettingSource | null +} + +/** + * Gets information about available environments and the currently selected one. + * + * @returns Promise containing: + * - availableEnvironments: all environments from the API + * - selectedEnvironment: the environment that would be used (based on settings or first available), + * or null if no environments are available + * - selectedEnvironmentSource: the SettingSource where defaultEnvironmentId is configured, + * or null if using the default (first environment) + */ +export async function getEnvironmentSelectionInfo(): Promise { + // Fetch available environments + const environments = await fetchEnvironments() + + if (environments.length === 0) { + return { + availableEnvironments: [], + selectedEnvironment: null, + selectedEnvironmentSource: null, + } + } + + // Get the merged settings to see what would actually be used + const mergedSettings = getSettings_DEPRECATED() + const defaultEnvironmentId = mergedSettings?.remote?.defaultEnvironmentId + + // Find which environment would be selected + let selectedEnvironment: EnvironmentResource = + environments.find(env => env.kind !== 'bridge') ?? environments[0]! + let selectedEnvironmentSource: SettingSource | null = null + + if (defaultEnvironmentId) { + const matchingEnvironment = environments.find( + env => env.environment_id === defaultEnvironmentId, + ) + + if (matchingEnvironment) { + selectedEnvironment = matchingEnvironment + + // Find which source has this setting + // Iterate from lowest to highest priority, so the last match wins (highest priority) + for (let i = SETTING_SOURCES.length - 1; i >= 0; i--) { + const source = SETTING_SOURCES[i] + if (!source || source === 'flagSettings') { + // Skip flagSettings as it's not a normal source we check + continue + } + const sourceSettings = getSettingsForSource(source) + if ( + sourceSettings?.remote?.defaultEnvironmentId === defaultEnvironmentId + ) { + selectedEnvironmentSource = source + break + } + } + } + } + + return { + availableEnvironments: environments, + selectedEnvironment, + selectedEnvironmentSource, + } +} diff --git a/src/utils/teleport/environments.ts b/src/utils/teleport/environments.ts new file mode 100644 index 0000000000000000000000000000000000000000..19242406fb59cd1e2c9975b512a499410dd7bcae --- /dev/null +++ b/src/utils/teleport/environments.ts @@ -0,0 +1,120 @@ +import axios from 'axios' +import { getOauthConfig } from 'src/constants/oauth.js' +import { getOrganizationUUID } from 'src/services/oauth/client.js' +import { getClaudeAIOAuthTokens } from '../auth.js' +import { toError } from '../errors.js' +import { logError } from '../log.js' +import { getOAuthHeaders } from './api.js' + +export type EnvironmentKind = 'anthropic_cloud' | 'byoc' | 'bridge' +export type EnvironmentState = 'active' + +export type EnvironmentResource = { + kind: EnvironmentKind + environment_id: string + name: string + created_at: string + state: EnvironmentState +} + +export type EnvironmentListResponse = { + environments: EnvironmentResource[] + has_more: boolean + first_id: string | null + last_id: string | null +} + +/** + * Fetches the list of available environments from the Environment API + * @returns Promise Array of available environments + * @throws Error if the API request fails or no access token is available + */ +export async function fetchEnvironments(): Promise { + const accessToken = getClaudeAIOAuthTokens()?.accessToken + if (!accessToken) { + throw new Error( + 'Claude Code web sessions require authentication with a Claude.ai account. API key authentication is not sufficient. Please run /login to authenticate, or check your authentication status with /status.', + ) + } + + const orgUUID = await getOrganizationUUID() + if (!orgUUID) { + throw new Error('Unable to get organization UUID') + } + + const url = `${getOauthConfig().BASE_API_URL}/v1/environment_providers` + + try { + const headers = { + ...getOAuthHeaders(accessToken), + 'x-organization-uuid': orgUUID, + } + + const response = await axios.get(url, { + headers, + timeout: 15000, + }) + + if (response.status !== 200) { + throw new Error( + `Failed to fetch environments: ${response.status} ${response.statusText}`, + ) + } + + return response.data.environments + } catch (error) { + const err = toError(error) + logError(err) + throw new Error(`Failed to fetch environments: ${err.message}`) + } +} + +/** + * Creates a default anthropic_cloud environment for users who have none. + * Uses the public environment_providers route (same auth as fetchEnvironments). + */ +export async function createDefaultCloudEnvironment( + name: string, +): Promise { + const accessToken = getClaudeAIOAuthTokens()?.accessToken + if (!accessToken) { + throw new Error('No access token available') + } + const orgUUID = await getOrganizationUUID() + if (!orgUUID) { + throw new Error('Unable to get organization UUID') + } + + const url = `${getOauthConfig().BASE_API_URL}/v1/environment_providers/cloud/create` + const response = await axios.post( + url, + { + name, + kind: 'anthropic_cloud', + description: '', + config: { + environment_type: 'anthropic', + cwd: '/home/user', + init_script: null, + environment: {}, + languages: [ + { name: 'python', version: '3.11' }, + { name: 'node', version: '20' }, + ], + network_config: { + allowed_hosts: [], + allow_default_hosts: true, + }, + }, + }, + { + headers: { + ...getOAuthHeaders(accessToken), + 'anthropic-beta': 'ccr-byoc-2025-07-29', + 'x-organization-uuid': orgUUID, + }, + timeout: 15000, + }, + ) + return response.data +} diff --git a/src/utils/teleport/gitBundle.ts b/src/utils/teleport/gitBundle.ts new file mode 100644 index 0000000000000000000000000000000000000000..0e53c5dc4cdf4ddd1d10e54ca6b18d1e8baa264c --- /dev/null +++ b/src/utils/teleport/gitBundle.ts @@ -0,0 +1,292 @@ +/** + * Git bundle creation + upload for CCR seed-bundle seeding. + * + * Flow: + * 1. git stash create → update-ref refs/seed/stash (makes it reachable) + * 2. git bundle create --all (packs refs/seed/stash + its objects) + * 3. Upload to /v1/files + * 4. Cleanup refs/seed/stash (don't pollute user's repo) + * 5. Caller sets seed_bundle_file_id on SessionContext + */ + +import { stat, unlink } from 'fs/promises' +import { + type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + logEvent, +} from 'src/services/analytics/index.js' +import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js' +import { type FilesApiConfig, uploadFile } from '../../services/api/filesApi.js' +import { getCwd } from '../cwd.js' +import { logForDebugging } from '../debug.js' +import { execFileNoThrowWithCwd } from '../execFileNoThrow.js' +import { findGitRoot, gitExe } from '../git.js' +import { generateTempFilePath } from '../tempfile.js' + +// Tunable via tengu_ccr_bundle_max_bytes. +const DEFAULT_BUNDLE_MAX_BYTES = 100 * 1024 * 1024 + +type BundleScope = 'all' | 'head' | 'squashed' + +export type BundleUploadResult = + | { + success: true + fileId: string + bundleSizeBytes: number + scope: BundleScope + hasWip: boolean + } + | { success: false; error: string; failReason?: BundleFailReason } + +type BundleFailReason = 'git_error' | 'too_large' | 'empty_repo' + +type BundleCreateResult = + | { ok: true; size: number; scope: BundleScope } + | { ok: false; error: string; failReason: BundleFailReason } + +// Bundle --all → HEAD → squashed-root. HEAD drops side branches/tags but +// keeps full current-branch history. Squashed-root is a single parentless +// commit of HEAD's tree (or the stash tree if WIP exists) — no history, +// just the snapshot. Receiver needs refs/seed/root handling for that tier. +async function _bundleWithFallback( + gitRoot: string, + bundlePath: string, + maxBytes: number, + hasStash: boolean, + signal: AbortSignal | undefined, +): Promise { + // --all picks up refs/seed/stash; HEAD needs it explicit. + const extra = hasStash ? ['refs/seed/stash'] : [] + const mkBundle = (base: string) => + execFileNoThrowWithCwd( + gitExe(), + ['bundle', 'create', bundlePath, base, ...extra], + { cwd: gitRoot, abortSignal: signal }, + ) + + const allResult = await mkBundle('--all') + if (allResult.code !== 0) { + return { + ok: false, + error: `git bundle create --all failed (${allResult.code}): ${allResult.stderr.slice(0, 200)}`, + failReason: 'git_error', + } + } + + const { size: allSize } = await stat(bundlePath) + if (allSize <= maxBytes) { + return { ok: true, size: allSize, scope: 'all' } + } + + // bundle create overwrites in place. + logForDebugging( + `[gitBundle] --all bundle is ${(allSize / 1024 / 1024).toFixed(1)}MB (> ${(maxBytes / 1024 / 1024).toFixed(0)}MB), retrying HEAD-only`, + ) + const headResult = await mkBundle('HEAD') + if (headResult.code !== 0) { + return { + ok: false, + error: `git bundle create HEAD failed (${headResult.code}): ${headResult.stderr.slice(0, 200)}`, + failReason: 'git_error', + } + } + + const { size: headSize } = await stat(bundlePath) + if (headSize <= maxBytes) { + return { ok: true, size: headSize, scope: 'head' } + } + + // Last resort: squash to a single parentless commit. Uses the stash tree + // when WIP exists (bakes uncommitted changes in — can't bundle the stash + // ref separately since its parents would drag history back). + logForDebugging( + `[gitBundle] HEAD bundle is ${(headSize / 1024 / 1024).toFixed(1)}MB, retrying squashed-root`, + ) + const treeRef = hasStash ? 'refs/seed/stash^{tree}' : 'HEAD^{tree}' + const commitTree = await execFileNoThrowWithCwd( + gitExe(), + ['commit-tree', treeRef, '-m', 'seed'], + { cwd: gitRoot, abortSignal: signal }, + ) + if (commitTree.code !== 0) { + return { + ok: false, + error: `git commit-tree failed (${commitTree.code}): ${commitTree.stderr.slice(0, 200)}`, + failReason: 'git_error', + } + } + const squashedSha = commitTree.stdout.trim() + await execFileNoThrowWithCwd( + gitExe(), + ['update-ref', 'refs/seed/root', squashedSha], + { cwd: gitRoot }, + ) + const squashResult = await execFileNoThrowWithCwd( + gitExe(), + ['bundle', 'create', bundlePath, 'refs/seed/root'], + { cwd: gitRoot, abortSignal: signal }, + ) + if (squashResult.code !== 0) { + return { + ok: false, + error: `git bundle create refs/seed/root failed (${squashResult.code}): ${squashResult.stderr.slice(0, 200)}`, + failReason: 'git_error', + } + } + const { size: squashSize } = await stat(bundlePath) + if (squashSize <= maxBytes) { + return { ok: true, size: squashSize, scope: 'squashed' } + } + + return { + ok: false, + error: + 'Repo is too large to bundle. Please setup GitHub on https://claude.ai/code', + failReason: 'too_large', + } +} + +// Bundle the repo and upload to Files API; return file_id for +// seed_bundle_file_id. --all → HEAD → squashed-root fallback chain. +// Tracked WIP via stash create → refs/seed/stash (or baked into the +// squashed tree); untracked not captured. +export async function createAndUploadGitBundle( + config: FilesApiConfig, + opts?: { cwd?: string; signal?: AbortSignal }, +): Promise { + const workdir = opts?.cwd ?? getCwd() + const gitRoot = findGitRoot(workdir) + if (!gitRoot) { + return { success: false, error: 'Not in a git repository' } + } + + // Sweep stale refs from a crashed prior run before --all bundles them. + // Runs before the empty-repo check so it's never skipped by an early return. + for (const ref of ['refs/seed/stash', 'refs/seed/root']) { + await execFileNoThrowWithCwd(gitExe(), ['update-ref', '-d', ref], { + cwd: gitRoot, + }) + } + + // `git bundle create` refuses to create an empty bundle (exit 128), and + // `stash create` fails with "You do not have the initial commit yet". + // Check for any refs (not just HEAD) so orphan branches with commits + // elsewhere still bundle — `--all` packs those refs regardless of HEAD. + const refCheck = await execFileNoThrowWithCwd( + gitExe(), + ['for-each-ref', '--count=1', 'refs/'], + { cwd: gitRoot }, + ) + if (refCheck.code === 0 && refCheck.stdout.trim() === '') { + logEvent('tengu_ccr_bundle_upload', { + outcome: + 'empty_repo' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + }) + return { + success: false, + error: 'Repository has no commits yet', + failReason: 'empty_repo', + } + } + + // stash create writes a dangling commit — doesn't touch refs/stash or + // the working tree. Untracked files intentionally excluded. + const stashResult = await execFileNoThrowWithCwd( + gitExe(), + ['stash', 'create'], + { cwd: gitRoot, abortSignal: opts?.signal }, + ) + // exit 0 + empty stdout = nothing to stash. Nonzero is rare; non-fatal. + const wipStashSha = stashResult.code === 0 ? stashResult.stdout.trim() : '' + const hasWip = wipStashSha !== '' + if (stashResult.code !== 0) { + logForDebugging( + `[gitBundle] git stash create failed (${stashResult.code}), proceeding without WIP: ${stashResult.stderr.slice(0, 200)}`, + ) + } else if (hasWip) { + logForDebugging(`[gitBundle] Captured WIP as stash ${wipStashSha}`) + // env-runner reads the SHA via bundle list-heads refs/seed/stash. + await execFileNoThrowWithCwd( + gitExe(), + ['update-ref', 'refs/seed/stash', wipStashSha], + { cwd: gitRoot }, + ) + } + + const bundlePath = generateTempFilePath('ccr-seed', '.bundle') + + // git leaves a partial file on nonzero exit (e.g. empty-repo 128). + try { + const maxBytes = + getFeatureValue_CACHED_MAY_BE_STALE( + 'tengu_ccr_bundle_max_bytes', + null, + ) ?? DEFAULT_BUNDLE_MAX_BYTES + + const bundle = await _bundleWithFallback( + gitRoot, + bundlePath, + maxBytes, + hasWip, + opts?.signal, + ) + + if (!bundle.ok) { + logForDebugging(`[gitBundle] ${bundle.error}`) + logEvent('tengu_ccr_bundle_upload', { + outcome: + bundle.failReason as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + max_bytes: maxBytes, + }) + return { + success: false, + error: bundle.error, + failReason: bundle.failReason, + } + } + + // Fixed relativePath so CCR can locate it. + const upload = await uploadFile(bundlePath, '_source_seed.bundle', config, { + signal: opts?.signal, + }) + + if (!upload.success) { + logEvent('tengu_ccr_bundle_upload', { + outcome: + 'failed' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + }) + return { success: false, error: upload.error } + } + + logForDebugging( + `[gitBundle] Uploaded ${upload.size} bytes as file_id ${upload.fileId}`, + ) + logEvent('tengu_ccr_bundle_upload', { + outcome: + 'success' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + size_bytes: upload.size, + scope: + bundle.scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + has_wip: hasWip, + }) + return { + success: true, + fileId: upload.fileId, + bundleSizeBytes: upload.size, + scope: bundle.scope, + hasWip, + } + } finally { + try { + await unlink(bundlePath) + } catch { + logForDebugging(`[gitBundle] Could not delete ${bundlePath} (non-fatal)`) + } + // Always delete — also sweeps a stale ref from a crashed prior run. + // update-ref -d on a missing ref exits 0. + for (const ref of ['refs/seed/stash', 'refs/seed/root']) { + await execFileNoThrowWithCwd(gitExe(), ['update-ref', '-d', ref], { + cwd: gitRoot, + }) + } + } +} diff --git a/src/utils/tmuxSocket.ts b/src/utils/tmuxSocket.ts new file mode 100644 index 0000000000000000000000000000000000000000..510720a005c1f76bdceae3d4802895f9c363bcc9 --- /dev/null +++ b/src/utils/tmuxSocket.ts @@ -0,0 +1,427 @@ +/** + * TMUX SOCKET ISOLATION + * ===================== + * This module manages an isolated tmux socket for Claude's operations. + * + * WHY THIS EXISTS: + * Without isolation, Claude could accidentally affect the user's tmux sessions. + * For example, running `tmux kill-session` via the Bash tool would kill the + * user's current session if they started Claude from within tmux. + * + * HOW IT WORKS: + * 1. Claude creates its own tmux socket: `claude-` (e.g., `claude-12345`) + * 2. ALL Tmux tool commands use this socket via the `-L` flag + * 3. ALL Bash tool commands inherit TMUX env var pointing to this socket + * (set in Shell.ts via getClaudeTmuxEnv()) + * + * This means ANY tmux command run through Claude - whether via the Tmux tool + * directly or via Bash - will operate on Claude's isolated socket, NOT the + * user's tmux session. + * + * IMPORTANT: The user's original TMUX env var is NOT used. After socket + * initialization, getClaudeTmuxEnv() returns a value that overrides the + * user's TMUX in all child processes spawned by Shell.ts. + */ + +import { posix } from 'path' +import { registerCleanup } from './cleanupRegistry.js' +import { logForDebugging } from './debug.js' +import { toError } from './errors.js' +import { execFileNoThrow } from './execFileNoThrow.js' +import { logError } from './log.js' +import { getPlatform } from './platform.js' + +// Constants for tmux socket management +const TMUX_COMMAND = 'tmux' +const CLAUDE_SOCKET_PREFIX = 'claude' + +/** + * Executes a tmux command, routing through WSL on Windows. + * On Windows, tmux only exists inside WSL — WSL interop lets the tmux session + * launch .exe files as native Win32 processes while stdin/stdout flow through + * the WSL pty. + */ +async function execTmux( + args: string[], + opts?: { useCwd?: boolean }, +): Promise<{ stdout: string; stderr: string; code: number }> { + if (getPlatform() === 'windows') { + // -e execs tmux directly without the login shell. Without it, wsl hands the + // command line to bash which eats `#` as a comment: `display-message -p + // #{socket_path},#{pid}` below becomes `display-message -p ` → exit 1 → + // we silently fall back to the guessed path and never learn the real + // server PID. Same root cause as TungstenTool/utils.ts:execTmuxCommand. + const result = await execFileNoThrow('wsl', ['-e', TMUX_COMMAND, ...args], { + env: { ...process.env, WSL_UTF8: '1' }, + ...opts, + }) + return { + stdout: result.stdout || '', + stderr: result.stderr || '', + code: result.code || 0, + } + } + const result = await execFileNoThrow(TMUX_COMMAND, args, opts) + return { + stdout: result.stdout || '', + stderr: result.stderr || '', + code: result.code || 0, + } +} + +// Socket state - initialized lazily when Tmux tool is first used or a tmux command is run +let socketName: string | null = null +let socketPath: string | null = null +let serverPid: number | null = null +let isInitializing = false +let initPromise: Promise | null = null + +// tmux availability - checked once upfront +let tmuxAvailabilityChecked = false +let tmuxAvailable = false + +// Track whether the Tmux tool has been used at least once +// Used to defer socket initialization until actually needed +let tmuxToolUsed = false + +/** + * Gets the socket name for Claude's isolated tmux session. + * Format: claude- + */ +export function getClaudeSocketName(): string { + if (!socketName) { + socketName = `${CLAUDE_SOCKET_PREFIX}-${process.pid}` + } + return socketName +} + +/** + * Gets the socket path if the socket has been initialized. + * Returns null if not yet initialized. + */ +export function getClaudeSocketPath(): string | null { + return socketPath +} + +/** + * Sets socket info after initialization. + * Called after the tmux session is created. + */ +export function setClaudeSocketInfo(path: string, pid: number): void { + socketPath = path + serverPid = pid +} + +/** + * Returns whether the socket has been initialized. + */ +export function isSocketInitialized(): boolean { + return socketPath !== null && serverPid !== null +} + +/** + * Gets the TMUX environment variable value for Claude's isolated socket. + * + * CRITICAL: This value is used by Shell.ts to override the TMUX env var + * in ALL child processes. This ensures that any `tmux` command run via + * the Bash tool will operate on Claude's socket, NOT the user's session. + * + * Format: "socket_path,server_pid,pane_index" (matches tmux's TMUX env var) + * Example: "/tmp/tmux-501/claude-12345,54321,0" + * + * Returns null if socket is not yet initialized. + * When null, Shell.ts does not override TMUX, preserving user's environment. + */ +export function getClaudeTmuxEnv(): string | null { + if (!socketPath || serverPid === null) { + return null + } + return `${socketPath},${serverPid},0` +} + +/** + * Checks if tmux is available on this system. + * This is checked once and cached for the lifetime of the process. + * + * When tmux is not available: + * - TungstenTool (Tmux) will not work + * - TeammateTool will not work (it uses tmux for pane management) + * - Bash commands will run without tmux isolation + */ +export async function checkTmuxAvailable(): Promise { + if (!tmuxAvailabilityChecked) { + const result = + getPlatform() === 'windows' + ? await execFileNoThrow('wsl', ['-e', TMUX_COMMAND, '-V'], { + env: { ...process.env, WSL_UTF8: '1' }, + useCwd: false, + }) + : await execFileNoThrow('which', [TMUX_COMMAND], { + useCwd: false, + }) + tmuxAvailable = result.code === 0 + if (!tmuxAvailable) { + logForDebugging( + `[Socket] tmux is not installed. The Tmux tool and Teammate tool will not be available.`, + ) + } + tmuxAvailabilityChecked = true + } + return tmuxAvailable +} + +/** + * Returns the cached tmux availability status. + * Returns false if availability hasn't been checked yet. + * Use checkTmuxAvailable() to perform the check. + */ +export function isTmuxAvailable(): boolean { + return tmuxAvailabilityChecked && tmuxAvailable +} + +/** + * Marks that the Tmux tool has been used at least once. + * Called by TungstenTool before initialization. + * After this is called, Shell.ts will initialize the socket for subsequent Bash commands. + */ +export function markTmuxToolUsed(): void { + tmuxToolUsed = true +} + +/** + * Returns whether the Tmux tool has been used at least once. + * Used by Shell.ts to decide whether to initialize the socket. + */ +export function hasTmuxToolBeenUsed(): boolean { + return tmuxToolUsed +} + +/** + * Ensures the socket is initialized with a tmux session. + * Called by Shell.ts when the Tmux tool has been used or the command includes "tmux". + * Safe to call multiple times; will only initialize once. + * + * If tmux is not installed, this function returns gracefully without + * initializing the socket. getClaudeTmuxEnv() will return null, and + * Bash commands will run without tmux isolation. + */ +export async function ensureSocketInitialized(): Promise { + // Already initialized + if (isSocketInitialized()) { + return + } + + // Check if tmux is available before trying to use it + const available = await checkTmuxAvailable() + if (!available) { + return + } + + // Another call is already initializing - wait for it but don't propagate errors + // The original caller handles the error and sets up graceful degradation + if (isInitializing && initPromise) { + try { + await initPromise + } catch { + // Ignore - the original caller logs the error + } + return + } + + isInitializing = true + initPromise = doInitialize() + + try { + await initPromise + } catch (error) { + // Log error but don't throw - graceful degradation + const err = toError(error) + logError(err) + logForDebugging( + `[Socket] Failed to initialize tmux socket: ${err.message}. Tmux isolation will be disabled.`, + ) + } finally { + isInitializing = false + } +} + +/** + * Kills the tmux server for Claude's isolated socket. + * Called during graceful shutdown to clean up resources. + */ +async function killTmuxServer(): Promise { + const socket = getClaudeSocketName() + logForDebugging(`[Socket] Killing tmux server for socket: ${socket}`) + + const result = await execTmux(['-L', socket, 'kill-server']) + + if (result.code === 0) { + logForDebugging(`[Socket] Successfully killed tmux server`) + } else { + // Server may already be dead, which is fine + logForDebugging( + `[Socket] Failed to kill tmux server (exit ${result.code}): ${result.stderr}`, + ) + } +} + +async function doInitialize(): Promise { + const socket = getClaudeSocketName() + + // Create a new session with our custom socket + // Pass CLAUDE_CODE_SKIP_PROMPT_HISTORY via -e so it's set in the initial shell environment + // + // On Windows, the tmux server inherits WSL_INTEROP from the short-lived + // wsl.exe that spawns it; once `new-session -d` detaches and wsl.exe exits, + // that socket stops servicing requests. Any cli.exe launched inside the pane + // then hits `UtilAcceptVsock: accept4 failed 110` (ETIMEDOUT). Observed on + // 2026-03-25: server PID 386 (started alongside /init at WSL boot) inherited + // /run/WSL/383_interop — init's own socket, which listens but doesn't handle + // interop. /run/WSL/1_interop is a stable symlink WSL maintains to the real + // handler; pin the server to it so interop survives the spawning wsl.exe. + const result = await execTmux([ + '-L', + socket, + 'new-session', + '-d', + '-s', + 'base', + '-e', + 'CLAUDE_CODE_SKIP_PROMPT_HISTORY=true', + ...(getPlatform() === 'windows' + ? ['-e', 'WSL_INTEROP=/run/WSL/1_interop'] + : []), + ]) + + if (result.code !== 0) { + // Session might already exist from a previous run with same PID (unlikely but possible) + // Check if the session exists + const checkResult = await execTmux([ + '-L', + socket, + 'has-session', + '-t', + 'base', + ]) + if (checkResult.code !== 0) { + throw new Error( + `Failed to create tmux session on socket ${socket}: ${result.stderr}`, + ) + } + } + + // Register cleanup to kill the tmux server on exit + registerCleanup(killTmuxServer) + + // Set CLAUDE_CODE_SKIP_PROMPT_HISTORY in the tmux GLOBAL environment (-g). + // Without -g this would only apply to the 'base' session, and new sessions + // created by TungstenTool (e.g. 'test', 'verify') would not inherit it. + // Any Claude Code instance spawned on this socket will inherit this env var, + // preventing test/verification sessions from polluting the user's real + // command history and --resume session list. + await execTmux([ + '-L', + socket, + 'set-environment', + '-g', + 'CLAUDE_CODE_SKIP_PROMPT_HISTORY', + 'true', + ]) + + // Same WSL_INTEROP pin as the new-session -e above, but in the GLOBAL env + // so sessions created by TungstenTool inherit it too. The -e on new-session + // only covers the base session's initial shell; a later `new-session -s cc` + // inherits the SERVER's env, which still holds the stale socket from the + // wsl.exe that spawned it. + if (getPlatform() === 'windows') { + await execTmux([ + '-L', + socket, + 'set-environment', + '-g', + 'WSL_INTEROP', + '/run/WSL/1_interop', + ]) + } + + // Get the socket path and server PID + const infoResult = await execTmux([ + '-L', + socket, + 'display-message', + '-p', + '#{socket_path},#{pid}', + ]) + + if (infoResult.code === 0) { + const [path, pidStr] = infoResult.stdout.trim().split(',') + if (path && pidStr) { + const pid = parseInt(pidStr, 10) + if (!isNaN(pid)) { + setClaudeSocketInfo(path, pid) + return + } + } + // Parsing failed - log and fall through to fallback + logForDebugging( + `[Socket] Failed to parse socket info from tmux output: "${infoResult.stdout.trim()}". Using fallback path.`, + ) + } else { + // Command failed - log and fall through to fallback + logForDebugging( + `[Socket] Failed to get socket info via display-message (exit ${infoResult.code}): ${infoResult.stderr}. Using fallback path.`, + ) + } + + // Fallback: construct the socket path from standard tmux location + // tmux sockets are typically at $TMPDIR/tmux-/ (or /tmp/tmux-/ if TMPDIR is not set) + // On Windows this path is inside WSL, so always use POSIX separators. + // process.getuid() is undefined on Windows; WSL default user is root (uid 0) in CI. + const uid = process.getuid?.() ?? 0 + const baseTmpDir = process.env.TMPDIR || '/tmp' + const fallbackPath = posix.join(baseTmpDir, `tmux-${uid}`, socket) + + // Get server PID separately + const pidResult = await execTmux([ + '-L', + socket, + 'display-message', + '-p', + '#{pid}', + ]) + + if (pidResult.code === 0) { + const pid = parseInt(pidResult.stdout.trim(), 10) + if (!isNaN(pid)) { + logForDebugging( + `[Socket] Using fallback socket path: ${fallbackPath} (server PID: ${pid})`, + ) + setClaudeSocketInfo(fallbackPath, pid) + return + } + // PID parsing failed + logForDebugging( + `[Socket] Failed to parse server PID from tmux output: "${pidResult.stdout.trim()}"`, + ) + } else { + logForDebugging( + `[Socket] Failed to get server PID (exit ${pidResult.code}): ${pidResult.stderr}`, + ) + } + + throw new Error( + `Failed to get socket info for ${socket}: primary="${infoResult.stderr}", fallback="${pidResult.stderr}"`, + ) +} + +// For testing purposes +export function resetSocketState(): void { + socketName = null + socketPath = null + serverPid = null + isInitializing = false + initPromise = null + tmuxAvailabilityChecked = false + tmuxAvailable = false + tmuxToolUsed = false +} diff --git a/src/utils/todo/types.ts b/src/utils/todo/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..639435456a5707699f3f8057723e319ea32830fa --- /dev/null +++ b/src/utils/todo/types.ts @@ -0,0 +1,18 @@ +import { z } from 'zod/v4' +import { lazySchema } from '../lazySchema.js' + +const TodoStatusSchema = lazySchema(() => + z.enum(['pending', 'in_progress', 'completed']), +) + +export const TodoItemSchema = lazySchema(() => + z.object({ + content: z.string().min(1, 'Content cannot be empty'), + status: TodoStatusSchema(), + activeForm: z.string().min(1, 'Active form cannot be empty'), + }), +) +export type TodoItem = z.infer> + +export const TodoListSchema = lazySchema(() => z.array(TodoItemSchema())) +export type TodoList = z.infer> diff --git a/src/utils/tokenBudget.ts b/src/utils/tokenBudget.ts new file mode 100644 index 0000000000000000000000000000000000000000..058c5351aae287a84865332fc4dbe6ca1f9827f9 --- /dev/null +++ b/src/utils/tokenBudget.ts @@ -0,0 +1,73 @@ +// Shorthand (+500k) anchored to start/end to avoid false positives in natural language. +// Verbose (use/spend 2M tokens) matches anywhere. +const SHORTHAND_START_RE = /^\s*\+(\d+(?:\.\d+)?)\s*(k|m|b)\b/i +// Lookbehind (?<=\s) is avoided — it defeats YARR JIT in JSC, and the +// interpreter scans O(n) even with the $ anchor. Capture the whitespace +// instead; callers offset match.index by 1 where position matters. +const SHORTHAND_END_RE = /\s\+(\d+(?:\.\d+)?)\s*(k|m|b)\s*[.!?]?\s*$/i +const VERBOSE_RE = /\b(?:use|spend)\s+(\d+(?:\.\d+)?)\s*(k|m|b)\s*tokens?\b/i +const VERBOSE_RE_G = new RegExp(VERBOSE_RE.source, 'gi') + +const MULTIPLIERS: Record = { + k: 1_000, + m: 1_000_000, + b: 1_000_000_000, +} + +function parseBudgetMatch(value: string, suffix: string): number { + return parseFloat(value) * MULTIPLIERS[suffix.toLowerCase()]! +} + +export function parseTokenBudget(text: string): number | null { + const startMatch = text.match(SHORTHAND_START_RE) + if (startMatch) return parseBudgetMatch(startMatch[1]!, startMatch[2]!) + const endMatch = text.match(SHORTHAND_END_RE) + if (endMatch) return parseBudgetMatch(endMatch[1]!, endMatch[2]!) + const verboseMatch = text.match(VERBOSE_RE) + if (verboseMatch) return parseBudgetMatch(verboseMatch[1]!, verboseMatch[2]!) + return null +} + +export function findTokenBudgetPositions( + text: string, +): Array<{ start: number; end: number }> { + const positions: Array<{ start: number; end: number }> = [] + const startMatch = text.match(SHORTHAND_START_RE) + if (startMatch) { + const offset = + startMatch.index! + + startMatch[0].length - + startMatch[0].trimStart().length + positions.push({ + start: offset, + end: startMatch.index! + startMatch[0].length, + }) + } + const endMatch = text.match(SHORTHAND_END_RE) + if (endMatch) { + // Avoid double-counting when input is just "+500k" + const endStart = endMatch.index! + 1 // +1: regex includes leading \s + const alreadyCovered = positions.some( + p => endStart >= p.start && endStart < p.end, + ) + if (!alreadyCovered) { + positions.push({ + start: endStart, + end: endMatch.index! + endMatch[0].length, + }) + } + } + for (const match of text.matchAll(VERBOSE_RE_G)) { + positions.push({ start: match.index, end: match.index + match[0].length }) + } + return positions +} + +export function getBudgetContinuationMessage( + pct: number, + turnTokens: number, + budget: number, +): string { + const fmt = (n: number): string => new Intl.NumberFormat('en-US').format(n) + return `Stopped at ${pct}% of token target (${fmt(turnTokens)} / ${fmt(budget)}). Keep working \u2014 do not summarize.` +} diff --git a/src/utils/tokens.ts b/src/utils/tokens.ts new file mode 100644 index 0000000000000000000000000000000000000000..c56da552ee0802590f93891249cbe445a5ab8326 --- /dev/null +++ b/src/utils/tokens.ts @@ -0,0 +1,261 @@ +import type { BetaUsage as Usage } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs' +import { roughTokenCountEstimationForMessages } from '../services/tokenEstimation.js' +import type { AssistantMessage, Message } from '../types/message.js' +import { SYNTHETIC_MESSAGES, SYNTHETIC_MODEL } from './messages.js' +import { jsonStringify } from './slowOperations.js' + +export function getTokenUsage(message: Message): Usage | undefined { + if ( + message?.type === 'assistant' && + 'usage' in message.message && + !( + message.message.content[0]?.type === 'text' && + SYNTHETIC_MESSAGES.has(message.message.content[0].text) + ) && + message.message.model !== SYNTHETIC_MODEL + ) { + return message.message.usage + } + return undefined +} + +/** + * Get the API response id for an assistant message with real (non-synthetic) usage. + * Used to identify split assistant records that came from the same API response — + * when parallel tool calls are streamed, each content block becomes a separate + * AssistantMessage record, but they all share the same message.id. + */ +function getAssistantMessageId(message: Message): string | undefined { + if ( + message?.type === 'assistant' && + 'id' in message.message && + message.message.model !== SYNTHETIC_MODEL + ) { + return message.message.id + } + return undefined +} + +/** + * Calculate total context window tokens from an API response's usage data. + * Includes input_tokens + cache tokens + output_tokens. + * + * This represents the full context size at the time of that API call. + * Use tokenCountWithEstimation() when you need context size from messages. + */ +export function getTokenCountFromUsage(usage: Usage): number { + return ( + usage.input_tokens + + (usage.cache_creation_input_tokens ?? 0) + + (usage.cache_read_input_tokens ?? 0) + + usage.output_tokens + ) +} + +export function tokenCountFromLastAPIResponse(messages: Message[]): number { + let i = messages.length - 1 + while (i >= 0) { + const message = messages[i] + const usage = message ? getTokenUsage(message) : undefined + if (usage) { + return getTokenCountFromUsage(usage) + } + i-- + } + return 0 +} + +/** + * Final context window size from the last API response's usage.iterations[-1]. + * Used for task_budget.remaining computation across compaction boundaries — + * the server's budget countdown is context-based, so remaining decrements by + * the pre-compact final window, not billing spend. See monorepo + * api/api/sampling/prompt/renderer.py:292 for the server-side computation. + * + * Falls back to top-level input_tokens + output_tokens when iterations is + * absent (no server-side tool loops, so top-level usage IS the final window). + * Both paths exclude cache tokens to match #304930's formula. + */ +export function finalContextTokensFromLastResponse( + messages: Message[], +): number { + let i = messages.length - 1 + while (i >= 0) { + const message = messages[i] + const usage = message ? getTokenUsage(message) : undefined + if (usage) { + // Stainless types don't include iterations yet — cast like advisor.ts:43 + const iterations = ( + usage as { + iterations?: Array<{ + input_tokens: number + output_tokens: number + }> | null + } + ).iterations + if (iterations && iterations.length > 0) { + const last = iterations.at(-1)! + return last.input_tokens + last.output_tokens + } + // No iterations → no server tool loop → top-level usage IS the final + // window. Match the iterations path's formula (input + output, no cache) + // rather than getTokenCountFromUsage — #304930 defines final window as + // non-cache input + output. Whether the server's budget countdown + // (renderer.py:292 calculate_context_tokens) counts cache the same way + // is an open question; aligning with the iterations path keeps the two + // branches consistent until that's resolved. + return usage.input_tokens + usage.output_tokens + } + i-- + } + return 0 +} + +/** + * Get only the output_tokens from the last API response. + * This excludes input context (system prompt, tools, prior messages). + * + * WARNING: Do NOT use this for threshold comparisons (autocompact, session memory). + * Use tokenCountWithEstimation() instead, which measures full context size. + * This function is only useful for measuring how many tokens Claude generated + * in a single response, not how full the context window is. + */ +export function messageTokenCountFromLastAPIResponse( + messages: Message[], +): number { + let i = messages.length - 1 + while (i >= 0) { + const message = messages[i] + const usage = message ? getTokenUsage(message) : undefined + if (usage) { + return usage.output_tokens + } + i-- + } + return 0 +} + +export function getCurrentUsage(messages: Message[]): { + input_tokens: number + output_tokens: number + cache_creation_input_tokens: number + cache_read_input_tokens: number +} | null { + for (let i = messages.length - 1; i >= 0; i--) { + const message = messages[i] + const usage = message ? getTokenUsage(message) : undefined + if (usage) { + return { + input_tokens: usage.input_tokens, + output_tokens: usage.output_tokens, + cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0, + cache_read_input_tokens: usage.cache_read_input_tokens ?? 0, + } + } + } + return null +} + +export function doesMostRecentAssistantMessageExceed200k( + messages: Message[], +): boolean { + const THRESHOLD = 200_000 + + const lastAsst = messages.findLast(m => m.type === 'assistant') + if (!lastAsst) return false + const usage = getTokenUsage(lastAsst) + return usage ? getTokenCountFromUsage(usage) > THRESHOLD : false +} + +/** + * Calculate the character content length of an assistant message. + * Used for spinner token estimation (characters / 4 ≈ tokens). + * This is used when subagent streaming events are filtered out and we + * need to count content from completed messages instead. + * + * Counts the same content that handleMessageFromStream would count via deltas: + * - text (text_delta) + * - thinking (thinking_delta) + * - redacted_thinking data + * - tool_use input (input_json_delta) + * Note: signature_delta is excluded from streaming counts (not model output). + */ +export function getAssistantMessageContentLength( + message: AssistantMessage, +): number { + let contentLength = 0 + for (const block of message.message.content) { + if (block.type === 'text') { + contentLength += block.text.length + } else if (block.type === 'thinking') { + contentLength += block.thinking.length + } else if (block.type === 'redacted_thinking') { + contentLength += block.data.length + } else if (block.type === 'tool_use') { + contentLength += jsonStringify(block.input).length + } + } + return contentLength +} + +/** + * Get the current context window size in tokens. + * + * This is the CANONICAL function for measuring context size when checking + * thresholds (autocompact, session memory init, etc.). Uses the last API + * response's token count (input + output + cache) plus estimates for any + * messages added since. + * + * Always use this instead of: + * - Cumulative token counting (which double-counts as context grows) + * - messageTokenCountFromLastAPIResponse (which only counts output_tokens) + * - tokenCountFromLastAPIResponse (which doesn't estimate new messages) + * + * Implementation note on parallel tool calls: when the model makes multiple + * tool calls in one response, the streaming code emits a SEPARATE assistant + * record per content block (all sharing the same message.id and usage), and + * the query loop interleaves each tool_result immediately after its tool_use. + * So the messages array looks like: + * [..., assistant(id=A), user(result), assistant(id=A), user(result), ...] + * If we stop at the LAST assistant record, we only estimate the one tool_result + * after it and miss all the earlier interleaved tool_results — which will ALL + * be in the next API request. To avoid undercounting, after finding a usage- + * bearing record we walk back to the FIRST sibling with the same message.id + * so every interleaved tool_result is included in the rough estimate. + */ +export function tokenCountWithEstimation(messages: readonly Message[]): number { + let i = messages.length - 1 + while (i >= 0) { + const message = messages[i] + const usage = message ? getTokenUsage(message) : undefined + if (message && usage) { + // Walk back past any earlier sibling records split from the same API + // response (same message.id) so interleaved tool_results between them + // are included in the estimation slice. + const responseId = getAssistantMessageId(message) + if (responseId) { + let j = i - 1 + while (j >= 0) { + const prior = messages[j] + const priorId = prior ? getAssistantMessageId(prior) : undefined + if (priorId === responseId) { + // Earlier split of the same API response — anchor here instead. + i = j + } else if (priorId !== undefined) { + // Hit a different API response — stop walking. + break + } + // priorId === undefined: a user/tool_result/attachment message, + // possibly interleaved between splits — keep walking. + j-- + } + } + return ( + getTokenCountFromUsage(usage) + + roughTokenCountEstimationForMessages(messages.slice(i + 1)) + ) + } + i-- + } + return roughTokenCountEstimationForMessages(messages) +} diff --git a/src/utils/toolPool.ts b/src/utils/toolPool.ts new file mode 100644 index 0000000000000000000000000000000000000000..b756d91537402f8a4a23e9fefb75a328a878bd26 --- /dev/null +++ b/src/utils/toolPool.ts @@ -0,0 +1,79 @@ +import { feature } from 'bun:bundle' +import partition from 'lodash-es/partition.js' +import uniqBy from 'lodash-es/uniqBy.js' +import { COORDINATOR_MODE_ALLOWED_TOOLS } from '../constants/tools.js' +import { isMcpTool } from '../services/mcp/utils.js' +import type { Tool, ToolPermissionContext, Tools } from '../Tool.js' + +// MCP tool name suffixes for PR activity subscription. These are lightweight +// orchestration actions the coordinator calls directly rather than delegating +// to workers. Matched by suffix since the MCP server name prefix may vary. +const PR_ACTIVITY_TOOL_SUFFIXES = [ + 'subscribe_pr_activity', + 'unsubscribe_pr_activity', +] + +export function isPrActivitySubscriptionTool(name: string): boolean { + return PR_ACTIVITY_TOOL_SUFFIXES.some(suffix => name.endsWith(suffix)) +} + +// Dead code elimination: conditional imports for feature-gated modules +/* eslint-disable @typescript-eslint/no-require-imports */ +const coordinatorModeModule = feature('COORDINATOR_MODE') + ? (require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js')) + : null +/* eslint-enable @typescript-eslint/no-require-imports */ + +/** + * Filters a tool array to the set allowed in coordinator mode. + * Shared between the REPL path (mergeAndFilterTools) and the headless + * path (main.tsx) so both stay in sync. + * + * PR activity subscription tools are always allowed since subscription + * management is orchestration. + */ +export function applyCoordinatorToolFilter(tools: Tools): Tools { + return tools.filter( + t => + COORDINATOR_MODE_ALLOWED_TOOLS.has(t.name) || + isPrActivitySubscriptionTool(t.name), + ) +} + +/** + * Pure function that merges tool pools and applies coordinator mode filtering. + * + * Lives in a React-free file so print.ts can import it without pulling + * react/ink into the SDK module graph. The useMergedTools hook delegates + * to this function inside useMemo. + * + * @param initialTools - Extra tools to include (built-in + startup MCP from props). + * @param assembled - Tools from assembleToolPool (built-in + MCP, deduped). + * @param mode - The permission context mode. + * @returns Merged, deduplicated, and coordinator-filtered tool array. + */ +export function mergeAndFilterTools( + initialTools: Tools, + assembled: Tools, + mode: ToolPermissionContext['mode'], +): Tools { + // Merge initialTools on top - they take precedence in deduplication. + // initialTools may include built-in tools (from getTools() in REPL.tsx) which + // overlap with assembled tools. uniqBy handles this deduplication. + // Partition-sort for prompt-cache stability (same as assembleToolPool): + // built-ins must stay a contiguous prefix for the server's cache policy. + const [mcp, builtIn] = partition( + uniqBy([...initialTools, ...assembled], 'name'), + isMcpTool, + ) + const byName = (a: Tool, b: Tool) => a.name.localeCompare(b.name) + const tools = [...builtIn.sort(byName), ...mcp.sort(byName)] + + if (feature('COORDINATOR_MODE') && coordinatorModeModule) { + if (coordinatorModeModule.isCoordinatorMode()) { + return applyCoordinatorToolFilter(tools) + } + } + + return tools +} diff --git a/src/utils/toolResultStorage.ts b/src/utils/toolResultStorage.ts new file mode 100644 index 0000000000000000000000000000000000000000..f4dfef32663554772a53557930b5651c3ef0c976 --- /dev/null +++ b/src/utils/toolResultStorage.ts @@ -0,0 +1,1040 @@ +/** + * Utility for persisting large tool results to disk instead of truncating them. + */ + +import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs' +import { mkdir, writeFile } from 'fs/promises' +import { join } from 'path' +import { getOriginalCwd, getSessionId } from '../bootstrap/state.js' +import { + BYTES_PER_TOKEN, + DEFAULT_MAX_RESULT_SIZE_CHARS, + MAX_TOOL_RESULT_BYTES, + MAX_TOOL_RESULTS_PER_MESSAGE_CHARS, +} from '../constants/toolLimits.js' +import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js' +import { logEvent } from '../services/analytics/index.js' +import { sanitizeToolNameForAnalytics } from '../services/analytics/metadata.js' +import type { Message } from '../types/message.js' +import { logForDebugging } from './debug.js' +import { getErrnoCode, toError } from './errors.js' +import { formatFileSize } from './format.js' +import { logError } from './log.js' +import { getProjectDir } from './sessionStorage.js' +import { jsonStringify } from './slowOperations.js' + +// Subdirectory name for tool results within a session +export const TOOL_RESULTS_SUBDIR = 'tool-results' + +// XML tag used to wrap persisted output messages +export const PERSISTED_OUTPUT_TAG = '' +export const PERSISTED_OUTPUT_CLOSING_TAG = '' + +// Message used when tool result content was cleared without persisting to file +export const TOOL_RESULT_CLEARED_MESSAGE = '[Old tool result content cleared]' + +/** + * GrowthBook override map: tool name -> persistence threshold (chars). + * When a tool name is present in this map, that value is used directly as the + * effective threshold, bypassing the Math.min() clamp against the 50k default. + * Tools absent from the map use the hardcoded fallback. + * Flag default is {} (no overrides == behavior unchanged). + */ +const PERSIST_THRESHOLD_OVERRIDE_FLAG = 'tengu_satin_quoll' + +/** + * Resolve the effective persistence threshold for a tool. + * GrowthBook override wins when present; otherwise falls back to the declared + * per-tool cap clamped by the global default. + * + * Defensive: GrowthBook's cache returns `cached !== undefined ? cached : default`, + * so a flag served as `null` leaks through. We guard with optional chaining and a + * typeof check so any non-object flag value (null, string, number) falls through + * to the hardcoded default instead of throwing on index or returning 0. + */ +export function getPersistenceThreshold( + toolName: string, + declaredMaxResultSizeChars: number, +): number { + // Infinity = hard opt-out. Read self-bounds via maxTokens; persisting its + // output to a file the model reads back with Read is circular. Checked + // before the GB override so tengu_satin_quoll can't force it back on. + if (!Number.isFinite(declaredMaxResultSizeChars)) { + return declaredMaxResultSizeChars + } + const overrides = getFeatureValue_CACHED_MAY_BE_STALE | null>(PERSIST_THRESHOLD_OVERRIDE_FLAG, {}) + const override = overrides?.[toolName] + if ( + typeof override === 'number' && + Number.isFinite(override) && + override > 0 + ) { + return override + } + return Math.min(declaredMaxResultSizeChars, DEFAULT_MAX_RESULT_SIZE_CHARS) +} + +// Result of persisting a tool result to disk +export type PersistedToolResult = { + filepath: string + originalSize: number + isJson: boolean + preview: string + hasMore: boolean +} + +// Error result when persistence fails +export type PersistToolResultError = { + error: string +} + +/** + * Get the session directory (projectDir/sessionId) + */ +function getSessionDir(): string { + return join(getProjectDir(getOriginalCwd()), getSessionId()) +} + +/** + * Get the tool results directory for this session (projectDir/sessionId/tool-results) + */ +export function getToolResultsDir(): string { + return join(getSessionDir(), TOOL_RESULTS_SUBDIR) +} + +// Preview size in bytes for the reference message +export const PREVIEW_SIZE_BYTES = 2000 + +/** + * Get the filepath where a tool result would be persisted. + */ +export function getToolResultPath(id: string, isJson: boolean): string { + const ext = isJson ? 'json' : 'txt' + return join(getToolResultsDir(), `${id}.${ext}`) +} + +/** + * Ensure the session-specific tool results directory exists + */ +export async function ensureToolResultsDir(): Promise { + try { + await mkdir(getToolResultsDir(), { recursive: true }) + } catch { + // Directory may already exist + } +} + +/** + * Persist a tool result to disk and return information about the persisted file + * + * @param content - The tool result content to persist (string or array of content blocks) + * @param toolUseId - The ID of the tool use that produced the result + * @returns Information about the persisted file including filepath and preview + */ +export async function persistToolResult( + content: NonNullable, + toolUseId: string, +): Promise { + const isJson = Array.isArray(content) + + // Check for non-text content - we can only persist text blocks + if (isJson) { + const hasNonTextContent = content.some(block => block.type !== 'text') + if (hasNonTextContent) { + return { + error: 'Cannot persist tool results containing non-text content', + } + } + } + + await ensureToolResultsDir() + const filepath = getToolResultPath(toolUseId, isJson) + const contentStr = isJson ? jsonStringify(content, null, 2) : content + + // tool_use_id is unique per invocation and content is deterministic for a + // given id, so skip if the file already exists. This prevents re-writing + // the same content on every API turn when microcompact replays the + // original messages. Use 'wx' instead of a stat-then-write race. + try { + await writeFile(filepath, contentStr, { encoding: 'utf-8', flag: 'wx' }) + logForDebugging( + `Persisted tool result to ${filepath} (${formatFileSize(contentStr.length)})`, + ) + } catch (error) { + if (getErrnoCode(error) !== 'EEXIST') { + logError(toError(error)) + return { error: getFileSystemErrorMessage(toError(error)) } + } + // EEXIST: already persisted on a prior turn, fall through to preview + } + + // Generate a preview + const { preview, hasMore } = generatePreview(contentStr, PREVIEW_SIZE_BYTES) + + return { + filepath, + originalSize: contentStr.length, + isJson, + preview, + hasMore, + } +} + +/** + * Build a message for large tool results with preview + */ +export function buildLargeToolResultMessage( + result: PersistedToolResult, +): string { + let message = `${PERSISTED_OUTPUT_TAG}\n` + message += `Output too large (${formatFileSize(result.originalSize)}). Full output saved to: ${result.filepath}\n\n` + message += `Preview (first ${formatFileSize(PREVIEW_SIZE_BYTES)}):\n` + message += result.preview + message += result.hasMore ? '\n...\n' : '\n' + message += PERSISTED_OUTPUT_CLOSING_TAG + return message +} + +/** + * Process a tool result for inclusion in a message. + * Maps the result to the API format and persists large results to disk. + */ +export async function processToolResultBlock( + tool: { + name: string + maxResultSizeChars: number + mapToolResultToToolResultBlockParam: ( + result: T, + toolUseID: string, + ) => ToolResultBlockParam + }, + toolUseResult: T, + toolUseID: string, +): Promise { + const toolResultBlock = tool.mapToolResultToToolResultBlockParam( + toolUseResult, + toolUseID, + ) + return maybePersistLargeToolResult( + toolResultBlock, + tool.name, + getPersistenceThreshold(tool.name, tool.maxResultSizeChars), + ) +} + +/** + * Process a pre-mapped tool result block. Applies persistence for large results + * without re-calling mapToolResultToToolResultBlockParam. + */ +export async function processPreMappedToolResultBlock( + toolResultBlock: ToolResultBlockParam, + toolName: string, + maxResultSizeChars: number, +): Promise { + return maybePersistLargeToolResult( + toolResultBlock, + toolName, + getPersistenceThreshold(toolName, maxResultSizeChars), + ) +} + +/** + * True when a tool_result's content is empty or effectively empty. Covers: + * undefined/null/'', whitespace-only strings, empty arrays, and arrays whose + * only blocks are text blocks with empty/whitespace text. Non-text blocks + * (images, tool_reference) are treated as non-empty. + */ +export function isToolResultContentEmpty( + content: ToolResultBlockParam['content'], +): boolean { + if (!content) return true + if (typeof content === 'string') return content.trim() === '' + if (!Array.isArray(content)) return false + if (content.length === 0) return true + return content.every( + block => + typeof block === 'object' && + 'type' in block && + block.type === 'text' && + 'text' in block && + (typeof block.text !== 'string' || block.text.trim() === ''), + ) +} + +/** + * Handle large tool results by persisting to disk instead of truncating. + * Returns the original block if no persistence needed, or a modified block + * with the content replaced by a reference to the persisted file. + */ +async function maybePersistLargeToolResult( + toolResultBlock: ToolResultBlockParam, + toolName: string, + persistenceThreshold?: number, +): Promise { + // Check size first before doing any async work - most tool results are small + const content = toolResultBlock.content + + // inc-4586: Empty tool_result content at the prompt tail causes some models + // (notably capybara) to emit the \n\nHuman: stop sequence and end their turn + // with zero output. The server renderer inserts no \n\nAssistant: marker after + // tool results, so a bare \n\n pattern-matches to a turn + // boundary. Several tools can legitimately produce empty output (silent-success + // shell commands, MCP servers returning content:[], REPL statements, etc.). + // Inject a short marker so the model always has something to react to. + if (isToolResultContentEmpty(content)) { + logEvent('tengu_tool_empty_result', { + toolName: sanitizeToolNameForAnalytics(toolName), + }) + return { + ...toolResultBlock, + content: `(${toolName} completed with no output)`, + } + } + // Narrow after the emptiness guard — content is non-nullish past this point. + if (!content) { + return toolResultBlock + } + + // Skip persistence for image content blocks - they need to be sent as-is to Claude + if (hasImageBlock(content)) { + return toolResultBlock + } + + const size = contentSize(content) + + // Use tool-specific threshold if provided, otherwise fall back to global limit + const threshold = persistenceThreshold ?? MAX_TOOL_RESULT_BYTES + if (size <= threshold) { + return toolResultBlock + } + + // Persist the entire content as a unit + const result = await persistToolResult(content, toolResultBlock.tool_use_id) + if (isPersistError(result)) { + // If persistence failed, return the original block unchanged + return toolResultBlock + } + + const message = buildLargeToolResultMessage(result) + + // Log analytics + logEvent('tengu_tool_result_persisted', { + toolName: sanitizeToolNameForAnalytics(toolName), + originalSizeBytes: result.originalSize, + persistedSizeBytes: message.length, + estimatedOriginalTokens: Math.ceil(result.originalSize / BYTES_PER_TOKEN), + estimatedPersistedTokens: Math.ceil(message.length / BYTES_PER_TOKEN), + thresholdUsed: threshold, + }) + + return { ...toolResultBlock, content: message } +} + +/** + * Generate a preview of content, truncating at a newline boundary when possible. + */ +export function generatePreview( + content: string, + maxBytes: number, +): { preview: string; hasMore: boolean } { + if (content.length <= maxBytes) { + return { preview: content, hasMore: false } + } + + // Find the last newline within the limit to avoid cutting mid-line + const truncated = content.slice(0, maxBytes) + const lastNewline = truncated.lastIndexOf('\n') + + // If we found a newline reasonably close to the limit, use it + // Otherwise fall back to the exact limit + const cutPoint = lastNewline > maxBytes * 0.5 ? lastNewline : maxBytes + + return { preview: content.slice(0, cutPoint), hasMore: true } +} + +/** + * Type guard to check if persist result is an error + */ +export function isPersistError( + result: PersistedToolResult | PersistToolResultError, +): result is PersistToolResultError { + return 'error' in result +} + +// --- Message-level aggregate tool result budget --- +// +// Tracks replacement state across turns so enforceToolResultBudget makes the +// same choices every time (preserves prompt cache prefix). + +/** + * Per-conversation-thread state for the aggregate tool result budget. + * State must be stable to preserve prompt cache: + * - seenIds: results that have passed through the budget check (replaced + * or not). Once seen, a result's fate is frozen for the conversation. + * - replacements: subset of seenIds that were persisted to disk and + * replaced with previews, mapped to the exact preview string shown to + * the model. Re-application is a Map lookup — no file I/O, guaranteed + * byte-identical, cannot fail. + * + * Lifecycle: one instance per conversation thread, carried on ToolUseContext. + * Main thread: REPL provisions once, never resets — stale entries after + * /clear, rewind, resume, or compact are never looked up (tool_use_ids are + * UUIDs) so they're harmless. Subagents: createSubagentContext clones the + * parent's state by default (cache-sharing forks like agentSummary need + * identical decisions), or resumeAgentBackground threads one reconstructed + * from sidechain records. + */ +export type ContentReplacementState = { + seenIds: Set + replacements: Map +} + +export function createContentReplacementState(): ContentReplacementState { + return { seenIds: new Set(), replacements: new Map() } +} + +/** + * Clone replacement state for a cache-sharing fork (e.g. agentSummary). + * The fork needs state identical to the source at fork time so + * enforceToolResultBudget makes the same choices → same wire prefix → + * prompt cache hit. Mutating the clone does not affect the source. + */ +export function cloneContentReplacementState( + source: ContentReplacementState, +): ContentReplacementState { + return { + seenIds: new Set(source.seenIds), + replacements: new Map(source.replacements), + } +} + +/** + * Resolve the per-message aggregate budget limit. GrowthBook override + * (tengu_hawthorn_window) wins when present and a finite positive number; + * otherwise falls back to the hardcoded constant. Defensive typeof/finite + * check: GrowthBook's cache returns `cached !== undefined ? cached : default`, + * so a flag served as null/string/NaN leaks through. + */ +export function getPerMessageBudgetLimit(): number { + const override = getFeatureValue_CACHED_MAY_BE_STALE( + 'tengu_hawthorn_window', + null, + ) + if ( + typeof override === 'number' && + Number.isFinite(override) && + override > 0 + ) { + return override + } + return MAX_TOOL_RESULTS_PER_MESSAGE_CHARS +} + +/** + * Provision replacement state for a new conversation thread. + * + * Encapsulates the feature-flag gate + reconstruct-vs-fresh choice: + * - Flag off → undefined (query.ts skips enforcement entirely) + * - No initialMessages (cold start) → fresh + * - initialMessages present → reconstruct (freeze all candidate IDs so the + * budget never replaces content the model already saw unreplaced). Empty + * or absent records freeze everything; non-empty records additionally + * populate the replacements Map for byte-identical re-apply. + */ +export function provisionContentReplacementState( + initialMessages?: Message[], + initialContentReplacements?: ContentReplacementRecord[], +): ContentReplacementState | undefined { + const enabled = getFeatureValue_CACHED_MAY_BE_STALE( + 'tengu_hawthorn_steeple', + false, + ) + if (!enabled) return undefined + if (initialMessages) { + return reconstructContentReplacementState( + initialMessages, + initialContentReplacements ?? [], + ) + } + return createContentReplacementState() +} + +/** + * Serializable record of one content-replacement decision. Written to the + * transcript as a ContentReplacementEntry so decisions survive resume. + * Discriminated by `kind` so future replacement mechanisms (user text, + * offloaded images) can share the same transcript entry type. + * + * `replacement` is the exact string the model saw — stored rather than + * derived on resume so code changes to the preview template, size formatting, + * or path layout can't silently break prompt cache. + */ +export type ContentReplacementRecord = { + kind: 'tool-result' + toolUseId: string + replacement: string +} + +export type ToolResultReplacementRecord = Extract< + ContentReplacementRecord, + { kind: 'tool-result' } +> + +type ToolResultCandidate = { + toolUseId: string + content: NonNullable + size: number +} + +type CandidatePartition = { + mustReapply: Array + frozen: ToolResultCandidate[] + fresh: ToolResultCandidate[] +} + +function isContentAlreadyCompacted( + content: ToolResultBlockParam['content'], +): boolean { + // All budget-produced content starts with the tag (buildLargeToolResultMessage). + // `.startsWith()` avoids false-positives when the tag appears anywhere else + // in the content (e.g., reading this source file). + return typeof content === 'string' && content.startsWith(PERSISTED_OUTPUT_TAG) +} + +function hasImageBlock( + content: NonNullable, +): boolean { + return ( + Array.isArray(content) && + content.some( + b => typeof b === 'object' && 'type' in b && b.type === 'image', + ) + ) +} + +function contentSize( + content: NonNullable, +): number { + if (typeof content === 'string') return content.length + // Sum text-block lengths directly. Slightly under-counts vs serialized + // (no JSON framing), but the budget is a rough token heuristic anyway. + // Avoids allocating a content-sized string every enforcement pass. + return content.reduce( + (sum, b) => sum + (b.type === 'text' ? b.text.length : 0), + 0, + ) +} + +/** + * Walk messages and build tool_use_id → tool_name from assistant tool_use + * blocks. tool_use always precedes its tool_result (model calls, then result + * arrives), so by the time budget enforcement sees a result, its name is known. + */ +function buildToolNameMap(messages: Message[]): Map { + const map = new Map() + for (const message of messages) { + if (message.type !== 'assistant') continue + const content = message.message.content + if (!Array.isArray(content)) continue + for (const block of content) { + if (block.type === 'tool_use') { + map.set(block.id, block.name) + } + } + } + return map +} + +/** + * Extract candidate tool_result blocks from a single user message: blocks + * that are non-empty, non-image, and not already compacted by tag (i.e. by + * the per-tool limit, or an earlier iteration of this same query call). + * Returns [] for messages with no eligible blocks. + */ +function collectCandidatesFromMessage(message: Message): ToolResultCandidate[] { + if (message.type !== 'user' || !Array.isArray(message.message.content)) { + return [] + } + return message.message.content.flatMap(block => { + if (block.type !== 'tool_result' || !block.content) return [] + if (isContentAlreadyCompacted(block.content)) return [] + if (hasImageBlock(block.content)) return [] + return [ + { + toolUseId: block.tool_use_id, + content: block.content, + size: contentSize(block.content), + }, + ] + }) +} + +/** + * Extract candidate tool_result blocks grouped by API-level user message. + * + * normalizeMessagesForAPI merges consecutive user messages into one + * (Bedrock compat; 1P does the same server-side), so parallel tool + * results that arrive as N separate user messages in our state become + * ONE user message on the wire. The budget must group the same way or + * it would see N under-budget messages instead of one over-budget + * message and fail to enforce exactly when it matters most. + * + * A "group" is a maximal run of user messages NOT separated by an + * assistant message. Only assistant messages create wire-level + * boundaries — normalizeMessagesForAPI filters out progress entirely + * and merges attachment / system(local_command) INTO adjacent user + * blocks, so those types do NOT break groups here either. + * + * This matters for abort-during-parallel-tools paths: agent_progress + * messages (non-ephemeral, persisted in REPL state) can interleave + * between fresh tool_result messages. If we flushed on progress, those + * tool_results would split into under-budget groups, slip through + * unreplaced, get frozen, then be merged by normalizeMessagesForAPI + * into one over-budget wire message — defeating the feature. + * + * Only groups with at least one eligible candidate are returned. + */ +function collectCandidatesByMessage( + messages: Message[], +): ToolResultCandidate[][] { + const groups: ToolResultCandidate[][] = [] + let current: ToolResultCandidate[] = [] + + const flush = () => { + if (current.length > 0) groups.push(current) + current = [] + } + + // Track all assistant message.ids seen so far — same-ID fragments are + // merged by normalizeMessagesForAPI (messages.ts ~2126 walks back PAST + // different-ID assistants via `continue`), so any re-appearance of a + // previously-seen ID must NOT create a group boundary. Two scenarios: + // • Consecutive: streamingToolExecution yields one AssistantMessage per + // content_block_stop (same id); a fast tool drains between blocks; + // abort/hook-stop leaves [asst(X), user(trA), asst(X), user(trB)]. + // • Interleaved: coordinator/teammate streams mix different responses + // so [asst(X), user(trA), asst(Y), user(trB), asst(X), user(trC)]. + // In both, normalizeMessagesForAPI merges the X fragments into one wire + // assistant, and their following tool_results merge into one wire user + // message — so the budget must see them as one group too. + const seenAsstIds = new Set() + for (const message of messages) { + if (message.type === 'user') { + current.push(...collectCandidatesFromMessage(message)) + } else if (message.type === 'assistant') { + if (!seenAsstIds.has(message.message.id)) { + flush() + seenAsstIds.add(message.message.id) + } + } + // progress / attachment / system are filtered or merged by + // normalizeMessagesForAPI — they don't create wire boundaries. + } + flush() + + return groups +} + +/** + * Partition candidates by their prior decision state: + * - mustReapply: previously replaced → re-apply the cached replacement for + * prefix stability + * - frozen: previously seen and left unreplaced → off-limits (replacing + * now would change a prefix that was already cached) + * - fresh: never seen → eligible for new replacement decisions + */ +function partitionByPriorDecision( + candidates: ToolResultCandidate[], + state: ContentReplacementState, +): CandidatePartition { + return candidates.reduce( + (acc, c) => { + const replacement = state.replacements.get(c.toolUseId) + if (replacement !== undefined) { + acc.mustReapply.push({ ...c, replacement }) + } else if (state.seenIds.has(c.toolUseId)) { + acc.frozen.push(c) + } else { + acc.fresh.push(c) + } + return acc + }, + { mustReapply: [], frozen: [], fresh: [] }, + ) +} + +/** + * Pick the largest fresh results to replace until the model-visible total + * (frozen + remaining fresh) is at or under budget, or fresh is exhausted. + * If frozen results alone exceed budget we accept the overage — microcompact + * will eventually clear them. + */ +function selectFreshToReplace( + fresh: ToolResultCandidate[], + frozenSize: number, + limit: number, +): ToolResultCandidate[] { + const sorted = [...fresh].sort((a, b) => b.size - a.size) + const selected: ToolResultCandidate[] = [] + let remaining = frozenSize + fresh.reduce((sum, c) => sum + c.size, 0) + for (const c of sorted) { + if (remaining <= limit) break + selected.push(c) + // We don't know the replacement size until after persist, but previews + // are ~2K and results hitting this path are much larger, so subtracting + // the full size is a close approximation for selection purposes. + remaining -= c.size + } + return selected +} + +/** + * Return a new Message[] where each tool_result block whose id appears in + * replacementMap has its content replaced. Messages and blocks with no + * replacements are passed through by reference. + */ +function replaceToolResultContents( + messages: Message[], + replacementMap: Map, +): Message[] { + return messages.map(message => { + if (message.type !== 'user' || !Array.isArray(message.message.content)) { + return message + } + const content = message.message.content + const needsReplace = content.some( + b => b.type === 'tool_result' && replacementMap.has(b.tool_use_id), + ) + if (!needsReplace) return message + return { + ...message, + message: { + ...message.message, + content: content.map(block => { + if (block.type !== 'tool_result') return block + const replacement = replacementMap.get(block.tool_use_id) + return replacement === undefined + ? block + : { ...block, content: replacement } + }), + }, + } + }) +} + +async function buildReplacement( + candidate: ToolResultCandidate, +): Promise<{ content: string; originalSize: number } | null> { + const result = await persistToolResult(candidate.content, candidate.toolUseId) + if (isPersistError(result)) return null + return { + content: buildLargeToolResultMessage(result), + originalSize: result.originalSize, + } +} + +/** + * Enforce the per-message budget on aggregate tool result size. + * + * For each user message whose tool_result blocks together exceed the + * per-message limit (see getPerMessageBudgetLimit), the largest FRESH + * (never-before-seen) results in THAT message are persisted to disk and + * replaced with previews. + * Messages are evaluated independently — a 150K result in one message and + * a 150K result in another are both under budget and untouched. + * + * State is tracked by tool_use_id in `state`. Once a result is seen its + * fate is frozen: previously-replaced results get the same replacement + * re-applied every turn from the cached preview string (zero I/O, + * byte-identical), and previously-unreplaced results are never replaced + * later (would break prompt cache). + * + * Each turn adds at most one new user message with tool_result blocks, + * so the per-message loop typically does the budget check at most once; + * all prior messages just re-apply cached replacements. + * + * @param state — MUTATED: seenIds and replacements are updated in place + * to record choices made this call. The caller holds a stable reference + * across turns; returning a new object would require error-prone ref + * updates after every query. + * + * Returns `{ messages, newlyReplaced }`: + * - messages: same array instance when no replacement is needed + * - newlyReplaced: replacements made THIS call (not re-applies). + * Caller persists these to the transcript for resume reconstruction. + */ +export async function enforceToolResultBudget( + messages: Message[], + state: ContentReplacementState, + skipToolNames: ReadonlySet = new Set(), +): Promise<{ + messages: Message[] + newlyReplaced: ToolResultReplacementRecord[] +}> { + const candidatesByMessage = collectCandidatesByMessage(messages) + const nameByToolUseId = + skipToolNames.size > 0 ? buildToolNameMap(messages) : undefined + const shouldSkip = (id: string): boolean => + nameByToolUseId !== undefined && + skipToolNames.has(nameByToolUseId.get(id) ?? '') + // Resolve once per call. A mid-session flag change only affects FRESH + // messages (prior decisions are frozen via seenIds/replacements), so + // prompt cache for already-seen content is preserved regardless. + const limit = getPerMessageBudgetLimit() + + // Walk each API-level message group independently. For previously-processed messages + // (all IDs in seenIds) this just re-applies cached replacements. For the + // single new message this turn added, it runs the budget check. + const replacementMap = new Map() + const toPersist: ToolResultCandidate[] = [] + let reappliedCount = 0 + let messagesOverBudget = 0 + + for (const candidates of candidatesByMessage) { + const { mustReapply, frozen, fresh } = partitionByPriorDecision( + candidates, + state, + ) + + // Re-apply: pure Map lookups. No file I/O, byte-identical, cannot fail. + mustReapply.forEach(c => replacementMap.set(c.toolUseId, c.replacement)) + reappliedCount += mustReapply.length + + // Fresh means this is a new message. Check its per-message budget. + // (A previously-processed message has fresh.length === 0 because all + // its IDs were added to seenIds when first seen.) + if (fresh.length === 0) { + // mustReapply/frozen are already in seenIds from their first pass — + // re-adding is a no-op but keeps the invariant explicit. + candidates.forEach(c => state.seenIds.add(c.toolUseId)) + continue + } + + // Tools with maxResultSizeChars: Infinity (Read) — never persist. + // Mark as seen (frozen) so the decision sticks across turns. They don't + // count toward freshSize; if that lets the group slip under budget and + // the wire message is still large, that's the contract — Read's own + // maxTokens is the bound, not this wrapper. + const skipped = fresh.filter(c => shouldSkip(c.toolUseId)) + skipped.forEach(c => state.seenIds.add(c.toolUseId)) + const eligible = fresh.filter(c => !shouldSkip(c.toolUseId)) + + const frozenSize = frozen.reduce((sum, c) => sum + c.size, 0) + const freshSize = eligible.reduce((sum, c) => sum + c.size, 0) + + const selected = + frozenSize + freshSize > limit + ? selectFreshToReplace(eligible, frozenSize, limit) + : [] + + // Mark non-persisting candidates as seen NOW (synchronously). IDs + // selected for persist are marked seen AFTER the await, alongside + // replacements.set — keeps the pair atomic under observation so no + // concurrent reader (once subagents share state) ever sees X∈seenIds + // but X∉replacements, which would misclassify X as frozen and send + // full content while the main thread sends the preview → cache miss. + const selectedIds = new Set(selected.map(c => c.toolUseId)) + candidates + .filter(c => !selectedIds.has(c.toolUseId)) + .forEach(c => state.seenIds.add(c.toolUseId)) + + if (selected.length === 0) continue + messagesOverBudget++ + toPersist.push(...selected) + } + + if (replacementMap.size === 0 && toPersist.length === 0) { + return { messages, newlyReplaced: [] } + } + + // Fresh: concurrent persist for all selected candidates across all + // messages. In practice toPersist comes from a single message per turn. + const freshReplacements = await Promise.all( + toPersist.map(async c => [c, await buildReplacement(c)] as const), + ) + const newlyReplaced: ToolResultReplacementRecord[] = [] + let replacedSize = 0 + for (const [candidate, replacement] of freshReplacements) { + // Mark seen HERE, post-await, atomically with replacements.set for + // success cases. For persist failures (replacement === null) the ID + // is seen-but-unreplaced — the original content was sent to the + // model, so treating it as frozen going forward is correct. + state.seenIds.add(candidate.toolUseId) + if (replacement === null) continue + replacedSize += candidate.size + replacementMap.set(candidate.toolUseId, replacement.content) + state.replacements.set(candidate.toolUseId, replacement.content) + newlyReplaced.push({ + kind: 'tool-result', + toolUseId: candidate.toolUseId, + replacement: replacement.content, + }) + logEvent('tengu_tool_result_persisted_message_budget', { + originalSizeBytes: replacement.originalSize, + persistedSizeBytes: replacement.content.length, + estimatedOriginalTokens: Math.ceil( + replacement.originalSize / BYTES_PER_TOKEN, + ), + estimatedPersistedTokens: Math.ceil( + replacement.content.length / BYTES_PER_TOKEN, + ), + }) + } + + if (replacementMap.size === 0) { + return { messages, newlyReplaced: [] } + } + + if (newlyReplaced.length > 0) { + logForDebugging( + `Per-message budget: persisted ${newlyReplaced.length} tool results ` + + `across ${messagesOverBudget} over-budget message(s), ` + + `shed ~${formatFileSize(replacedSize)}, ${reappliedCount} re-applied`, + ) + logEvent('tengu_message_level_tool_result_budget_enforced', { + resultsPersisted: newlyReplaced.length, + messagesOverBudget, + replacedSizeBytes: replacedSize, + reapplied: reappliedCount, + }) + } + + return { + messages: replaceToolResultContents(messages, replacementMap), + newlyReplaced, + } +} + +/** + * Query-loop integration point for the aggregate budget. + * + * Gates on `state` (undefined means feature disabled → no-op return), + * applies enforcement, and fires an optional transcript-write callback + * for new replacements. The caller (query.ts) owns the persistence gate + * — it passes a callback only for querySources that read records back on + * resume (repl_main_thread*, agent:*); ephemeral runForkedAgent callers + * (agentSummary, sessionMemory, /btw, compact) pass undefined. + * + * @returns messages with replacements applied, or the input array unchanged + * when the feature is off or no replacement occurred. + */ +export async function applyToolResultBudget( + messages: Message[], + state: ContentReplacementState | undefined, + writeToTranscript?: (records: ToolResultReplacementRecord[]) => void, + skipToolNames?: ReadonlySet, +): Promise { + if (!state) return messages + const result = await enforceToolResultBudget(messages, state, skipToolNames) + if (result.newlyReplaced.length > 0) { + writeToTranscript?.(result.newlyReplaced) + } + return result.messages +} + +/** + * Reconstruct replacement state from content-replacement records loaded from + * the transcript. Used on resume so the budget makes the same choices it + * made in the original session (prompt cache stability). + * + * Accepts the full ContentReplacementRecord[] from LogOption (may include + * future non-tool-result kinds); only tool-result records are applied here. + * + * - replacements: populated directly from the stored replacement strings. + * Records for IDs not in messages (e.g. after compact) are skipped — + * they're inert anyway. + * - seenIds: every candidate tool_use_id in the loaded messages. A result + * being in the transcript means it was sent to the model, so it was seen. + * This freezes unreplaced results against future replacement. + * - inheritedReplacements: gap-fill for fork-subagent resume. A fork's + * original run applies parent-inherited replacements via mustReapply + * (never persisted — not newlyReplaced). On resume the sidechain has + * the original content but no record, so records alone would classify + * it as frozen. The parent's live state still has the mapping; copy + * it for IDs in messages that records don't cover. No-op for non-fork + * resumes (parent IDs aren't in the subagent's messages). + */ +export function reconstructContentReplacementState( + messages: Message[], + records: ContentReplacementRecord[], + inheritedReplacements?: ReadonlyMap, +): ContentReplacementState { + const state = createContentReplacementState() + const candidateIds = new Set( + collectCandidatesByMessage(messages) + .flat() + .map(c => c.toolUseId), + ) + + for (const id of candidateIds) { + state.seenIds.add(id) + } + for (const r of records) { + if (r.kind === 'tool-result' && candidateIds.has(r.toolUseId)) { + state.replacements.set(r.toolUseId, r.replacement) + } + } + if (inheritedReplacements) { + for (const [id, replacement] of inheritedReplacements) { + if (candidateIds.has(id) && !state.replacements.has(id)) { + state.replacements.set(id, replacement) + } + } + } + return state +} + +/** + * AgentTool-resume variant: encapsulates the feature-flag gate + parent + * gap-fill so both AgentTool.call and resumeAgentBackground share one + * implementation. Returns undefined when parentState is undefined (feature + * off); otherwise reconstructs from sidechain records with parent's live + * replacements filling gaps for fork-inherited mustReapply entries. + * + * Kept out of AgentTool.tsx — that file is at the feature() DCE complexity + * cliff and cannot tolerate even +1 net source line without silently + * breaking feature('TRANSCRIPT_CLASSIFIER') eval in tests. + */ +export function reconstructForSubagentResume( + parentState: ContentReplacementState | undefined, + resumedMessages: Message[], + sidechainRecords: ContentReplacementRecord[], +): ContentReplacementState | undefined { + if (!parentState) return undefined + return reconstructContentReplacementState( + resumedMessages, + sidechainRecords, + parentState.replacements, + ) +} + +/** + * Get a human-readable error message from a filesystem error + */ +function getFileSystemErrorMessage(error: Error): string { + // Node.js filesystem errors have a 'code' property + // eslint-disable-next-line no-restricted-syntax -- uses .path, not just .code + const nodeError = error as NodeJS.ErrnoException + if (nodeError.code) { + switch (nodeError.code) { + case 'ENOENT': + return `Directory not found: ${nodeError.path ?? 'unknown path'}` + case 'EACCES': + return `Permission denied: ${nodeError.path ?? 'unknown path'}` + case 'ENOSPC': + return 'No space left on device' + case 'EROFS': + return 'Read-only file system' + case 'EMFILE': + return 'Too many open files' + case 'EEXIST': + return `File already exists: ${nodeError.path ?? 'unknown path'}` + default: + return `${nodeError.code}: ${nodeError.message}` + } + } + return error.message +} diff --git a/src/utils/ultraplan/ccrSession.ts b/src/utils/ultraplan/ccrSession.ts new file mode 100644 index 0000000000000000000000000000000000000000..a72b594e645f57d1fe88494349d4c9d95e468a7c --- /dev/null +++ b/src/utils/ultraplan/ccrSession.ts @@ -0,0 +1,349 @@ +// CCR session polling for /ultraplan. Waits for an approved ExitPlanMode +// tool_result, then extracts the plan text. Uses pollRemoteSessionEvents +// (shared with RemoteAgentTask) for pagination + typed SDKMessage[]. +// Plan mode is set via set_permission_mode control_request in +// teleportToRemote's CreateSession events array. + +import type { + ToolResultBlockParam, + ToolUseBlock, +} from '@anthropic-ai/sdk/resources' +import type { SDKMessage } from '../../entrypoints/agentSdkTypes.js' +import { EXIT_PLAN_MODE_V2_TOOL_NAME } from '../../tools/ExitPlanModeTool/constants.js' +import { logForDebugging } from '../debug.js' +import { sleep } from '../sleep.js' +import { isTransientNetworkError } from '../teleport/api.js' +import { + type PollRemoteSessionResponse, + pollRemoteSessionEvents, +} from '../teleport.js' + +const POLL_INTERVAL_MS = 3000 +// pollRemoteSessionEvents doesn't retry. A 30min poll makes ~600 calls; +// at any nonzero 5xx rate one blip would kill the run. +const MAX_CONSECUTIVE_FAILURES = 5 + +export type PollFailReason = + | 'terminated' + | 'timeout_pending' + | 'timeout_no_plan' + | 'extract_marker_missing' + | 'network_or_unknown' + | 'stopped' + +export class UltraplanPollError extends Error { + constructor( + message: string, + readonly reason: PollFailReason, + readonly rejectCount: number, + options?: ErrorOptions, + ) { + super(message, options) + this.name = 'UltraplanPollError' + } +} + +// Sentinel string the browser PlanModal includes in the feedback when the user +// clicks "teleport back to terminal". Plan text follows on the next line. +export const ULTRAPLAN_TELEPORT_SENTINEL = '__ULTRAPLAN_TELEPORT_LOCAL__' + +export type ScanResult = + | { kind: 'approved'; plan: string } + | { kind: 'teleport'; plan: string } + | { kind: 'rejected'; id: string } + | { kind: 'pending' } + | { kind: 'terminated'; subtype: string } + | { kind: 'unchanged' } + +/** + * Pill/detail-view state derived from the event stream. Transitions: + * running → (turn ends, no ExitPlanMode) → needs_input + * needs_input → (user replies in browser) → running + * running → (ExitPlanMode emitted, no result yet) → plan_ready + * plan_ready → (rejected) → running + * plan_ready → (approved) → poll resolves, pill removed + */ +export type UltraplanPhase = 'running' | 'needs_input' | 'plan_ready' + +/** + * Pure stateful classifier for the CCR event stream. Ingests SDKMessage[] + * batches (as delivered by pollRemoteSessionEvents) and returns the current + * ExitPlanMode verdict. No I/O, no timers — feed it synthetic or recorded + * events for unit tests and offline replay. + * + * Precedence (approved > terminated > rejected > pending > unchanged): + * pollRemoteSessionEvents paginates up to 50 pages per call, so one ingest + * can span seconds of session activity. A batch may contain both an approved + * tool_result AND a subsequent {type:'result'} (user approved, then remote + * crashed). The approved plan is real and in threadstore — don't drop it. + */ +export class ExitPlanModeScanner { + private exitPlanCalls: string[] = [] + private results = new Map() + private rejectedIds = new Set() + private terminated: { subtype: string } | null = null + private rescanAfterRejection = false + everSeenPending = false + + get rejectCount(): number { + return this.rejectedIds.size + } + + /** + * True when an ExitPlanMode tool_use exists with no tool_result yet — + * the remote is showing the approval dialog in the browser. + */ + get hasPendingPlan(): boolean { + const id = this.exitPlanCalls.findLast(c => !this.rejectedIds.has(c)) + return id !== undefined && !this.results.has(id) + } + + ingest(newEvents: SDKMessage[]): ScanResult { + for (const m of newEvents) { + if (m.type === 'assistant') { + for (const block of m.message.content) { + if (block.type !== 'tool_use') continue + const tu = block as ToolUseBlock + if (tu.name === EXIT_PLAN_MODE_V2_TOOL_NAME) { + this.exitPlanCalls.push(tu.id) + } + } + } else if (m.type === 'user') { + const content = m.message.content + if (!Array.isArray(content)) continue + for (const block of content) { + if (block.type === 'tool_result') { + this.results.set(block.tool_use_id, block) + } + } + } else if (m.type === 'result' && m.subtype !== 'success') { + // result(success) fires after EVERY CCR turn + // If the remote asks a clarifying question (turn ends without + // ExitPlanMode), we must keep polling — the user can reply in + // the browser and reach ExitPlanMode in a later turn. + // Only error subtypes (error_during_execution, error_max_turns, + // etc.) mean the session is actually dead. + this.terminated = { subtype: m.subtype } + } + } + + // Skip-scan when nothing could have moved the target: no new events, no + // rejection last tick. A rejection moves the newest-non-rejected target. + const shouldScan = newEvents.length > 0 || this.rescanAfterRejection + this.rescanAfterRejection = false + + let found: + | { kind: 'approved'; plan: string } + | { kind: 'teleport'; plan: string } + | { kind: 'rejected'; id: string } + | { kind: 'pending' } + | null = null + if (shouldScan) { + for (let i = this.exitPlanCalls.length - 1; i >= 0; i--) { + const id = this.exitPlanCalls[i]! + if (this.rejectedIds.has(id)) continue + const tr = this.results.get(id) + if (!tr) { + found = { kind: 'pending' } + } else if (tr.is_error === true) { + const teleportPlan = extractTeleportPlan(tr.content) + found = + teleportPlan !== null + ? { kind: 'teleport', plan: teleportPlan } + : { kind: 'rejected', id } + } else { + found = { kind: 'approved', plan: extractApprovedPlan(tr.content) } + } + break + } + if (found?.kind === 'approved' || found?.kind === 'teleport') return found + } + + // Bookkeeping before the terminated check — a batch can contain BOTH a + // rejected tool_result and a {type:'result'}; rejectCount must reflect + // the rejection even though terminated takes return precedence. + if (found?.kind === 'rejected') { + this.rejectedIds.add(found.id) + this.rescanAfterRejection = true + } + if (this.terminated) { + return { kind: 'terminated', subtype: this.terminated.subtype } + } + if (found?.kind === 'rejected') { + return found + } + if (found?.kind === 'pending') { + this.everSeenPending = true + return found + } + return { kind: 'unchanged' } + } +} + +export type PollResult = { + plan: string + rejectCount: number + /** 'local' = user clicked teleport (execute here, archive remote). 'remote' = user approved in-CCR execution (don't archive). */ + executionTarget: 'local' | 'remote' +} + +// Returns the approved plan text and where the user wants it executed. +// 'approved' scrapes from the "## Approved Plan:" marker (ExitPlanModeV2Tool +// default branch) — the model writes plan to a file inside CCR and calls +// ExitPlanMode({allowedPrompts}), so input.plan is never in threadstore. +// 'teleport' scrapes from the ULTRAPLAN_TELEPORT_SENTINEL in a deny tool_result — +// browser sends a rejection so the remote stays in plan mode, with the plan +// text embedded in the feedback. Normal rejections (is_error === true, no +// sentinel) are tracked and skipped so the user can iterate in the browser. +export async function pollForApprovedExitPlanMode( + sessionId: string, + timeoutMs: number, + onPhaseChange?: (phase: UltraplanPhase) => void, + shouldStop?: () => boolean, +): Promise { + const deadline = Date.now() + timeoutMs + const scanner = new ExitPlanModeScanner() + let cursor: string | null = null + let failures = 0 + let lastPhase: UltraplanPhase = 'running' + + while (Date.now() < deadline) { + if (shouldStop?.()) { + throw new UltraplanPollError( + 'poll stopped by caller', + 'stopped', + scanner.rejectCount, + ) + } + let newEvents: SDKMessage[] + let sessionStatus: PollRemoteSessionResponse['sessionStatus'] + try { + // Metadata fetch (session_status) is the needs_input signal — + // threadstore doesn't persist result(success) turn-end events, so + // idle status is the only authoritative "remote is waiting" marker. + const resp = await pollRemoteSessionEvents(sessionId, cursor) + newEvents = resp.newEvents + cursor = resp.lastEventId + sessionStatus = resp.sessionStatus + failures = 0 + } catch (e) { + const transient = isTransientNetworkError(e) + if (!transient || ++failures >= MAX_CONSECUTIVE_FAILURES) { + throw new UltraplanPollError( + e instanceof Error ? e.message : String(e), + 'network_or_unknown', + scanner.rejectCount, + { cause: e }, + ) + } + await sleep(POLL_INTERVAL_MS) + continue + } + + let result: ScanResult + try { + result = scanner.ingest(newEvents) + } catch (e) { + throw new UltraplanPollError( + e instanceof Error ? e.message : String(e), + 'extract_marker_missing', + scanner.rejectCount, + ) + } + if (result.kind === 'approved') { + return { + plan: result.plan, + rejectCount: scanner.rejectCount, + executionTarget: 'remote', + } + } + if (result.kind === 'teleport') { + return { + plan: result.plan, + rejectCount: scanner.rejectCount, + executionTarget: 'local', + } + } + if (result.kind === 'terminated') { + throw new UltraplanPollError( + `remote session ended (${result.subtype}) before plan approval`, + 'terminated', + scanner.rejectCount, + ) + } + // plan_ready from the event stream wins; otherwise idle session status + // means the remote asked a question and is waiting for a browser reply. + // requires_action with no pending plan is also needs_input — the remote + // may be blocked on a non-ExitPlanMode permission prompt. + // CCR briefly flips to 'idle' between tool turns (see STABLE_IDLE_POLLS + // in RemoteAgentTask). Only trust idle when no new events arrived — + // events flowing means the session is working regardless of the status + // snapshot. This also makes needs_input → running snap back on the first + // poll that sees the user's reply event, even if session_status lags. + const quietIdle = + (sessionStatus === 'idle' || sessionStatus === 'requires_action') && + newEvents.length === 0 + const phase: UltraplanPhase = scanner.hasPendingPlan + ? 'plan_ready' + : quietIdle + ? 'needs_input' + : 'running' + if (phase !== lastPhase) { + logForDebugging(`[ultraplan] phase ${lastPhase} → ${phase}`) + lastPhase = phase + onPhaseChange?.(phase) + } + await sleep(POLL_INTERVAL_MS) + } + + throw new UltraplanPollError( + scanner.everSeenPending + ? `no approval after ${timeoutMs / 1000}s` + : `ExitPlanMode never reached after ${timeoutMs / 1000}s (the remote container failed to start, or session ID mismatch?)`, + scanner.everSeenPending ? 'timeout_pending' : 'timeout_no_plan', + scanner.rejectCount, + ) +} + +// tool_result content may be string or [{type:'text',text}] depending on +// threadstore encoding. +function contentToText(content: ToolResultBlockParam['content']): string { + return typeof content === 'string' + ? content + : Array.isArray(content) + ? content.map(b => ('text' in b ? b.text : '')).join('') + : '' +} + +// Extracts the plan text after the ULTRAPLAN_TELEPORT_SENTINEL marker. +// Returns null when the sentinel is absent — callers treat null as a normal +// user rejection (scanner falls through to { kind: 'rejected' }). +function extractTeleportPlan( + content: ToolResultBlockParam['content'], +): string | null { + const text = contentToText(content) + const marker = `${ULTRAPLAN_TELEPORT_SENTINEL}\n` + const idx = text.indexOf(marker) + if (idx === -1) return null + return text.slice(idx + marker.length).trimEnd() +} + +// Plan is echoed in tool_result content as "## Approved Plan:\n" or +// "## Approved Plan (edited by user):\n" (ExitPlanModeV2Tool). +function extractApprovedPlan(content: ToolResultBlockParam['content']): string { + const text = contentToText(content) + // Try both markers — edited plans use a different label. + const markers = [ + '## Approved Plan (edited by user):\n', + '## Approved Plan:\n', + ] + for (const marker of markers) { + const idx = text.indexOf(marker) + if (idx !== -1) { + return text.slice(idx + marker.length).trimEnd() + } + } + throw new Error( + `ExitPlanMode approved but tool_result has no "## Approved Plan:" marker — remote may have hit the empty-plan or isAgent branch. Content preview: ${text.slice(0, 200)}`, + ) +} diff --git a/src/utils/ultraplan/keyword.ts b/src/utils/ultraplan/keyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..5e56919addf20c611ff6b5316040397c853bcd6d --- /dev/null +++ b/src/utils/ultraplan/keyword.ts @@ -0,0 +1,127 @@ +type TriggerPosition = { word: string; start: number; end: number } + +const OPEN_TO_CLOSE: Record = { + '`': '`', + '"': '"', + '<': '>', + '{': '}', + '[': ']', + '(': ')', + "'": "'", +} + +/** + * Find keyword positions, skipping occurrences that are clearly not a + * launch directive: + * + * - Inside paired delimiters: backticks, double quotes, angle brackets + * (tag-like only, so `n < 5 ultraplan n > 10` is not a phantom range), + * curly braces, square brackets (innermost — preExpansionInput has + * `[Pasted text #N]` placeholders), parentheses. Single quotes are + * delimiters only when not an apostrophe — the opening quote must be + * preceded by a non-word char (or start) and the closing quote must be + * followed by a non-word char (or end), so "let's ultraplan it's" + * still triggers. + * + * - Path/identifier-like context: immediately preceded or followed by + * `/`, `\`, or `-`, or followed by `.` + word char (file extension). + * `\b` sees a boundary at `-`, so `ultraplan-s` would otherwise + * match. This keeps `src/ultraplan/foo.ts`, `ultraplan.tsx`, and + * `--ultraplan-mode` from triggering while `ultraplan.` at a sentence + * end still does. + * + * - Followed by `?`: a question about the feature shouldn't invoke it. + * Other sentence punctuation (`.`, `,`, `!`) still triggers. + * + * - Slash command input: text starting with `/` is a slash command + * invocation (processUserInput.ts routes it to processSlashCommand, + * not keyword detection), so `/rename ultraplan foo` never triggers. + * Without this, PromptInput would rainbow-highlight the word and show + * the "will launch ultraplan" notification even though submitting the + * input runs /rename, not /ultraplan. + * + * Shape matches findThinkingTriggerPositions (thinking.ts) so + * PromptInput treats both trigger types uniformly. + */ +function findKeywordTriggerPositions( + text: string, + keyword: string, +): TriggerPosition[] { + const re = new RegExp(keyword, 'i') + if (!re.test(text)) return [] + if (text.startsWith('/')) return [] + const quotedRanges: Array<{ start: number; end: number }> = [] + let openQuote: string | null = null + let openAt = 0 + const isWord = (ch: string | undefined) => !!ch && /[\p{L}\p{N}_]/u.test(ch) + for (let i = 0; i < text.length; i++) { + const ch = text[i]! + if (openQuote) { + if (openQuote === '[' && ch === '[') { + openAt = i + continue + } + if (ch !== OPEN_TO_CLOSE[openQuote]) continue + if (openQuote === "'" && isWord(text[i + 1])) continue + quotedRanges.push({ start: openAt, end: i + 1 }) + openQuote = null + } else if ( + (ch === '<' && i + 1 < text.length && /[a-zA-Z/]/.test(text[i + 1]!)) || + (ch === "'" && !isWord(text[i - 1])) || + (ch !== '<' && ch !== "'" && ch in OPEN_TO_CLOSE) + ) { + openQuote = ch + openAt = i + } + } + + const positions: TriggerPosition[] = [] + const wordRe = new RegExp(`\\b${keyword}\\b`, 'gi') + const matches = text.matchAll(wordRe) + for (const match of matches) { + if (match.index === undefined) continue + const start = match.index + const end = start + match[0].length + if (quotedRanges.some(r => start >= r.start && start < r.end)) continue + const before = text[start - 1] + const after = text[end] + if (before === '/' || before === '\\' || before === '-') continue + if (after === '/' || after === '\\' || after === '-' || after === '?') + continue + if (after === '.' && isWord(text[end + 1])) continue + positions.push({ word: match[0], start, end }) + } + return positions +} + +export function findUltraplanTriggerPositions(text: string): TriggerPosition[] { + return findKeywordTriggerPositions(text, 'ultraplan') +} + +export function findUltrareviewTriggerPositions( + text: string, +): TriggerPosition[] { + return findKeywordTriggerPositions(text, 'ultrareview') +} + +export function hasUltraplanKeyword(text: string): boolean { + return findUltraplanTriggerPositions(text).length > 0 +} + +export function hasUltrareviewKeyword(text: string): boolean { + return findUltrareviewTriggerPositions(text).length > 0 +} + +/** + * Replace the first triggerable "ultraplan" with "plan" so the forwarded + * prompt stays grammatical ("please ultraplan this" → "please plan this"). + * Preserves the user's casing of the "plan" suffix. + */ +export function replaceUltraplanKeyword(text: string): string { + const [trigger] = findUltraplanTriggerPositions(text) + if (!trigger) return text + const before = text.slice(0, trigger.start) + const after = text.slice(trigger.end) + if (!(before + after).trim()) return '' + return before + trigger.word.slice('ultra'.length) + after +}