diff --git a/src/components/DevBar.tsx b/src/components/DevBar.tsx new file mode 100644 index 0000000000000000000000000000000000000000..fd4c5ea145075052237a05a2014592bbb8d080e5 --- /dev/null +++ b/src/components/DevBar.tsx @@ -0,0 +1,49 @@ +import { c as _c } from "react/compiler-runtime"; +import * as React from 'react'; +import { useState } from 'react'; +import { getSlowOperations } from '../bootstrap/state.js'; +import { Text, useInterval } from '../ink.js'; + +// Show DevBar for dev builds or all ants +function shouldShowDevBar(): boolean { + return "production" === 'development' || "external" === 'ant'; +} +export function DevBar() { + const $ = _c(5); + const [slowOps, setSlowOps] = useState(getSlowOperations); + let t0; + if ($[0] === Symbol.for("react.memo_cache_sentinel")) { + t0 = () => { + setSlowOps(getSlowOperations()); + }; + $[0] = t0; + } else { + t0 = $[0]; + } + useInterval(t0, shouldShowDevBar() ? 500 : null); + if (!shouldShowDevBar() || slowOps.length === 0) { + return null; + } + let t1; + if ($[1] !== slowOps) { + t1 = slowOps.slice(-3).map(_temp).join(" \xB7 "); + $[1] = slowOps; + $[2] = t1; + } else { + t1 = $[2]; + } + const recentOps = t1; + let t2; + if ($[3] !== recentOps) { + t2 = [ANT-ONLY] slow sync: {recentOps}; + $[3] = recentOps; + $[4] = t2; + } else { + t2 = $[4]; + } + return t2; +} +function _temp(op) { + return `${op.operation} (${Math.round(op.durationMs)}ms)`; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/src/components/TaskListV2.tsx b/src/components/TaskListV2.tsx new file mode 100644 index 0000000000000000000000000000000000000000..addc083d1506c084c29896c8cf1bcca29f2c4fcc --- /dev/null +++ b/src/components/TaskListV2.tsx @@ -0,0 +1,378 @@ +import { c as _c } from "react/compiler-runtime"; +import figures from 'figures'; +import * as React from 'react'; +import { useTerminalSize } from '../hooks/useTerminalSize.js'; +import { stringWidth } from '../ink/stringWidth.js'; +import { Box, Text } from '../ink.js'; +import { useAppState } from '../state/AppState.js'; +import { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js'; +import { AGENT_COLOR_TO_THEME_COLOR, type AgentColorName } from '../tools/AgentTool/agentColorManager.js'; +import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js'; +import { count } from '../utils/array.js'; +import { summarizeRecentActivities } from '../utils/collapseReadSearch.js'; +import { truncateToWidth } from '../utils/format.js'; +import { isTodoV2Enabled, type Task } from '../utils/tasks.js'; +import type { Theme } from '../utils/theme.js'; +import ThemedText from './design-system/ThemedText.js'; +type Props = { + tasks: Task[]; + isStandalone?: boolean; +}; +const RECENT_COMPLETED_TTL_MS = 30_000; +function byIdAsc(a: Task, b: Task): number { + const aNum = parseInt(a.id, 10); + const bNum = parseInt(b.id, 10); + if (!isNaN(aNum) && !isNaN(bNum)) { + return aNum - bNum; + } + return a.id.localeCompare(b.id); +} +export function TaskListV2({ + tasks, + isStandalone = false +}: Props): React.ReactNode { + const teamContext = useAppState(s => s.teamContext); + const appStateTasks = useAppState(s_0 => s_0.tasks); + const [, forceUpdate] = React.useState(0); + const { + rows, + columns + } = useTerminalSize(); + + // Track when each task was last observed transitioning to completed + const completionTimestampsRef = React.useRef(new Map()); + const previousCompletedIdsRef = React.useRef | null>(null); + if (previousCompletedIdsRef.current === null) { + previousCompletedIdsRef.current = new Set(tasks.filter(t => t.status === 'completed').map(t_0 => t_0.id)); + } + const maxDisplay = rows <= 10 ? 0 : Math.min(10, Math.max(3, rows - 14)); + + // Update completion timestamps: reset when a task transitions to completed + const currentCompletedIds = new Set(tasks.filter(t_1 => t_1.status === 'completed').map(t_2 => t_2.id)); + const now = Date.now(); + for (const id of currentCompletedIds) { + if (!previousCompletedIdsRef.current.has(id)) { + completionTimestampsRef.current.set(id, now); + } + } + for (const id_0 of completionTimestampsRef.current.keys()) { + if (!currentCompletedIds.has(id_0)) { + completionTimestampsRef.current.delete(id_0); + } + } + previousCompletedIdsRef.current = currentCompletedIds; + + // Schedule re-render when the next recent completion expires. + // Depend on `tasks` so the timer is only reset when the task list changes, + // not on every render (which was causing unnecessary work). + React.useEffect(() => { + if (completionTimestampsRef.current.size === 0) { + return; + } + const currentNow = Date.now(); + let earliestExpiry = Infinity; + for (const ts of completionTimestampsRef.current.values()) { + const expiry = ts + RECENT_COMPLETED_TTL_MS; + if (expiry > currentNow && expiry < earliestExpiry) { + earliestExpiry = expiry; + } + } + if (earliestExpiry === Infinity) { + return; + } + const timer = setTimeout(forceUpdate_0 => forceUpdate_0((n: number) => n + 1), earliestExpiry - currentNow, forceUpdate); + return () => clearTimeout(timer); + }, [tasks]); + if (!isTodoV2Enabled()) { + return null; + } + if (tasks.length === 0) { + return null; + } + + // Build a map of teammate name -> theme color + const teammateColors: Record = {}; + if (isAgentSwarmsEnabled() && teamContext?.teammates) { + for (const teammate of Object.values(teamContext.teammates)) { + if (teammate.color) { + const themeColor = AGENT_COLOR_TO_THEME_COLOR[teammate.color as AgentColorName]; + if (themeColor) { + teammateColors[teammate.name] = themeColor; + } + } + } + } + + // Build a map of teammate name -> current activity description + // Map both agentName ("researcher") and agentId ("researcher@team") so + // task owners match regardless of which format the model used. + // Rolls up consecutive search/read tool uses into a compact summary. + // Also track which teammates are still running (not shut down). + const teammateActivity: Record = {}; + const activeTeammates = new Set(); + if (isAgentSwarmsEnabled()) { + for (const bgTask of Object.values(appStateTasks)) { + if (isInProcessTeammateTask(bgTask) && bgTask.status === 'running') { + activeTeammates.add(bgTask.identity.agentName); + activeTeammates.add(bgTask.identity.agentId); + const activities = bgTask.progress?.recentActivities; + const desc = (activities && summarizeRecentActivities(activities)) ?? bgTask.progress?.lastActivity?.activityDescription; + if (desc) { + teammateActivity[bgTask.identity.agentName] = desc; + teammateActivity[bgTask.identity.agentId] = desc; + } + } + } + } + + // Get task counts for display + const completedCount = count(tasks, t_3 => t_3.status === 'completed'); + const pendingCount = count(tasks, t_4 => t_4.status === 'pending'); + const inProgressCount = tasks.length - completedCount - pendingCount; + // Unresolved tasks (open or in_progress) block dependent tasks + const unresolvedTaskIds = new Set(tasks.filter(t_5 => t_5.status !== 'completed').map(t_6 => t_6.id)); + + // Check if we need to truncate + const needsTruncation = tasks.length > maxDisplay; + let visibleTasks: Task[]; + let hiddenTasks: Task[]; + if (needsTruncation) { + // Prioritize: recently completed (within 30s), in-progress, pending, older completed + const recentCompleted: Task[] = []; + const olderCompleted: Task[] = []; + for (const task of tasks.filter(t_7 => t_7.status === 'completed')) { + const ts_0 = completionTimestampsRef.current.get(task.id); + if (ts_0 && now - ts_0 < RECENT_COMPLETED_TTL_MS) { + recentCompleted.push(task); + } else { + olderCompleted.push(task); + } + } + recentCompleted.sort(byIdAsc); + olderCompleted.sort(byIdAsc); + const inProgress = tasks.filter(t_8 => t_8.status === 'in_progress').sort(byIdAsc); + const pending = tasks.filter(t_9 => t_9.status === 'pending').sort((a, b) => { + const aBlocked = a.blockedBy.some(id_1 => unresolvedTaskIds.has(id_1)); + const bBlocked = b.blockedBy.some(id_2 => unresolvedTaskIds.has(id_2)); + if (aBlocked !== bBlocked) { + return aBlocked ? 1 : -1; + } + return byIdAsc(a, b); + }); + const prioritized = [...recentCompleted, ...inProgress, ...pending, ...olderCompleted]; + visibleTasks = prioritized.slice(0, maxDisplay); + hiddenTasks = prioritized.slice(maxDisplay); + } else { + // No truncation needed — sort by ID for stable ordering + visibleTasks = [...tasks].sort(byIdAsc); + hiddenTasks = []; + } + let hiddenSummary = ''; + if (hiddenTasks.length > 0) { + const parts: string[] = []; + const hiddenPending = count(hiddenTasks, t_10 => t_10.status === 'pending'); + const hiddenInProgress = count(hiddenTasks, t_11 => t_11.status === 'in_progress'); + const hiddenCompleted = count(hiddenTasks, t_12 => t_12.status === 'completed'); + if (hiddenInProgress > 0) { + parts.push(`${hiddenInProgress} in progress`); + } + if (hiddenPending > 0) { + parts.push(`${hiddenPending} pending`); + } + if (hiddenCompleted > 0) { + parts.push(`${hiddenCompleted} completed`); + } + hiddenSummary = ` … +${parts.join(', ')}`; + } + const content = <> + {visibleTasks.map(task_0 => unresolvedTaskIds.has(id_3))} activity={task_0.owner ? teammateActivity[task_0.owner] : undefined} ownerActive={task_0.owner ? activeTeammates.has(task_0.owner) : false} columns={columns} />)} + {maxDisplay > 0 && hiddenSummary && {hiddenSummary}} + ; + if (isStandalone) { + return + + + {tasks.length} + {' tasks ('} + {completedCount} + {' done, '} + {inProgressCount > 0 && <> + {inProgressCount} + {' in progress, '} + } + {pendingCount} + {' open)'} + + + {content} + ; + } + return {content}; +} +type TaskItemProps = { + task: Task; + ownerColor?: keyof Theme; + openBlockers: string[]; + activity?: string; + ownerActive: boolean; + columns: number; +}; +function getTaskIcon(status: Task['status']): { + icon: string; + color: keyof Theme | undefined; +} { + switch (status) { + case 'completed': + return { + icon: figures.tick, + color: 'success' + }; + case 'in_progress': + return { + icon: figures.squareSmallFilled, + color: 'claude' + }; + case 'pending': + return { + icon: figures.squareSmall, + color: undefined + }; + } +} +function TaskItem(t0) { + const $ = _c(37); + const { + task, + ownerColor, + openBlockers, + activity, + ownerActive, + columns + } = t0; + const isCompleted = task.status === "completed"; + const isInProgress = task.status === "in_progress"; + const isBlocked = openBlockers.length > 0; + let t1; + if ($[0] !== task.status) { + t1 = getTaskIcon(task.status); + $[0] = task.status; + $[1] = t1; + } else { + t1 = $[1]; + } + const { + icon, + color + } = t1; + const showActivity = isInProgress && !isBlocked && activity; + const showOwner = columns >= 60 && task.owner && ownerActive; + let t2; + if ($[2] !== showOwner || $[3] !== task.owner) { + t2 = showOwner ? stringWidth(` (@${task.owner})`) : 0; + $[2] = showOwner; + $[3] = task.owner; + $[4] = t2; + } else { + t2 = $[4]; + } + const ownerWidth = t2; + const maxSubjectWidth = Math.max(15, columns - 15 - ownerWidth); + let t3; + if ($[5] !== maxSubjectWidth || $[6] !== task.subject) { + t3 = truncateToWidth(task.subject, maxSubjectWidth); + $[5] = maxSubjectWidth; + $[6] = task.subject; + $[7] = t3; + } else { + t3 = $[7]; + } + const displaySubject = t3; + const maxActivityWidth = Math.max(15, columns - 15); + let t4; + if ($[8] !== activity || $[9] !== maxActivityWidth) { + t4 = activity ? truncateToWidth(activity, maxActivityWidth) : undefined; + $[8] = activity; + $[9] = maxActivityWidth; + $[10] = t4; + } else { + t4 = $[10]; + } + const displayActivity = t4; + let t5; + if ($[11] !== color || $[12] !== icon) { + t5 = {icon} ; + $[11] = color; + $[12] = icon; + $[13] = t5; + } else { + t5 = $[13]; + } + const t6 = isCompleted || isBlocked; + let t7; + if ($[14] !== displaySubject || $[15] !== isCompleted || $[16] !== isInProgress || $[17] !== t6) { + t7 = {displaySubject}; + $[14] = displaySubject; + $[15] = isCompleted; + $[16] = isInProgress; + $[17] = t6; + $[18] = t7; + } else { + t7 = $[18]; + } + let t8; + if ($[19] !== ownerColor || $[20] !== showOwner || $[21] !== task.owner) { + t8 = showOwner && {" ("}{ownerColor ? @{task.owner} : `@${task.owner}`}{")"}; + $[19] = ownerColor; + $[20] = showOwner; + $[21] = task.owner; + $[22] = t8; + } else { + t8 = $[22]; + } + let t9; + if ($[23] !== isBlocked || $[24] !== openBlockers) { + t9 = isBlocked && {" "}{figures.pointerSmall} blocked by{" "}{[...openBlockers].sort(_temp).map(_temp2).join(", ")}; + $[23] = isBlocked; + $[24] = openBlockers; + $[25] = t9; + } else { + t9 = $[25]; + } + let t10; + if ($[26] !== t5 || $[27] !== t7 || $[28] !== t8 || $[29] !== t9) { + t10 = {t5}{t7}{t8}{t9}; + $[26] = t5; + $[27] = t7; + $[28] = t8; + $[29] = t9; + $[30] = t10; + } else { + t10 = $[30]; + } + let t11; + if ($[31] !== displayActivity || $[32] !== showActivity) { + t11 = showActivity && displayActivity && {" "}{displayActivity}{figures.ellipsis}; + $[31] = displayActivity; + $[32] = showActivity; + $[33] = t11; + } else { + t11 = $[33]; + } + let t12; + if ($[34] !== t10 || $[35] !== t11) { + t12 = {t10}{t11}; + $[34] = t10; + $[35] = t11; + $[36] = t12; + } else { + t12 = $[36]; + } + return t12; +} +function _temp2(id) { + return `#${id}`; +} +function _temp(a, b) { + return parseInt(a, 10) - parseInt(b, 10); +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useTerminalSize","stringWidth","Box","Text","useAppState","isInProcessTeammateTask","AGENT_COLOR_TO_THEME_COLOR","AgentColorName","isAgentSwarmsEnabled","count","summarizeRecentActivities","truncateToWidth","isTodoV2Enabled","Task","Theme","ThemedText","Props","tasks","isStandalone","RECENT_COMPLETED_TTL_MS","byIdAsc","a","b","aNum","parseInt","id","bNum","isNaN","localeCompare","TaskListV2","ReactNode","teamContext","s","appStateTasks","forceUpdate","useState","rows","columns","completionTimestampsRef","useRef","Map","previousCompletedIdsRef","Set","current","filter","t","status","map","maxDisplay","Math","min","max","currentCompletedIds","now","Date","has","set","keys","delete","useEffect","size","currentNow","earliestExpiry","Infinity","ts","values","expiry","timer","setTimeout","n","clearTimeout","length","teammateColors","Record","teammates","teammate","Object","color","themeColor","name","teammateActivity","activeTeammates","bgTask","add","identity","agentName","agentId","activities","progress","recentActivities","desc","lastActivity","activityDescription","completedCount","pendingCount","inProgressCount","unresolvedTaskIds","needsTruncation","visibleTasks","hiddenTasks","recentCompleted","olderCompleted","task","get","push","sort","inProgress","pending","aBlocked","blockedBy","some","bBlocked","prioritized","slice","hiddenSummary","parts","hiddenPending","hiddenInProgress","hiddenCompleted","join","content","owner","undefined","TaskItemProps","ownerColor","openBlockers","activity","ownerActive","getTaskIcon","icon","tick","squareSmallFilled","squareSmall","TaskItem","t0","$","_c","isCompleted","isInProgress","isBlocked","t1","showActivity","showOwner","t2","ownerWidth","maxSubjectWidth","t3","subject","displaySubject","maxActivityWidth","t4","displayActivity","t5","t6","t7","t8","t9","pointerSmall","_temp","_temp2","t10","t11","ellipsis","t12"],"sources":["TaskListV2.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { stringWidth } from '../ink/stringWidth.js'\nimport { Box, Text } from '../ink.js'\nimport { useAppState } from '../state/AppState.js'\nimport { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js'\nimport {\n  AGENT_COLOR_TO_THEME_COLOR,\n  type AgentColorName,\n} from '../tools/AgentTool/agentColorManager.js'\nimport { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js'\nimport { count } from '../utils/array.js'\nimport { summarizeRecentActivities } from '../utils/collapseReadSearch.js'\nimport { truncateToWidth } from '../utils/format.js'\nimport { isTodoV2Enabled, type Task } from '../utils/tasks.js'\nimport type { Theme } from '../utils/theme.js'\nimport ThemedText from './design-system/ThemedText.js'\n\ntype Props = {\n  tasks: Task[]\n  isStandalone?: boolean\n}\n\nconst RECENT_COMPLETED_TTL_MS = 30_000\n\nfunction byIdAsc(a: Task, b: Task): number {\n  const aNum = parseInt(a.id, 10)\n  const bNum = parseInt(b.id, 10)\n  if (!isNaN(aNum) && !isNaN(bNum)) {\n    return aNum - bNum\n  }\n  return a.id.localeCompare(b.id)\n}\n\nexport function TaskListV2({\n  tasks,\n  isStandalone = false,\n}: Props): React.ReactNode {\n  const teamContext = useAppState(s => s.teamContext)\n  const appStateTasks = useAppState(s => s.tasks)\n  const [, forceUpdate] = React.useState(0)\n  const { rows, columns } = useTerminalSize()\n\n  // Track when each task was last observed transitioning to completed\n  const completionTimestampsRef = React.useRef(new Map<string, number>())\n  const previousCompletedIdsRef = React.useRef<Set<string> | null>(null)\n  if (previousCompletedIdsRef.current === null) {\n    previousCompletedIdsRef.current = new Set(\n      tasks.filter(t => t.status === 'completed').map(t => t.id),\n    )\n  }\n  const maxDisplay = rows <= 10 ? 0 : Math.min(10, Math.max(3, rows - 14))\n\n  // Update completion timestamps: reset when a task transitions to completed\n  const currentCompletedIds = new Set(\n    tasks.filter(t => t.status === 'completed').map(t => t.id),\n  )\n  const now = Date.now()\n  for (const id of currentCompletedIds) {\n    if (!previousCompletedIdsRef.current.has(id)) {\n      completionTimestampsRef.current.set(id, now)\n    }\n  }\n  for (const id of completionTimestampsRef.current.keys()) {\n    if (!currentCompletedIds.has(id)) {\n      completionTimestampsRef.current.delete(id)\n    }\n  }\n  previousCompletedIdsRef.current = currentCompletedIds\n\n  // Schedule re-render when the next recent completion expires.\n  // Depend on `tasks` so the timer is only reset when the task list changes,\n  // not on every render (which was causing unnecessary work).\n  React.useEffect(() => {\n    if (completionTimestampsRef.current.size === 0) {\n      return\n    }\n    const currentNow = Date.now()\n    let earliestExpiry = Infinity\n    for (const ts of completionTimestampsRef.current.values()) {\n      const expiry = ts + RECENT_COMPLETED_TTL_MS\n      if (expiry > currentNow && expiry < earliestExpiry) {\n        earliestExpiry = expiry\n      }\n    }\n    if (earliestExpiry === Infinity) {\n      return\n    }\n    const timer = setTimeout(\n      forceUpdate => forceUpdate((n: number) => n + 1),\n      earliestExpiry - currentNow,\n      forceUpdate,\n    )\n    return () => clearTimeout(timer)\n  }, [tasks])\n\n  if (!isTodoV2Enabled()) {\n    return null\n  }\n\n  if (tasks.length === 0) {\n    return null\n  }\n\n  // Build a map of teammate name -> theme color\n  const teammateColors: Record<string, keyof Theme> = {}\n  if (isAgentSwarmsEnabled() && teamContext?.teammates) {\n    for (const teammate of Object.values(teamContext.teammates)) {\n      if (teammate.color) {\n        const themeColor =\n          AGENT_COLOR_TO_THEME_COLOR[teammate.color as AgentColorName]\n        if (themeColor) {\n          teammateColors[teammate.name] = themeColor\n        }\n      }\n    }\n  }\n\n  // Build a map of teammate name -> current activity description\n  // Map both agentName (\"researcher\") and agentId (\"researcher@team\") so\n  // task owners match regardless of which format the model used.\n  // Rolls up consecutive search/read tool uses into a compact summary.\n  // Also track which teammates are still running (not shut down).\n  const teammateActivity: Record<string, string> = {}\n  const activeTeammates = new Set<string>()\n  if (isAgentSwarmsEnabled()) {\n    for (const bgTask of Object.values(appStateTasks)) {\n      if (isInProcessTeammateTask(bgTask) && bgTask.status === 'running') {\n        activeTeammates.add(bgTask.identity.agentName)\n        activeTeammates.add(bgTask.identity.agentId)\n        const activities = bgTask.progress?.recentActivities\n        const desc =\n          (activities && summarizeRecentActivities(activities)) ??\n          bgTask.progress?.lastActivity?.activityDescription\n        if (desc) {\n          teammateActivity[bgTask.identity.agentName] = desc\n          teammateActivity[bgTask.identity.agentId] = desc\n        }\n      }\n    }\n  }\n\n  // Get task counts for display\n  const completedCount = count(tasks, t => t.status === 'completed')\n  const pendingCount = count(tasks, t => t.status === 'pending')\n  const inProgressCount = tasks.length - completedCount - pendingCount\n  // Unresolved tasks (open or in_progress) block dependent tasks\n  const unresolvedTaskIds = new Set(\n    tasks.filter(t => t.status !== 'completed').map(t => t.id),\n  )\n\n  // Check if we need to truncate\n  const needsTruncation = tasks.length > maxDisplay\n\n  let visibleTasks: Task[]\n  let hiddenTasks: Task[]\n\n  if (needsTruncation) {\n    // Prioritize: recently completed (within 30s), in-progress, pending, older completed\n    const recentCompleted: Task[] = []\n    const olderCompleted: Task[] = []\n    for (const task of tasks.filter(t => t.status === 'completed')) {\n      const ts = completionTimestampsRef.current.get(task.id)\n      if (ts && now - ts < RECENT_COMPLETED_TTL_MS) {\n        recentCompleted.push(task)\n      } else {\n        olderCompleted.push(task)\n      }\n    }\n    recentCompleted.sort(byIdAsc)\n    olderCompleted.sort(byIdAsc)\n    const inProgress = tasks\n      .filter(t => t.status === 'in_progress')\n      .sort(byIdAsc)\n    const pending = tasks\n      .filter(t => t.status === 'pending')\n      .sort((a, b) => {\n        const aBlocked = a.blockedBy.some(id => unresolvedTaskIds.has(id))\n        const bBlocked = b.blockedBy.some(id => unresolvedTaskIds.has(id))\n        if (aBlocked !== bBlocked) {\n          return aBlocked ? 1 : -1\n        }\n        return byIdAsc(a, b)\n      })\n\n    const prioritized = [\n      ...recentCompleted,\n      ...inProgress,\n      ...pending,\n      ...olderCompleted,\n    ]\n    visibleTasks = prioritized.slice(0, maxDisplay)\n    hiddenTasks = prioritized.slice(maxDisplay)\n  } else {\n    // No truncation needed — sort by ID for stable ordering\n    visibleTasks = [...tasks].sort(byIdAsc)\n    hiddenTasks = []\n  }\n\n  let hiddenSummary = ''\n  if (hiddenTasks.length > 0) {\n    const parts: string[] = []\n    const hiddenPending = count(hiddenTasks, t => t.status === 'pending')\n    const hiddenInProgress = count(hiddenTasks, t => t.status === 'in_progress')\n    const hiddenCompleted = count(hiddenTasks, t => t.status === 'completed')\n    if (hiddenInProgress > 0) {\n      parts.push(`${hiddenInProgress} in progress`)\n    }\n    if (hiddenPending > 0) {\n      parts.push(`${hiddenPending} pending`)\n    }\n    if (hiddenCompleted > 0) {\n      parts.push(`${hiddenCompleted} completed`)\n    }\n    hiddenSummary = ` … +${parts.join(', ')}`\n  }\n\n  const content = (\n    <>\n      {visibleTasks.map(task => (\n        <TaskItem\n          key={task.id}\n          task={task}\n          ownerColor={task.owner ? teammateColors[task.owner] : undefined}\n          openBlockers={task.blockedBy.filter(id => unresolvedTaskIds.has(id))}\n          activity={task.owner ? teammateActivity[task.owner] : undefined}\n          ownerActive={task.owner ? activeTeammates.has(task.owner) : false}\n          columns={columns}\n        />\n      ))}\n      {maxDisplay > 0 && hiddenSummary && <Text dimColor>{hiddenSummary}</Text>}\n    </>\n  )\n\n  if (isStandalone) {\n    return (\n      <Box flexDirection=\"column\" marginTop={1} marginLeft={2}>\n        <Box>\n          <Text dimColor>\n            <Text bold>{tasks.length}</Text>\n            {' tasks ('}\n            <Text bold>{completedCount}</Text>\n            {' done, '}\n            {inProgressCount > 0 && (\n              <>\n                <Text bold>{inProgressCount}</Text>\n                {' in progress, '}\n              </>\n            )}\n            <Text bold>{pendingCount}</Text>\n            {' open)'}\n          </Text>\n        </Box>\n        {content}\n      </Box>\n    )\n  }\n\n  return <Box flexDirection=\"column\">{content}</Box>\n}\n\ntype TaskItemProps = {\n  task: Task\n  ownerColor?: keyof Theme\n  openBlockers: string[]\n  activity?: string\n  ownerActive: boolean\n  columns: number\n}\n\nfunction getTaskIcon(status: Task['status']): {\n  icon: string\n  color: keyof Theme | undefined\n} {\n  switch (status) {\n    case 'completed':\n      return { icon: figures.tick, color: 'success' }\n    case 'in_progress':\n      return { icon: figures.squareSmallFilled, color: 'claude' }\n    case 'pending':\n      return { icon: figures.squareSmall, color: undefined }\n  }\n}\n\nfunction TaskItem({\n  task,\n  ownerColor,\n  openBlockers,\n  activity,\n  ownerActive,\n  columns,\n}: TaskItemProps): React.ReactNode {\n  const isCompleted = task.status === 'completed'\n  const isInProgress = task.status === 'in_progress'\n  const isBlocked = openBlockers.length > 0\n\n  const { icon, color } = getTaskIcon(task.status)\n\n  const showActivity = isInProgress && !isBlocked && activity\n\n  // Responsive layout: hide owner on narrow screens (<60 cols)\n  // Truncate subject based on available space\n  const showOwner = columns >= 60 && task.owner && ownerActive\n  const ownerWidth = showOwner ? stringWidth(` (@${task.owner})`) : 0\n  // Account for: icon(2) + indentation(~8 when nested under spinner) + owner + safety\n  // Use columns - 15 as a conservative estimate for nested layouts\n  const maxSubjectWidth = Math.max(15, columns - 15 - ownerWidth)\n  const displaySubject = truncateToWidth(task.subject, maxSubjectWidth)\n\n  // Truncate activity for narrow screens\n  const maxActivityWidth = Math.max(15, columns - 15)\n  const displayActivity = activity\n    ? truncateToWidth(activity, maxActivityWidth)\n    : undefined\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box>\n        <Text color={color}>{icon} </Text>\n        <Text\n          bold={isInProgress}\n          strikethrough={isCompleted}\n          dimColor={isCompleted || isBlocked}\n        >\n          {displaySubject}\n        </Text>\n        {showOwner && (\n          <Text dimColor>\n            {' ('}\n            {ownerColor ? (\n              <ThemedText color={ownerColor}>@{task.owner}</ThemedText>\n            ) : (\n              `@${task.owner}`\n            )}\n            {')'}\n          </Text>\n        )}\n        {isBlocked && (\n          <Text dimColor>\n            {' '}\n            {figures.pointerSmall} blocked by{' '}\n            {[...openBlockers]\n              .sort((a, b) => parseInt(a, 10) - parseInt(b, 10))\n              .map(id => `#${id}`)\n              .join(', ')}\n          </Text>\n        )}\n      </Box>\n      {showActivity && displayActivity && (\n        <Box>\n          <Text dimColor>\n            {'  '}\n            {displayActivity}\n            {figures.ellipsis}\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/components/agents/new-agent-creation/wizard-steps/GenerateStep.tsx b/src/components/agents/new-agent-creation/wizard-steps/GenerateStep.tsx new file mode 100644 index 0000000000000000000000000000000000000000..d17ee6980d9bef3298ab6b3a8dd4d2d5489b88a8 --- /dev/null +++ b/src/components/agents/new-agent-creation/wizard-steps/GenerateStep.tsx @@ -0,0 +1,143 @@ +import { APIUserAbortError } from '@anthropic-ai/sdk'; +import React, { type ReactNode, useCallback, useRef, useState } from 'react'; +import { useMainLoopModel } from '../../../../hooks/useMainLoopModel.js'; +import { Box, Text } from '../../../../ink.js'; +import { useKeybinding } from '../../../../keybindings/useKeybinding.js'; +import { createAbortController } from '../../../../utils/abortController.js'; +import { editPromptInEditor } from '../../../../utils/promptEditor.js'; +import { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js'; +import { Byline } from '../../../design-system/Byline.js'; +import { Spinner } from '../../../Spinner.js'; +import TextInput from '../../../TextInput.js'; +import { useWizard } from '../../../wizard/index.js'; +import { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js'; +import { generateAgent } from '../../generateAgent.js'; +import type { AgentWizardData } from '../types.js'; +export function GenerateStep(): ReactNode { + const { + updateWizardData, + goBack, + goToStep, + wizardData + } = useWizard(); + const [prompt, setPrompt] = useState(wizardData.generationPrompt || ''); + const [isGenerating, setIsGenerating] = useState(false); + const [error, setError] = useState(null); + const [cursorOffset, setCursorOffset] = useState(prompt.length); + const model = useMainLoopModel(); + const abortControllerRef = useRef(null); + + // Cancel generation when escape pressed during generation + const handleCancelGeneration = useCallback(() => { + if (abortControllerRef.current) { + abortControllerRef.current.abort(); + abortControllerRef.current = null; + setIsGenerating(false); + setError('Generation cancelled'); + } + }, []); + + // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in prompt input) + useKeybinding('confirm:no', handleCancelGeneration, { + context: 'Settings', + isActive: isGenerating + }); + const handleExternalEditor = useCallback(async () => { + const result = await editPromptInEditor(prompt); + if (result.content !== null) { + setPrompt(result.content); + setCursorOffset(result.content.length); + } + }, [prompt]); + useKeybinding('chat:externalEditor', handleExternalEditor, { + context: 'Chat', + isActive: !isGenerating + }); + + // Go back when escape pressed while not generating + const handleGoBack = useCallback(() => { + updateWizardData({ + generationPrompt: '', + agentType: '', + systemPrompt: '', + whenToUse: '', + generatedAgent: undefined, + wasGenerated: false + }); + setPrompt(''); + setError(null); + goBack(); + }, [updateWizardData, goBack]); + + // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in prompt input) + useKeybinding('confirm:no', handleGoBack, { + context: 'Settings', + isActive: !isGenerating + }); + const handleGenerate = async (): Promise => { + const trimmedPrompt = prompt.trim(); + if (!trimmedPrompt) { + setError('Please describe what the agent should do'); + return; + } + setError(null); + setIsGenerating(true); + updateWizardData({ + generationPrompt: trimmedPrompt, + isGenerating: true + }); + + // Create abort controller for this generation + const controller = createAbortController(); + abortControllerRef.current = controller; + try { + const generated = await generateAgent(trimmedPrompt, model, [], controller.signal); + updateWizardData({ + agentType: generated.identifier, + whenToUse: generated.whenToUse, + systemPrompt: generated.systemPrompt, + generatedAgent: generated, + isGenerating: false, + wasGenerated: true + }); + + // Skip directly to ToolsStep (index 6) - matching original flow + goToStep(6); + } catch (err) { + // Don't show error if it was cancelled (already set in escape handler) + if (err instanceof APIUserAbortError) { + // User cancelled - no error to show + } else if (err instanceof Error && !err.message.includes('No assistant message found')) { + setError(err.message || 'Failed to generate agent'); + } + updateWizardData({ + isGenerating: false + }); + } finally { + setIsGenerating(false); + abortControllerRef.current = null; + } + }; + const subtitle = 'Describe what this agent should do and when it should be used (be comprehensive for best results)'; + if (isGenerating) { + return }> + + + Generating agent from description... + + ; + } + return + + + + }> + + {error && + {error} + } + + + ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["APIUserAbortError","React","ReactNode","useCallback","useRef","useState","useMainLoopModel","Box","Text","useKeybinding","createAbortController","editPromptInEditor","ConfigurableShortcutHint","Byline","Spinner","TextInput","useWizard","WizardDialogLayout","generateAgent","AgentWizardData","GenerateStep","updateWizardData","goBack","goToStep","wizardData","prompt","setPrompt","generationPrompt","isGenerating","setIsGenerating","error","setError","cursorOffset","setCursorOffset","length","model","abortControllerRef","AbortController","handleCancelGeneration","current","abort","context","isActive","handleExternalEditor","result","content","handleGoBack","agentType","systemPrompt","whenToUse","generatedAgent","undefined","wasGenerated","handleGenerate","Promise","trimmedPrompt","trim","controller","generated","signal","identifier","err","Error","message","includes","subtitle"],"sources":["GenerateStep.tsx"],"sourcesContent":["import { APIUserAbortError } from '@anthropic-ai/sdk'\nimport React, { type ReactNode, useCallback, useRef, useState } from 'react'\nimport { useMainLoopModel } from '../../../../hooks/useMainLoopModel.js'\nimport { Box, Text } from '../../../../ink.js'\nimport { useKeybinding } from '../../../../keybindings/useKeybinding.js'\nimport { createAbortController } from '../../../../utils/abortController.js'\nimport { editPromptInEditor } from '../../../../utils/promptEditor.js'\nimport { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js'\nimport { Byline } from '../../../design-system/Byline.js'\nimport { Spinner } from '../../../Spinner.js'\nimport TextInput from '../../../TextInput.js'\nimport { useWizard } from '../../../wizard/index.js'\nimport { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js'\nimport { generateAgent } from '../../generateAgent.js'\nimport type { AgentWizardData } from '../types.js'\n\nexport function GenerateStep(): ReactNode {\n  const { updateWizardData, goBack, goToStep, wizardData } =\n    useWizard<AgentWizardData>()\n  const [prompt, setPrompt] = useState(wizardData.generationPrompt || '')\n  const [isGenerating, setIsGenerating] = useState(false)\n  const [error, setError] = useState<string | null>(null)\n  const [cursorOffset, setCursorOffset] = useState(prompt.length)\n  const model = useMainLoopModel()\n  const abortControllerRef = useRef<AbortController | null>(null)\n\n  // Cancel generation when escape pressed during generation\n  const handleCancelGeneration = useCallback(() => {\n    if (abortControllerRef.current) {\n      abortControllerRef.current.abort()\n      abortControllerRef.current = null\n      setIsGenerating(false)\n      setError('Generation cancelled')\n    }\n  }, [])\n\n  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in prompt input)\n  useKeybinding('confirm:no', handleCancelGeneration, {\n    context: 'Settings',\n    isActive: isGenerating,\n  })\n\n  const handleExternalEditor = useCallback(async () => {\n    const result = await editPromptInEditor(prompt)\n    if (result.content !== null) {\n      setPrompt(result.content)\n      setCursorOffset(result.content.length)\n    }\n  }, [prompt])\n\n  useKeybinding('chat:externalEditor', handleExternalEditor, {\n    context: 'Chat',\n    isActive: !isGenerating,\n  })\n\n  // Go back when escape pressed while not generating\n  const handleGoBack = useCallback(() => {\n    updateWizardData({\n      generationPrompt: '',\n      agentType: '',\n      systemPrompt: '',\n      whenToUse: '',\n      generatedAgent: undefined,\n      wasGenerated: false,\n    })\n    setPrompt('')\n    setError(null)\n    goBack()\n  }, [updateWizardData, goBack])\n\n  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in prompt input)\n  useKeybinding('confirm:no', handleGoBack, {\n    context: 'Settings',\n    isActive: !isGenerating,\n  })\n\n  const handleGenerate = async (): Promise<void> => {\n    const trimmedPrompt = prompt.trim()\n    if (!trimmedPrompt) {\n      setError('Please describe what the agent should do')\n      return\n    }\n\n    setError(null)\n    setIsGenerating(true)\n    updateWizardData({\n      generationPrompt: trimmedPrompt,\n      isGenerating: true,\n    })\n\n    // Create abort controller for this generation\n    const controller = createAbortController()\n    abortControllerRef.current = controller\n\n    try {\n      const generated = await generateAgent(\n        trimmedPrompt,\n        model,\n        [],\n        controller.signal,\n      )\n\n      updateWizardData({\n        agentType: generated.identifier,\n        whenToUse: generated.whenToUse,\n        systemPrompt: generated.systemPrompt,\n        generatedAgent: generated,\n        isGenerating: false,\n        wasGenerated: true,\n      })\n\n      // Skip directly to ToolsStep (index 6) - matching original flow\n      goToStep(6)\n    } catch (err) {\n      // Don't show error if it was cancelled (already set in escape handler)\n      if (err instanceof APIUserAbortError) {\n        // User cancelled - no error to show\n      } else if (\n        err instanceof Error &&\n        !err.message.includes('No assistant message found')\n      ) {\n        setError(err.message || 'Failed to generate agent')\n      }\n      updateWizardData({ isGenerating: false })\n    } finally {\n      setIsGenerating(false)\n      abortControllerRef.current = null\n    }\n  }\n\n  const subtitle =\n    'Describe what this agent should do and when it should be used (be comprehensive for best results)'\n\n  if (isGenerating) {\n    return (\n      <WizardDialogLayout\n        subtitle={subtitle}\n        footerText={\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Settings\"\n            fallback=\"Esc\"\n            description=\"cancel\"\n          />\n        }\n      >\n        <Box flexDirection=\"row\" alignItems=\"center\">\n          <Spinner />\n          <Text color=\"suggestion\"> Generating agent from description...</Text>\n        </Box>\n      </WizardDialogLayout>\n    )\n  }\n\n  return (\n    <WizardDialogLayout\n      subtitle={subtitle}\n      footerText={\n        <Byline>\n          <ConfigurableShortcutHint\n            action=\"confirm:yes\"\n            context=\"Confirmation\"\n            fallback=\"Enter\"\n            description=\"submit\"\n          />\n          <ConfigurableShortcutHint\n            action=\"chat:externalEditor\"\n            context=\"Chat\"\n            fallback=\"ctrl+g\"\n            description=\"open in editor\"\n          />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Settings\"\n            fallback=\"Esc\"\n            description=\"go back\"\n          />\n        </Byline>\n      }\n    >\n      <Box flexDirection=\"column\">\n        {error && (\n          <Box marginBottom={1}>\n            <Text color=\"error\">{error}</Text>\n          </Box>\n        )}\n        <TextInput\n          value={prompt}\n          onChange={setPrompt}\n          onSubmit={handleGenerate}\n          placeholder=\"e.g., Help me write unit tests for my code...\"\n          columns={80}\n          cursorOffset={cursorOffset}\n          onChangeCursorOffset={setCursorOffset}\n          focus\n          showCursor\n        />\n      </Box>\n    </WizardDialogLayout>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/components/agents/new-agent-creation/wizard-steps/LocationStep.tsx b/src/components/agents/new-agent-creation/wizard-steps/LocationStep.tsx new file mode 100644 index 0000000000000000000000000000000000000000..d64c165665517461d2f6c6f41d4cda081f9a843c --- /dev/null +++ b/src/components/agents/new-agent-creation/wizard-steps/LocationStep.tsx @@ -0,0 +1,80 @@ +import { c as _c } from "react/compiler-runtime"; +import React, { type ReactNode } from 'react'; +import { Box } from '../../../../ink.js'; +import type { SettingSource } from '../../../../utils/settings/constants.js'; +import { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js'; +import { Select } from '../../../CustomSelect/select.js'; +import { Byline } from '../../../design-system/Byline.js'; +import { KeyboardShortcutHint } from '../../../design-system/KeyboardShortcutHint.js'; +import { useWizard } from '../../../wizard/index.js'; +import { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js'; +import type { AgentWizardData } from '../types.js'; +export function LocationStep() { + const $ = _c(11); + const { + goNext, + updateWizardData, + cancel + } = useWizard(); + let t0; + if ($[0] === Symbol.for("react.memo_cache_sentinel")) { + t0 = { + label: "Project (.claude/agents/)", + value: "projectSettings" as SettingSource + }; + $[0] = t0; + } else { + t0 = $[0]; + } + let t1; + if ($[1] === Symbol.for("react.memo_cache_sentinel")) { + t1 = [t0, { + label: "Personal (~/.claude/agents/)", + value: "userSettings" as SettingSource + }]; + $[1] = t1; + } else { + t1 = $[1]; + } + const locationOptions = t1; + let t2; + if ($[2] === Symbol.for("react.memo_cache_sentinel")) { + t2 = ; + $[2] = t2; + } else { + t2 = $[2]; + } + let t3; + if ($[3] !== goNext || $[4] !== updateWizardData) { + t3 = value => { + updateWizardData({ + location: value as SettingSource + }); + goNext(); + }; + $[3] = goNext; + $[4] = updateWizardData; + $[5] = t3; + } else { + t3 = $[5]; + } + let t4; + if ($[6] !== cancel) { + t4 = () => cancel(); + $[6] = cancel; + $[7] = t4; + } else { + t4 = $[7]; + } + let t5; + if ($[8] !== t3 || $[9] !== t4) { + t5 = ; + $[10] = onCancel; + $[11] = t2; + $[12] = t3; + $[13] = t4; + } else { + t4 = $[13]; + } + let t5; + if ($[14] !== hookEventMetadata.description || $[15] !== onCancel || $[16] !== t4 || $[17] !== title) { + t5 = {t4}; + $[14] = hookEventMetadata.description; + $[15] = onCancel; + $[16] = t4; + $[17] = title; + $[18] = t5; + } else { + t5 = $[18]; + } + return t5; +} +function _temp2(hook, index) { + return { + label: `[${hook.config.type}] ${getHookDisplayText(hook.config)}`, + value: index.toString(), + description: hook.source === "pluginHook" && hook.pluginName ? `${hookSourceHeaderDisplayString(hook.source)} (${hook.pluginName})` : hookSourceHeaderDisplayString(hook.source) + }; +} +function _temp() { + return Esc to go back; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","HookEvent","HookEventMetadata","Box","Text","getHookDisplayText","hookSourceHeaderDisplayString","IndividualHookConfig","Select","Dialog","Props","selectedEvent","selectedMatcher","hooksForSelectedMatcher","hookEventMetadata","onSelect","hook","onCancel","SelectHookMode","t0","$","_c","title","matcherMetadata","undefined","length","t1","Symbol","for","t2","description","_temp","map","_temp2","t3","value","index_0","parseInt","hook_0","index","t4","t5","label","config","type","toString","source","pluginName"],"sources":["SelectHookMode.tsx"],"sourcesContent":["/**\n * SelectHookMode shows all hooks configured for a given event+matcher pair.\n *\n * The /hooks menu is read-only: this view no longer offers \"add new hook\"\n * and selecting a hook shows its read-only details instead of a delete\n * confirmation.\n */\nimport * as React from 'react'\nimport type { HookEvent } from 'src/entrypoints/agentSdkTypes.js'\nimport type { HookEventMetadata } from 'src/utils/hooks/hooksConfigManager.js'\nimport { Box, Text } from '../../ink.js'\nimport {\n  getHookDisplayText,\n  hookSourceHeaderDisplayString,\n  type IndividualHookConfig,\n} from '../../utils/hooks/hooksSettings.js'\nimport { Select } from '../CustomSelect/select.js'\nimport { Dialog } from '../design-system/Dialog.js'\n\ntype Props = {\n  selectedEvent: HookEvent\n  selectedMatcher: string | null\n  hooksForSelectedMatcher: IndividualHookConfig[]\n  hookEventMetadata: HookEventMetadata\n  onSelect: (hook: IndividualHookConfig) => void\n  onCancel: () => void\n}\n\nexport function SelectHookMode({\n  selectedEvent,\n  selectedMatcher,\n  hooksForSelectedMatcher,\n  hookEventMetadata,\n  onSelect,\n  onCancel,\n}: Props): React.ReactNode {\n  const title =\n    hookEventMetadata.matcherMetadata !== undefined\n      ? `${selectedEvent} - Matcher: ${selectedMatcher || '(all)'}`\n      : selectedEvent\n\n  if (hooksForSelectedMatcher.length === 0) {\n    return (\n      <Dialog\n        title={title}\n        subtitle={hookEventMetadata.description}\n        onCancel={onCancel}\n        inputGuide={() => <Text>Esc to go back</Text>}\n      >\n        <Box flexDirection=\"column\" gap={1}>\n          <Text dimColor>No hooks configured for this event.</Text>\n          <Text dimColor>\n            To add hooks, edit settings.json directly or ask Claude.\n          </Text>\n        </Box>\n      </Dialog>\n    )\n  }\n\n  return (\n    <Dialog\n      title={title}\n      subtitle={hookEventMetadata.description}\n      onCancel={onCancel}\n    >\n      <Box flexDirection=\"column\">\n        <Select\n          options={hooksForSelectedMatcher.map((hook, index) => ({\n            label: `[${hook.config.type}] ${getHookDisplayText(hook.config)}`,\n            value: index.toString(),\n            description:\n              hook.source === 'pluginHook' && hook.pluginName\n                ? `${hookSourceHeaderDisplayString(hook.source)} (${hook.pluginName})`\n                : hookSourceHeaderDisplayString(hook.source),\n          }))}\n          onChange={value => {\n            const index = parseInt(value, 10)\n            const hook = hooksForSelectedMatcher[index]\n            if (hook) {\n              onSelect(hook)\n            }\n          }}\n          onCancel={onCancel}\n        />\n      </Box>\n    </Dialog>\n  )\n}\n"],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAC9B,cAAcC,SAAS,QAAQ,kCAAkC;AACjE,cAAcC,iBAAiB,QAAQ,uCAAuC;AAC9E,SAASC,GAAG,EAAEC,IAAI,QAAQ,cAAc;AACxC,SACEC,kBAAkB,EAClBC,6BAA6B,EAC7B,KAAKC,oBAAoB,QACpB,oCAAoC;AAC3C,SAASC,MAAM,QAAQ,2BAA2B;AAClD,SAASC,MAAM,QAAQ,4BAA4B;AAEnD,KAAKC,KAAK,GAAG;EACXC,aAAa,EAAEV,SAAS;EACxBW,eAAe,EAAE,MAAM,GAAG,IAAI;EAC9BC,uBAAuB,EAAEN,oBAAoB,EAAE;EAC/CO,iBAAiB,EAAEZ,iBAAiB;EACpCa,QAAQ,EAAE,CAACC,IAAI,EAAET,oBAAoB,EAAE,GAAG,IAAI;EAC9CU,QAAQ,EAAE,GAAG,GAAG,IAAI;AACtB,CAAC;AAED,OAAO,SAAAC,eAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAwB;IAAAV,aAAA;IAAAC,eAAA;IAAAC,uBAAA;IAAAC,iBAAA;IAAAC,QAAA;IAAAE;EAAA,IAAAE,EAOvB;EACN,MAAAG,KAAA,GACER,iBAAiB,CAAAS,eAAgB,KAAKC,SAErB,GAFjB,GACOb,aAAa,eAAeC,eAA0B,IAA1B,OAA0B,EAC5C,GAFjBD,aAEiB;EAEnB,IAAIE,uBAAuB,CAAAY,MAAO,KAAK,CAAC;IAAA,IAAAC,EAAA;IAAA,IAAAN,CAAA,QAAAO,MAAA,CAAAC,GAAA;MAQlCF,EAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAM,GAAC,CAAD,GAAC,CAChC,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,mCAAmC,EAAjD,IAAI,CACL,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,wDAEf,EAFC,IAAI,CAGP,EALC,GAAG,CAKE;MAAAN,CAAA,MAAAM,EAAA;IAAA;MAAAA,EAAA,GAAAN,CAAA;IAAA;IAAA,IAAAS,EAAA;IAAA,IAAAT,CAAA,QAAAN,iBAAA,CAAAgB,WAAA,IAAAV,CAAA,QAAAH,QAAA,IAAAG,CAAA,QAAAE,KAAA;MAXRO,EAAA,IAAC,MAAM,CACEP,KAAK,CAALA,MAAI,CAAC,CACF,QAA6B,CAA7B,CAAAR,iBAAiB,CAAAgB,WAAW,CAAC,CAC7Bb,QAAQ,CAARA,SAAO,CAAC,CACN,UAAiC,CAAjC,CAAAc,KAAgC,CAAC,CAE7C,CAAAL,EAKK,CACP,EAZC,MAAM,CAYE;MAAAN,CAAA,MAAAN,iBAAA,CAAAgB,WAAA;MAAAV,CAAA,MAAAH,QAAA;MAAAG,CAAA,MAAAE,KAAA;MAAAF,CAAA,MAAAS,EAAA;IAAA;MAAAA,EAAA,GAAAT,CAAA;IAAA;IAAA,OAZTS,EAYS;EAAA;EAOC,MAAAH,EAAA,GAAAZ,iBAAiB,CAAAgB,WAAY;EAAA,IAAAD,EAAA;EAAA,IAAAT,CAAA,QAAAP,uBAAA;IAK1BgB,EAAA,GAAAhB,uBAAuB,CAAAmB,GAAI,CAACC,MAOnC,CAAC;IAAAb,CAAA,MAAAP,uBAAA;IAAAO,CAAA,MAAAS,EAAA;EAAA;IAAAA,EAAA,GAAAT,CAAA;EAAA;EAAA,IAAAc,EAAA;EAAA,IAAAd,CAAA,QAAAP,uBAAA,IAAAO,CAAA,QAAAL,QAAA;IACOmB,EAAA,GAAAC,KAAA;MACR,MAAAC,OAAA,GAAcC,QAAQ,CAACF,KAAK,EAAE,EAAE,CAAC;MACjC,MAAAG,MAAA,GAAazB,uBAAuB,CAAC0B,OAAK,CAAC;MAC3C,IAAIvB,MAAI;QACND,QAAQ,CAACC,MAAI,CAAC;MAAA;IACf,CACF;IAAAI,CAAA,MAAAP,uBAAA;IAAAO,CAAA,MAAAL,QAAA;IAAAK,CAAA,MAAAc,EAAA;EAAA;IAAAA,EAAA,GAAAd,CAAA;EAAA;EAAA,IAAAoB,EAAA;EAAA,IAAApB,CAAA,SAAAH,QAAA,IAAAG,CAAA,SAAAS,EAAA,IAAAT,CAAA,SAAAc,EAAA;IAhBLM,EAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAC,MAAM,CACI,OAON,CAPM,CAAAX,EAOP,CAAC,CACO,QAMT,CANS,CAAAK,EAMV,CAAC,CACSjB,QAAQ,CAARA,SAAO,CAAC,GAEtB,EAnBC,GAAG,CAmBE;IAAAG,CAAA,OAAAH,QAAA;IAAAG,CAAA,OAAAS,EAAA;IAAAT,CAAA,OAAAc,EAAA;IAAAd,CAAA,OAAAoB,EAAA;EAAA;IAAAA,EAAA,GAAApB,CAAA;EAAA;EAAA,IAAAqB,EAAA;EAAA,IAAArB,CAAA,SAAAN,iBAAA,CAAAgB,WAAA,IAAAV,CAAA,SAAAH,QAAA,IAAAG,CAAA,SAAAoB,EAAA,IAAApB,CAAA,SAAAE,KAAA;IAxBRmB,EAAA,IAAC,MAAM,CACEnB,KAAK,CAALA,MAAI,CAAC,CACF,QAA6B,CAA7B,CAAAI,EAA4B,CAAC,CAC7BT,QAAQ,CAARA,SAAO,CAAC,CAElB,CAAAuB,EAmBK,CACP,EAzBC,MAAM,CAyBE;IAAApB,CAAA,OAAAN,iBAAA,CAAAgB,WAAA;IAAAV,CAAA,OAAAH,QAAA;IAAAG,CAAA,OAAAoB,EAAA;IAAApB,CAAA,OAAAE,KAAA;IAAAF,CAAA,OAAAqB,EAAA;EAAA;IAAAA,EAAA,GAAArB,CAAA;EAAA;EAAA,OAzBTqB,EAyBS;AAAA;AAzDN,SAAAR,OAAAjB,IAAA,EAAAuB,KAAA;EAAA,OAuC0D;IAAAG,KAAA,EAC9C,IAAI1B,IAAI,CAAA2B,MAAO,CAAAC,IAAK,KAAKvC,kBAAkB,CAACW,IAAI,CAAA2B,MAAO,CAAC,EAAE;IAAAR,KAAA,EAC1DI,KAAK,CAAAM,QAAS,CAAC,CAAC;IAAAf,WAAA,EAErBd,IAAI,CAAA8B,MAAO,KAAK,YAA+B,IAAf9B,IAAI,CAAA+B,UAEU,GAF9C,GACOzC,6BAA6B,CAACU,IAAI,CAAA8B,MAAO,CAAC,KAAK9B,IAAI,CAAA+B,UAAW,GACvB,GAA1CzC,6BAA6B,CAACU,IAAI,CAAA8B,MAAO;EACjD,CAAC;AAAA;AA9CJ,SAAAf,MAAA;EAAA,OAmBmB,CAAC,IAAI,CAAC,cAAc,EAAnB,IAAI,CAAsB;AAAA","ignoreList":[]} \ No newline at end of file diff --git a/src/components/hooks/ViewHookMode.tsx b/src/components/hooks/ViewHookMode.tsx new file mode 100644 index 0000000000000000000000000000000000000000..b84d4b0f0af0bfd510934ed7e8e28266bbd6908b --- /dev/null +++ b/src/components/hooks/ViewHookMode.tsx @@ -0,0 +1,199 @@ +import { c as _c } from "react/compiler-runtime"; +/** + * ViewHookMode shows read-only details for a single configured hook. + * + * The /hooks menu is read-only; this view replaces the former delete-hook + * confirmation screen and directs users to settings.json or Claude for edits. + */ +import * as React from 'react'; +import { Box, Text } from '../../ink.js'; +import { hookSourceDescriptionDisplayString, type IndividualHookConfig } from '../../utils/hooks/hooksSettings.js'; +import { Dialog } from '../design-system/Dialog.js'; +type Props = { + selectedHook: IndividualHookConfig; + eventSupportsMatcher: boolean; + onCancel: () => void; +}; +export function ViewHookMode(t0) { + const $ = _c(40); + const { + selectedHook, + eventSupportsMatcher, + onCancel + } = t0; + let t1; + if ($[0] !== selectedHook.event) { + t1 = Event: {selectedHook.event}; + $[0] = selectedHook.event; + $[1] = t1; + } else { + t1 = $[1]; + } + let t2; + if ($[2] !== eventSupportsMatcher || $[3] !== selectedHook.matcher) { + t2 = eventSupportsMatcher && Matcher: {selectedHook.matcher || "(all)"}; + $[2] = eventSupportsMatcher; + $[3] = selectedHook.matcher; + $[4] = t2; + } else { + t2 = $[4]; + } + let t3; + if ($[5] !== selectedHook.config.type) { + t3 = Type: {selectedHook.config.type}; + $[5] = selectedHook.config.type; + $[6] = t3; + } else { + t3 = $[6]; + } + let t4; + if ($[7] !== selectedHook.source) { + t4 = hookSourceDescriptionDisplayString(selectedHook.source); + $[7] = selectedHook.source; + $[8] = t4; + } else { + t4 = $[8]; + } + let t5; + if ($[9] !== t4) { + t5 = Source:{" "}{t4}; + $[9] = t4; + $[10] = t5; + } else { + t5 = $[10]; + } + let t6; + if ($[11] !== selectedHook.pluginName) { + t6 = selectedHook.pluginName && Plugin: {selectedHook.pluginName}; + $[11] = selectedHook.pluginName; + $[12] = t6; + } else { + t6 = $[12]; + } + let t7; + if ($[13] !== t1 || $[14] !== t2 || $[15] !== t3 || $[16] !== t5 || $[17] !== t6) { + t7 = {t1}{t2}{t3}{t5}{t6}; + $[13] = t1; + $[14] = t2; + $[15] = t3; + $[16] = t5; + $[17] = t6; + $[18] = t7; + } else { + t7 = $[18]; + } + let t8; + if ($[19] !== selectedHook.config) { + t8 = getContentFieldLabel(selectedHook.config); + $[19] = selectedHook.config; + $[20] = t8; + } else { + t8 = $[20]; + } + let t9; + if ($[21] !== t8) { + t9 = {t8}:; + $[21] = t8; + $[22] = t9; + } else { + t9 = $[22]; + } + let t10; + if ($[23] !== selectedHook.config) { + t10 = getContentFieldValue(selectedHook.config); + $[23] = selectedHook.config; + $[24] = t10; + } else { + t10 = $[24]; + } + let t11; + if ($[25] !== t10) { + t11 = {t10}; + $[25] = t10; + $[26] = t11; + } else { + t11 = $[26]; + } + let t12; + if ($[27] !== t11 || $[28] !== t9) { + t12 = {t9}{t11}; + $[27] = t11; + $[28] = t9; + $[29] = t12; + } else { + t12 = $[29]; + } + let t13; + if ($[30] !== selectedHook.config) { + t13 = "statusMessage" in selectedHook.config && selectedHook.config.statusMessage && Status message:{" "}{selectedHook.config.statusMessage}; + $[30] = selectedHook.config; + $[31] = t13; + } else { + t13 = $[31]; + } + let t14; + if ($[32] === Symbol.for("react.memo_cache_sentinel")) { + t14 = To modify or remove this hook, edit settings.json directly or ask Claude to help.; + $[32] = t14; + } else { + t14 = $[32]; + } + let t15; + if ($[33] !== t12 || $[34] !== t13 || $[35] !== t7) { + t15 = {t7}{t12}{t13}{t14}; + $[33] = t12; + $[34] = t13; + $[35] = t7; + $[36] = t15; + } else { + t15 = $[36]; + } + let t16; + if ($[37] !== onCancel || $[38] !== t15) { + t16 = {t15}; + $[37] = onCancel; + $[38] = t15; + $[39] = t16; + } else { + t16 = $[39]; + } + return t16; +} + +/** + * Get a human-readable label for the primary content field of a hook + * based on its type. + */ +function _temp() { + return Esc to go back; +} +function getContentFieldLabel(config: IndividualHookConfig['config']): string { + switch (config.type) { + case 'command': + return 'Command'; + case 'prompt': + return 'Prompt'; + case 'agent': + return 'Prompt'; + case 'http': + return 'URL'; + } +} + +/** + * Get the actual content value for a hook's primary field, bypassing + * statusMessage so the detail view always shows the real command/prompt/URL. + */ +function getContentFieldValue(config: IndividualHookConfig['config']): string { + switch (config.type) { + case 'command': + return config.command; + case 'prompt': + return config.prompt; + case 'agent': + return config.prompt; + case 'http': + return config.url; + } +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Box","Text","hookSourceDescriptionDisplayString","IndividualHookConfig","Dialog","Props","selectedHook","eventSupportsMatcher","onCancel","ViewHookMode","t0","$","_c","t1","event","t2","matcher","t3","config","type","t4","source","t5","t6","pluginName","t7","t8","getContentFieldLabel","t9","t10","getContentFieldValue","t11","t12","t13","statusMessage","t14","Symbol","for","t15","t16","_temp","command","prompt","url"],"sources":["ViewHookMode.tsx"],"sourcesContent":["/**\n * ViewHookMode shows read-only details for a single configured hook.\n *\n * The /hooks menu is read-only; this view replaces the former delete-hook\n * confirmation screen and directs users to settings.json or Claude for edits.\n */\nimport * as React from 'react'\nimport { Box, Text } from '../../ink.js'\nimport {\n  hookSourceDescriptionDisplayString,\n  type IndividualHookConfig,\n} from '../../utils/hooks/hooksSettings.js'\nimport { Dialog } from '../design-system/Dialog.js'\n\ntype Props = {\n  selectedHook: IndividualHookConfig\n  eventSupportsMatcher: boolean\n  onCancel: () => void\n}\n\nexport function ViewHookMode({\n  selectedHook,\n  eventSupportsMatcher,\n  onCancel,\n}: Props): React.ReactNode {\n  return (\n    <Dialog\n      title=\"Hook details\"\n      onCancel={onCancel}\n      inputGuide={() => <Text>Esc to go back</Text>}\n    >\n      <Box flexDirection=\"column\" gap={1}>\n        <Box flexDirection=\"column\">\n          <Text>\n            Event: <Text bold>{selectedHook.event}</Text>\n          </Text>\n          {eventSupportsMatcher && (\n            <Text>\n              Matcher: <Text bold>{selectedHook.matcher || '(all)'}</Text>\n            </Text>\n          )}\n          <Text>\n            Type: <Text bold>{selectedHook.config.type}</Text>\n          </Text>\n          <Text>\n            Source:{' '}\n            <Text dimColor>\n              {hookSourceDescriptionDisplayString(selectedHook.source)}\n            </Text>\n          </Text>\n          {selectedHook.pluginName && (\n            <Text>\n              Plugin: <Text dimColor>{selectedHook.pluginName}</Text>\n            </Text>\n          )}\n        </Box>\n        <Box flexDirection=\"column\">\n          <Text dimColor>{getContentFieldLabel(selectedHook.config)}:</Text>\n          <Box\n            borderStyle=\"round\"\n            borderDimColor\n            paddingLeft={1}\n            paddingRight={1}\n          >\n            <Text>{getContentFieldValue(selectedHook.config)}</Text>\n          </Box>\n        </Box>\n        {'statusMessage' in selectedHook.config &&\n          selectedHook.config.statusMessage && (\n            <Text>\n              Status message:{' '}\n              <Text dimColor>{selectedHook.config.statusMessage}</Text>\n            </Text>\n          )}\n        <Text dimColor>\n          To modify or remove this hook, edit settings.json directly or ask\n          Claude to help.\n        </Text>\n      </Box>\n    </Dialog>\n  )\n}\n\n/**\n * Get a human-readable label for the primary content field of a hook\n * based on its type.\n */\nfunction getContentFieldLabel(config: IndividualHookConfig['config']): string {\n  switch (config.type) {\n    case 'command':\n      return 'Command'\n    case 'prompt':\n      return 'Prompt'\n    case 'agent':\n      return 'Prompt'\n    case 'http':\n      return 'URL'\n  }\n}\n\n/**\n * Get the actual content value for a hook's primary field, bypassing\n * statusMessage so the detail view always shows the real command/prompt/URL.\n */\nfunction getContentFieldValue(config: IndividualHookConfig['config']): string {\n  switch (config.type) {\n    case 'command':\n      return config.command\n    case 'prompt':\n      return config.prompt\n    case 'agent':\n      return config.prompt\n    case 'http':\n      return config.url\n  }\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/components/mcp/CapabilitiesSection.tsx b/src/components/mcp/CapabilitiesSection.tsx new file mode 100644 index 0000000000000000000000000000000000000000..7d136f5679f193b708538ff64e5b6a9657ceaaa9 --- /dev/null +++ b/src/components/mcp/CapabilitiesSection.tsx @@ -0,0 +1,61 @@ +import { c as _c } from "react/compiler-runtime"; +import React from 'react'; +import { Box, Text } from '../../ink.js'; +import { Byline } from '../design-system/Byline.js'; +type Props = { + serverToolsCount: number; + serverPromptsCount: number; + serverResourcesCount: number; +}; +export function CapabilitiesSection(t0) { + const $ = _c(9); + const { + serverToolsCount, + serverPromptsCount, + serverResourcesCount + } = t0; + let capabilities; + if ($[0] !== serverPromptsCount || $[1] !== serverResourcesCount || $[2] !== serverToolsCount) { + capabilities = []; + if (serverToolsCount > 0) { + capabilities.push("tools"); + } + if (serverResourcesCount > 0) { + capabilities.push("resources"); + } + if (serverPromptsCount > 0) { + capabilities.push("prompts"); + } + $[0] = serverPromptsCount; + $[1] = serverResourcesCount; + $[2] = serverToolsCount; + $[3] = capabilities; + } else { + capabilities = $[3]; + } + let t1; + if ($[4] === Symbol.for("react.memo_cache_sentinel")) { + t1 = Capabilities: ; + $[4] = t1; + } else { + t1 = $[4]; + } + let t2; + if ($[5] !== capabilities) { + t2 = capabilities.length > 0 ? {capabilities} : "none"; + $[5] = capabilities; + $[6] = t2; + } else { + t2 = $[6]; + } + let t3; + if ($[7] !== t2) { + t3 = {t1}{t2}; + $[7] = t2; + $[8] = t3; + } else { + t3 = $[8]; + } + return t3; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/src/components/mcp/MCPRemoteServerMenu.tsx b/src/components/mcp/MCPRemoteServerMenu.tsx new file mode 100644 index 0000000000000000000000000000000000000000..954c6f30b72fb1ead33cbf13936c0e7f1e56d104 --- /dev/null +++ b/src/components/mcp/MCPRemoteServerMenu.tsx @@ -0,0 +1,649 @@ +import figures from 'figures'; +import React, { useEffect, useRef, useState } from 'react'; +import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js'; +import type { CommandResultDisplay } from '../../commands.js'; +import { getOauthConfig } from '../../constants/oauth.js'; +import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'; +import { useTerminalSize } from '../../hooks/useTerminalSize.js'; +import { setClipboard } from '../../ink/termio/osc.js'; +// eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw j/k/arrow menu navigation +import { Box, color, Link, Text, useInput, useTheme } from '../../ink.js'; +import { useKeybinding } from '../../keybindings/useKeybinding.js'; +import { AuthenticationCancelledError, performMCPOAuthFlow, revokeServerTokens } from '../../services/mcp/auth.js'; +import { clearServerCache } from '../../services/mcp/client.js'; +import { useMcpReconnect, useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js'; +import { describeMcpConfigFilePath, excludeCommandsByServer, excludeResourcesByServer, excludeToolsByServer, filterMcpPromptsByServer } from '../../services/mcp/utils.js'; +import { useAppState, useSetAppState } from '../../state/AppState.js'; +import { getOauthAccountInfo } from '../../utils/auth.js'; +import { openBrowser } from '../../utils/browser.js'; +import { errorMessage } from '../../utils/errors.js'; +import { logMCPDebug } from '../../utils/log.js'; +import { capitalize } from '../../utils/stringUtils.js'; +import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'; +import { Select } from '../CustomSelect/index.js'; +import { Byline } from '../design-system/Byline.js'; +import { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js'; +import { Spinner } from '../Spinner.js'; +import TextInput from '../TextInput.js'; +import { CapabilitiesSection } from './CapabilitiesSection.js'; +import type { ClaudeAIServerInfo, HTTPServerInfo, SSEServerInfo } from './types.js'; +import { handleReconnectError, handleReconnectResult } from './utils/reconnectHelpers.js'; +type Props = { + server: SSEServerInfo | HTTPServerInfo | ClaudeAIServerInfo; + serverToolsCount: number; + onViewTools: () => void; + onCancel: () => void; + onComplete?: (result?: string, options?: { + display?: CommandResultDisplay; + }) => void; + borderless?: boolean; +}; +export function MCPRemoteServerMenu({ + server, + serverToolsCount, + onViewTools, + onCancel, + onComplete, + borderless = false +}: Props): React.ReactNode { + const [theme] = useTheme(); + const exitState = useExitOnCtrlCDWithKeybindings(); + const { + columns: terminalColumns + } = useTerminalSize(); + const [isAuthenticating, setIsAuthenticating] = React.useState(false); + const [error, setError] = React.useState(null); + const mcp = useAppState(s => s.mcp); + const setAppState = useSetAppState(); + const [authorizationUrl, setAuthorizationUrl] = React.useState(null); + const [isReconnecting, setIsReconnecting] = useState(false); + const authAbortControllerRef = useRef(null); + const [isClaudeAIAuthenticating, setIsClaudeAIAuthenticating] = useState(false); + const [claudeAIAuthUrl, setClaudeAIAuthUrl] = useState(null); + const [isClaudeAIClearingAuth, setIsClaudeAIClearingAuth] = useState(false); + const [claudeAIClearAuthUrl, setClaudeAIClearAuthUrl] = useState(null); + const [claudeAIClearAuthBrowserOpened, setClaudeAIClearAuthBrowserOpened] = useState(false); + const [urlCopied, setUrlCopied] = useState(false); + const copyTimeoutRef = useRef | undefined>(undefined); + const unmountedRef = useRef(false); + const [callbackUrlInput, setCallbackUrlInput] = useState(''); + const [callbackUrlCursorOffset, setCallbackUrlCursorOffset] = useState(0); + const [manualCallbackSubmit, setManualCallbackSubmit] = useState<((url: string) => void) | null>(null); + + // If the component unmounts mid-auth (e.g. a parent component's Esc handler + // navigates away before ours fires), abort the OAuth flow so the callback + // server is closed. Without this, the server stays bound and the process + // can outlive the terminal. Also clear the copy-feedback timer and mark + // unmounted so the async setClipboard callback doesn't setUrlCopied / + // schedule a new timer after unmount. + useEffect(() => () => { + unmountedRef.current = true; + authAbortControllerRef.current?.abort(); + if (copyTimeoutRef.current !== undefined) { + clearTimeout(copyTimeoutRef.current); + } + }, []); + + // A server is effectively authenticated if: + // 1. It has OAuth tokens (server.isAuthenticated), OR + // 2. It's connected and has tools (meaning it's working via some auth mechanism) + const isEffectivelyAuthenticated = server.isAuthenticated || server.client.type === 'connected' && serverToolsCount > 0; + const reconnectMcpServer = useMcpReconnect(); + const handleClaudeAIAuthComplete = React.useCallback(async () => { + setIsClaudeAIAuthenticating(false); + setClaudeAIAuthUrl(null); + setIsReconnecting(true); + try { + const result = await reconnectMcpServer(server.name); + const success = result.client.type === 'connected'; + logEvent('tengu_claudeai_mcp_auth_completed', { + success + }); + if (success) { + onComplete?.(`Authentication successful. Connected to ${server.name}.`); + } else if (result.client.type === 'needs-auth') { + onComplete?.('Authentication successful, but server still requires authentication. You may need to manually restart Claude Code.'); + } else { + onComplete?.('Authentication successful, but server reconnection failed. You may need to manually restart Claude Code for the changes to take effect.'); + } + } catch (err) { + logEvent('tengu_claudeai_mcp_auth_completed', { + success: false + }); + onComplete?.(handleReconnectError(err, server.name)); + } finally { + setIsReconnecting(false); + } + }, [reconnectMcpServer, server.name, onComplete]); + const handleClaudeAIClearAuthComplete = React.useCallback(async () => { + await clearServerCache(server.name, { + ...server.config, + scope: server.scope + }); + setAppState(prev => { + const newClients = prev.mcp.clients.map(c => c.name === server.name ? { + ...c, + type: 'needs-auth' as const + } : c); + const newTools = excludeToolsByServer(prev.mcp.tools, server.name); + const newCommands = excludeCommandsByServer(prev.mcp.commands, server.name); + const newResources = excludeResourcesByServer(prev.mcp.resources, server.name); + return { + ...prev, + mcp: { + ...prev.mcp, + clients: newClients, + tools: newTools, + commands: newCommands, + resources: newResources + } + }; + }); + logEvent('tengu_claudeai_mcp_clear_auth_completed', {}); + onComplete?.(`Disconnected from ${server.name}.`); + setIsClaudeAIClearingAuth(false); + setClaudeAIClearAuthUrl(null); + setClaudeAIClearAuthBrowserOpened(false); + }, [server.name, server.config, server.scope, setAppState, onComplete]); + + // Escape to cancel authentication flow + useKeybinding('confirm:no', () => { + authAbortControllerRef.current?.abort(); + authAbortControllerRef.current = null; + setIsAuthenticating(false); + setAuthorizationUrl(null); + }, { + context: 'Confirmation', + isActive: isAuthenticating + }); + + // Escape to cancel Claude AI authentication + useKeybinding('confirm:no', () => { + setIsClaudeAIAuthenticating(false); + setClaudeAIAuthUrl(null); + }, { + context: 'Confirmation', + isActive: isClaudeAIAuthenticating + }); + + // Escape to cancel Claude AI clear auth + useKeybinding('confirm:no', () => { + setIsClaudeAIClearingAuth(false); + setClaudeAIClearAuthUrl(null); + setClaudeAIClearAuthBrowserOpened(false); + }, { + context: 'Confirmation', + isActive: isClaudeAIClearingAuth + }); + + // Return key handling for authentication flows and 'c' to copy URL + useInput((input, key) => { + if (key.return && isClaudeAIAuthenticating) { + void handleClaudeAIAuthComplete(); + } + if (key.return && isClaudeAIClearingAuth) { + if (claudeAIClearAuthBrowserOpened) { + void handleClaudeAIClearAuthComplete(); + } else { + // First Enter: open the browser + const connectorsUrl = `${getOauthConfig().CLAUDE_AI_ORIGIN}/settings/connectors`; + setClaudeAIClearAuthUrl(connectorsUrl); + setClaudeAIClearAuthBrowserOpened(true); + void openBrowser(connectorsUrl); + } + } + if (input === 'c' && !urlCopied) { + const urlToCopy = authorizationUrl || claudeAIAuthUrl || claudeAIClearAuthUrl; + if (urlToCopy) { + void setClipboard(urlToCopy).then(raw => { + if (unmountedRef.current) return; + if (raw) process.stdout.write(raw); + setUrlCopied(true); + if (copyTimeoutRef.current !== undefined) { + clearTimeout(copyTimeoutRef.current); + } + copyTimeoutRef.current = setTimeout(setUrlCopied, 2000, false); + }); + } + } + }); + const capitalizedServerName = capitalize(String(server.name)); + + // Count MCP prompts for this server (skills are shown in /skills, not here) + const serverCommandsCount = filterMcpPromptsByServer(mcp.commands, server.name).length; + const toggleMcpServer = useMcpToggleEnabled(); + const handleClaudeAIAuth = React.useCallback(async () => { + const claudeAiBaseUrl = getOauthConfig().CLAUDE_AI_ORIGIN; + const accountInfo = getOauthAccountInfo(); + const orgUuid = accountInfo?.organizationUuid; + let authUrl: string; + if (orgUuid && server.config.type === 'claudeai-proxy' && server.config.id) { + // Use the direct auth URL with org and server IDs + // Replace 'mcprs' prefix with 'mcpsrv' if present + const serverId = server.config.id.startsWith('mcprs') ? 'mcpsrv' + server.config.id.slice(5) : server.config.id; + const productSurface = encodeURIComponent(process.env.CLAUDE_CODE_ENTRYPOINT || 'cli'); + authUrl = `${claudeAiBaseUrl}/api/organizations/${orgUuid}/mcp/start-auth/${serverId}?product_surface=${productSurface}`; + } else { + // Fall back to settings/connectors if we don't have the required IDs + authUrl = `${claudeAiBaseUrl}/settings/connectors`; + } + setClaudeAIAuthUrl(authUrl); + setIsClaudeAIAuthenticating(true); + logEvent('tengu_claudeai_mcp_auth_started', {}); + await openBrowser(authUrl); + }, [server.config]); + const handleClaudeAIClearAuth = React.useCallback(() => { + setIsClaudeAIClearingAuth(true); + logEvent('tengu_claudeai_mcp_clear_auth_started', {}); + }, []); + const handleToggleEnabled = React.useCallback(async () => { + const wasEnabled = server.client.type !== 'disabled'; + try { + await toggleMcpServer(server.name); + if (server.config.type === 'claudeai-proxy') { + logEvent('tengu_claudeai_mcp_toggle', { + new_state: (wasEnabled ? 'disabled' : 'enabled') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS + }); + } + + // Return to the server list so user can continue managing other servers + onCancel(); + } catch (err_0) { + const action = wasEnabled ? 'disable' : 'enable'; + onComplete?.(`Failed to ${action} MCP server '${server.name}': ${errorMessage(err_0)}`); + } + }, [server.client.type, server.config.type, server.name, toggleMcpServer, onCancel, onComplete]); + const handleAuthenticate = React.useCallback(async () => { + if (server.config.type === 'claudeai-proxy') return; + setIsAuthenticating(true); + setError(null); + const controller = new AbortController(); + authAbortControllerRef.current = controller; + try { + // Revoke existing tokens if re-authenticating, but preserve step-up + // auth state so the next OAuth flow can reuse cached scope/discovery. + if (server.isAuthenticated && server.config) { + await revokeServerTokens(server.name, server.config, { + preserveStepUpState: true + }); + } + if (server.config) { + await performMCPOAuthFlow(server.name, server.config, setAuthorizationUrl, controller.signal, { + onWaitingForCallback: submit => { + setManualCallbackSubmit(() => submit); + } + }); + logEvent('tengu_mcp_auth_config_authenticate', { + wasAuthenticated: server.isAuthenticated + }); + const result_0 = await reconnectMcpServer(server.name); + if (result_0.client.type === 'connected') { + const message = isEffectivelyAuthenticated ? `Authentication successful. Reconnected to ${server.name}.` : `Authentication successful. Connected to ${server.name}.`; + onComplete?.(message); + } else if (result_0.client.type === 'needs-auth') { + onComplete?.('Authentication successful, but server still requires authentication. You may need to manually restart Claude Code.'); + } else { + // result.client.type === 'failed' + logMCPDebug(server.name, `Reconnection failed after authentication`); + onComplete?.('Authentication successful, but server reconnection failed. You may need to manually restart Claude Code for the changes to take effect.'); + } + } + } catch (err_1) { + // Don't show error if it was a cancellation + if (err_1 instanceof Error && !(err_1 instanceof AuthenticationCancelledError)) { + setError(err_1.message); + } + } finally { + setIsAuthenticating(false); + authAbortControllerRef.current = null; + setManualCallbackSubmit(null); + setCallbackUrlInput(''); + } + }, [server.isAuthenticated, server.config, server.name, onComplete, reconnectMcpServer, isEffectivelyAuthenticated]); + const handleClearAuth = async () => { + if (server.config.type === 'claudeai-proxy') return; + if (server.config) { + // First revoke the authentication tokens and clear all auth state + await revokeServerTokens(server.name, server.config); + logEvent('tengu_mcp_auth_config_clear', {}); + + // Disconnect the client and clear the cache + await clearServerCache(server.name, { + ...server.config, + scope: server.scope + }); + + // Update app state to remove the disconnected server's tools, commands, and resources + setAppState(prev_0 => { + const newClients_0 = prev_0.mcp.clients.map(c_0 => + // 'failed' is a misnomer here, but we don't really differentiate between "not connected" and "failed" at the moment + c_0.name === server.name ? { + ...c_0, + type: 'failed' as const + } : c_0); + const newTools_0 = excludeToolsByServer(prev_0.mcp.tools, server.name); + const newCommands_0 = excludeCommandsByServer(prev_0.mcp.commands, server.name); + const newResources_0 = excludeResourcesByServer(prev_0.mcp.resources, server.name); + return { + ...prev_0, + mcp: { + ...prev_0.mcp, + clients: newClients_0, + tools: newTools_0, + commands: newCommands_0, + resources: newResources_0 + } + }; + }); + onComplete?.(`Authentication cleared for ${server.name}.`); + } + }; + if (isAuthenticating) { + // XAA: silent exchange (cached id_token → no browser), so don't claim + // one will open. If IdP login IS needed, authorizationUrl populates and + // the URL fallback block below still renders. + const authCopy = server.config.type !== 'claudeai-proxy' && server.config.oauth?.xaa ? ' Authenticating via your identity provider' : ' A browser window will open for authentication'; + return + Authenticating with {server.name}… + + + {authCopy} + + {authorizationUrl && + + + If your browser doesn't open automatically, copy this URL + manually{' '} + + {urlCopied ? (Copied!) : + + } + + + } + {isAuthenticating && authorizationUrl && manualCallbackSubmit && + + If the redirect page shows a connection error, paste the URL from + your browser's address bar: + + + URL {'>'} + { + manualCallbackSubmit(value.trim()); + setCallbackUrlInput(''); + }} cursorOffset={callbackUrlCursorOffset} onChangeCursorOffset={setCallbackUrlCursorOffset} columns={terminalColumns - 8} /> + + } + + + Return here after authenticating in your browser. Press Esc to go + back. + + + ; + } + if (isClaudeAIAuthenticating) { + return + Authenticating with {server.name}… + + + A browser window will open for authentication + + {claudeAIAuthUrl && + + + If your browser doesn't open automatically, copy this URL + manually{' '} + + {urlCopied ? (Copied!) : + + } + + + } + + + Press Enter after authenticating in your browser. + + + + + + ; + } + if (isClaudeAIClearingAuth) { + return + Clear authentication for {server.name} + {claudeAIClearAuthBrowserOpened ? <> + + Find the MCP server in the browser and click + "Disconnect". + + {claudeAIClearAuthUrl && + + + If your browser didn't open automatically, copy this + URL manually{' '} + + {urlCopied ? (Copied!) : + + } + + + } + + + Press Enter when done. + + + + + + : <> + + This will open claude.ai in the browser. Find the MCP server in + the list and click "Disconnect". + + + + Press Enter to open the browser. + + + + + + } + ; + } + if (isReconnecting) { + return + + Connecting to {server.name}… + + + + Establishing connection to MCP server + + This may take a few moments. + ; + } + const menuOptions = []; + + // If server is disabled, show Enable first as the primary action + if (server.client.type === 'disabled') { + menuOptions.push({ + label: 'Enable', + value: 'toggle-enabled' + }); + } + if (server.client.type === 'connected' && serverToolsCount > 0) { + menuOptions.push({ + label: 'View tools', + value: 'tools' + }); + } + if (server.config.type === 'claudeai-proxy') { + if (server.client.type === 'connected') { + menuOptions.push({ + label: 'Clear authentication', + value: 'claudeai-clear-auth' + }); + } else if (server.client.type !== 'disabled') { + menuOptions.push({ + label: 'Authenticate', + value: 'claudeai-auth' + }); + } + } else { + if (isEffectivelyAuthenticated) { + menuOptions.push({ + label: 'Re-authenticate', + value: 'reauth' + }); + menuOptions.push({ + label: 'Clear authentication', + value: 'clear-auth' + }); + } + if (!isEffectivelyAuthenticated) { + menuOptions.push({ + label: 'Authenticate', + value: 'auth' + }); + } + } + if (server.client.type !== 'disabled') { + if (server.client.type !== 'needs-auth') { + menuOptions.push({ + label: 'Reconnect', + value: 'reconnectMcpServer' + }); + } + menuOptions.push({ + label: 'Disable', + value: 'toggle-enabled' + }); + } + + // If there are no other options, add a back option so Select handles escape + if (menuOptions.length === 0) { + menuOptions.push({ + label: 'Back', + value: 'back' + }); + } + return + + + {capitalizedServerName} MCP Server + + + + + Status: + {server.client.type === 'disabled' ? {color('inactive', theme)(figures.radioOff)} disabled : server.client.type === 'connected' ? {color('success', theme)(figures.tick)} connected : server.client.type === 'pending' ? <> + {figures.radioOff} + connecting… + : server.client.type === 'needs-auth' ? + {color('warning', theme)(figures.triangleUpOutline)} needs + authentication + : {color('error', theme)(figures.cross)} failed} + + + {server.transport !== 'claudeai-proxy' && + Auth: + {isEffectivelyAuthenticated ? + {color('success', theme)(figures.tick)} authenticated + : + {color('error', theme)(figures.cross)} not authenticated + } + } + + + URL: + {server.config.url} + + + + Config location: + {describeMcpConfigFilePath(server.scope)} + + + {server.client.type === 'connected' && } + + {server.client.type === 'connected' && serverToolsCount > 0 && + Tools: + {serverToolsCount} tools + } + + + {error && + Error: {error} + } + + {menuOptions.length > 0 && + { + if (value === 'tools') { + onViewTools(); + } else if (value === 'reconnectMcpServer') { + setIsReconnecting(true); + try { + const result = await reconnectMcpServer(server.name); + const { + message + } = handleReconnectResult(result, server.name); + onComplete?.(message); + } catch (err_0) { + onComplete?.(handleReconnectError(err_0, server.name)); + } finally { + setIsReconnecting(false); + } + } else if (value === 'toggle-enabled') { + await handleToggleEnabled(); + } else if (value === 'back') { + onCancel(); + } + }} onCancel={onCancel} /> + } + + + + + {exitState.pending ? <>Press {exitState.keyName} again to exit : + + + + } + + + ; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useState","CommandResultDisplay","useExitOnCtrlCDWithKeybindings","Box","color","Text","useTheme","getMcpConfigByName","useMcpReconnect","useMcpToggleEnabled","describeMcpConfigFilePath","filterMcpPromptsByServer","useAppState","errorMessage","capitalize","ConfigurableShortcutHint","Select","Byline","KeyboardShortcutHint","Spinner","CapabilitiesSection","StdioServerInfo","handleReconnectError","handleReconnectResult","Props","server","serverToolsCount","onViewTools","onCancel","onComplete","result","options","display","borderless","MCPStdioServerMenu","ReactNode","theme","exitState","mcp","s","reconnectMcpServer","toggleMcpServer","isReconnecting","setIsReconnecting","handleToggleEnabled","useCallback","wasEnabled","client","type","name","err","action","capitalizedServerName","String","serverCommandsCount","commands","length","menuOptions","push","label","value","undefined","radioOff","tick","cross","config","command","args","join","scope","resources","message","pending","keyName"],"sources":["MCPStdioServerMenu.tsx"],"sourcesContent":["import figures from 'figures'\nimport React, { useState } from 'react'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { Box, color, Text, useTheme } from '../../ink.js'\nimport { getMcpConfigByName } from '../../services/mcp/config.js'\nimport {\n  useMcpReconnect,\n  useMcpToggleEnabled,\n} from '../../services/mcp/MCPConnectionManager.js'\nimport {\n  describeMcpConfigFilePath,\n  filterMcpPromptsByServer,\n} from '../../services/mcp/utils.js'\nimport { useAppState } from '../../state/AppState.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { capitalize } from '../../utils/stringUtils.js'\nimport { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'\nimport { Select } from '../CustomSelect/index.js'\nimport { Byline } from '../design-system/Byline.js'\nimport { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js'\nimport { Spinner } from '../Spinner.js'\nimport { CapabilitiesSection } from './CapabilitiesSection.js'\nimport type { StdioServerInfo } from './types.js'\nimport {\n  handleReconnectError,\n  handleReconnectResult,\n} from './utils/reconnectHelpers.js'\n\ntype Props = {\n  server: StdioServerInfo\n  serverToolsCount: number\n  onViewTools: () => void\n  onCancel: () => void\n  onComplete: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n  borderless?: boolean\n}\n\nexport function MCPStdioServerMenu({\n  server,\n  serverToolsCount,\n  onViewTools,\n  onCancel,\n  onComplete,\n  borderless = false,\n}: Props): React.ReactNode {\n  const [theme] = useTheme()\n  const exitState = useExitOnCtrlCDWithKeybindings()\n  const mcp = useAppState(s => s.mcp)\n  const reconnectMcpServer = useMcpReconnect()\n  const toggleMcpServer = useMcpToggleEnabled()\n  const [isReconnecting, setIsReconnecting] = useState(false)\n\n  const handleToggleEnabled = React.useCallback(async () => {\n    const wasEnabled = server.client.type !== 'disabled'\n\n    try {\n      await toggleMcpServer(server.name)\n      // Return to the server list so user can continue managing other servers\n      onCancel()\n    } catch (err) {\n      const action = wasEnabled ? 'disable' : 'enable'\n      onComplete(\n        `Failed to ${action} MCP server '${server.name}': ${errorMessage(err)}`,\n      )\n    }\n  }, [server.client.type, server.name, toggleMcpServer, onCancel, onComplete])\n\n  const capitalizedServerName = capitalize(String(server.name))\n\n  // Count MCP prompts for this server (skills are shown in /skills, not here)\n  const serverCommandsCount = filterMcpPromptsByServer(\n    mcp.commands,\n    server.name,\n  ).length\n\n  const menuOptions = []\n\n  // Only show \"View tools\" if server is not disabled and has tools\n  if (server.client.type !== 'disabled' && serverToolsCount > 0) {\n    menuOptions.push({\n      label: 'View tools',\n      value: 'tools',\n    })\n  }\n\n  // Only show reconnect option if the server is not disabled\n  if (server.client.type !== 'disabled') {\n    menuOptions.push({\n      label: 'Reconnect',\n      value: 'reconnectMcpServer',\n    })\n  }\n\n  menuOptions.push({\n    label: server.client.type !== 'disabled' ? 'Disable' : 'Enable',\n    value: 'toggle-enabled',\n  })\n\n  // If there are no other options, add a back option so Select handles escape\n  if (menuOptions.length === 0) {\n    menuOptions.push({\n      label: 'Back',\n      value: 'back',\n    })\n  }\n\n  if (isReconnecting) {\n    return (\n      <Box flexDirection=\"column\" gap={1} padding={1}>\n        <Text color=\"text\">\n          Reconnecting to <Text bold>{server.name}</Text>\n        </Text>\n        <Box>\n          <Spinner />\n          <Text> Restarting MCP server process</Text>\n        </Box>\n        <Text dimColor>This may take a few moments.</Text>\n      </Box>\n    )\n  }\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box\n        flexDirection=\"column\"\n        paddingX={1}\n        borderStyle={borderless ? undefined : 'round'}\n      >\n        <Box marginBottom={1}>\n          <Text bold>{capitalizedServerName} MCP Server</Text>\n        </Box>\n\n        <Box flexDirection=\"column\" gap={0}>\n          <Box>\n            <Text bold>Status: </Text>\n            {server.client.type === 'disabled' ? (\n              <Text>{color('inactive', theme)(figures.radioOff)} disabled</Text>\n            ) : server.client.type === 'connected' ? (\n              <Text>{color('success', theme)(figures.tick)} connected</Text>\n            ) : server.client.type === 'pending' ? (\n              <>\n                <Text dimColor>{figures.radioOff}</Text>\n                <Text> connecting…</Text>\n              </>\n            ) : (\n              <Text>{color('error', theme)(figures.cross)} failed</Text>\n            )}\n          </Box>\n\n          <Box>\n            <Text bold>Command: </Text>\n            <Text dimColor>{server.config.command}</Text>\n          </Box>\n\n          {server.config.args && server.config.args.length > 0 && (\n            <Box>\n              <Text bold>Args: </Text>\n              <Text dimColor>{server.config.args.join(' ')}</Text>\n            </Box>\n          )}\n\n          <Box>\n            <Text bold>Config location: </Text>\n            <Text dimColor>\n              {describeMcpConfigFilePath(\n                getMcpConfigByName(server.name)?.scope ?? 'dynamic',\n              )}\n            </Text>\n          </Box>\n\n          {server.client.type === 'connected' && (\n            <CapabilitiesSection\n              serverToolsCount={serverToolsCount}\n              serverPromptsCount={serverCommandsCount}\n              serverResourcesCount={mcp.resources[server.name]?.length || 0}\n            />\n          )}\n\n          {server.client.type === 'connected' && serverToolsCount > 0 && (\n            <Box>\n              <Text bold>Tools: </Text>\n              <Text dimColor>{serverToolsCount} tools</Text>\n            </Box>\n          )}\n        </Box>\n\n        {menuOptions.length > 0 && (\n          <Box marginTop={1}>\n            <Select\n              options={menuOptions}\n              onChange={async value => {\n                if (value === 'tools') {\n                  onViewTools()\n                } else if (value === 'reconnectMcpServer') {\n                  setIsReconnecting(true)\n                  try {\n                    const result = await reconnectMcpServer(server.name)\n                    const { message } = handleReconnectResult(\n                      result,\n                      server.name,\n                    )\n                    onComplete?.(message)\n                  } catch (err) {\n                    onComplete?.(handleReconnectError(err, server.name))\n                  } finally {\n                    setIsReconnecting(false)\n                  }\n                } else if (value === 'toggle-enabled') {\n                  await handleToggleEnabled()\n                } else if (value === 'back') {\n                  onCancel()\n                }\n              }}\n              onCancel={onCancel}\n            />\n          </Box>\n        )}\n      </Box>\n\n      <Box marginTop={1}>\n        <Text dimColor italic>\n          {exitState.pending ? (\n            <>Press {exitState.keyName} again to exit</>\n          ) : (\n            <Byline>\n              <KeyboardShortcutHint shortcut=\"↑↓\" action=\"navigate\" />\n              <KeyboardShortcutHint shortcut=\"Enter\" action=\"select\" />\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"back\"\n              />\n            </Byline>\n          )}\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/components/mcp/MCPToolListView.tsx b/src/components/mcp/MCPToolListView.tsx new file mode 100644 index 0000000000000000000000000000000000000000..0e1e8bee6c6fd52cd22a05e50b880a42c03c844c --- /dev/null +++ b/src/components/mcp/MCPToolListView.tsx @@ -0,0 +1,141 @@ +import { c as _c } from "react/compiler-runtime"; +import React from 'react'; +import { Text } from '../../ink.js'; +import { extractMcpToolDisplayName, getMcpDisplayName } from '../../services/mcp/mcpStringUtils.js'; +import { filterToolsByServer } from '../../services/mcp/utils.js'; +import { useAppState } from '../../state/AppState.js'; +import type { Tool } from '../../Tool.js'; +import { plural } from '../../utils/stringUtils.js'; +import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'; +import { Select } from '../CustomSelect/index.js'; +import { Byline } from '../design-system/Byline.js'; +import { Dialog } from '../design-system/Dialog.js'; +import { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js'; +import type { ServerInfo } from './types.js'; +type Props = { + server: ServerInfo; + onSelectTool: (tool: Tool, index: number) => void; + onBack: () => void; +}; +export function MCPToolListView(t0) { + const $ = _c(21); + const { + server, + onSelectTool, + onBack + } = t0; + const mcpTools = useAppState(_temp); + let t1; + bb0: { + if (server.client.type !== "connected") { + let t2; + if ($[0] === Symbol.for("react.memo_cache_sentinel")) { + t2 = []; + $[0] = t2; + } else { + t2 = $[0]; + } + t1 = t2; + break bb0; + } + let t2; + if ($[1] !== mcpTools || $[2] !== server.name) { + t2 = filterToolsByServer(mcpTools, server.name); + $[1] = mcpTools; + $[2] = server.name; + $[3] = t2; + } else { + t2 = $[3]; + } + t1 = t2; + } + const serverTools = t1; + let t2; + if ($[4] !== server.name || $[5] !== serverTools) { + let t3; + if ($[7] !== server.name) { + t3 = (tool, index) => { + const toolName = getMcpDisplayName(tool.name, server.name); + const fullDisplayName = tool.userFacingName ? tool.userFacingName({}) : toolName; + const displayName = extractMcpToolDisplayName(fullDisplayName); + const isReadOnly = tool.isReadOnly?.({}) ?? false; + const isDestructive = tool.isDestructive?.({}) ?? false; + const isOpenWorld = tool.isOpenWorld?.({}) ?? false; + const annotations = []; + if (isReadOnly) { + annotations.push("read-only"); + } + if (isDestructive) { + annotations.push("destructive"); + } + if (isOpenWorld) { + annotations.push("open-world"); + } + return { + label: displayName, + value: index.toString(), + description: annotations.length > 0 ? annotations.join(", ") : undefined, + descriptionColor: isDestructive ? "error" : isReadOnly ? "success" : undefined + }; + }; + $[7] = server.name; + $[8] = t3; + } else { + t3 = $[8]; + } + t2 = serverTools.map(t3); + $[4] = server.name; + $[5] = serverTools; + $[6] = t2; + } else { + t2 = $[6]; + } + const toolOptions = t2; + const t3 = `Tools for ${server.name}`; + const t4 = serverTools.length; + let t5; + if ($[9] !== serverTools.length) { + t5 = plural(serverTools.length, "tool"); + $[9] = serverTools.length; + $[10] = t5; + } else { + t5 = $[10]; + } + const t6 = `${t4} ${t5}`; + let t7; + if ($[11] !== onBack || $[12] !== onSelectTool || $[13] !== serverTools || $[14] !== toolOptions) { + t7 = serverTools.length === 0 ? No tools available : onFinalResponse(value as 'submit' | 'cancel')} onCancel={() => onFinalResponse("cancel")} />; + $[16] = onFinalResponse; + $[17] = t10; + } else { + t10 = $[17]; + } + let t11; + if ($[18] !== minContentHeight || $[19] !== t10 || $[20] !== t4 || $[21] !== t5 || $[22] !== t6) { + t11 = {t4}{t5}{t6}{t7}{t10}; + $[18] = minContentHeight; + $[19] = t10; + $[20] = t4; + $[21] = t5; + $[22] = t6; + $[23] = t11; + } else { + t11 = $[23]; + } + let t12; + if ($[24] !== t11 || $[25] !== t2) { + t12 = {t1}{t2}{t3}{t11}; + $[24] = t11; + $[25] = t2; + $[26] = t12; + } else { + t12 = $[26]; + } + return t12; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","Box","Text","Question","PermissionDecision","Select","Divider","PermissionRequestTitle","PermissionRuleExplanation","QuestionNavigationBar","Props","questions","currentQuestionIndex","answers","Record","allQuestionsAnswered","permissionResult","minContentHeight","onFinalResponse","value","SubmitQuestionsView","t0","$","_c","t1","Symbol","for","t2","t3","t4","warning","t5","Object","keys","length","filter","q","question","map","q_0","answer","bullet","arrowRight","t6","t7","t8","type","const","label","t9","t10","t11","t12"],"sources":["SubmitQuestionsView.tsx"],"sourcesContent":["import figures from 'figures'\nimport React from 'react'\nimport { Box, Text } from '../../../ink.js'\nimport type { Question } from '../../../tools/AskUserQuestionTool/AskUserQuestionTool.js'\nimport type { PermissionDecision } from '../../../utils/permissions/PermissionResult.js'\nimport { Select } from '../../CustomSelect/index.js'\nimport { Divider } from '../../design-system/Divider.js'\nimport { PermissionRequestTitle } from '../PermissionRequestTitle.js'\nimport { PermissionRuleExplanation } from '../PermissionRuleExplanation.js'\nimport { QuestionNavigationBar } from './QuestionNavigationBar.js'\n\ntype Props = {\n  questions: Question[]\n  currentQuestionIndex: number\n  answers: Record<string, string>\n  allQuestionsAnswered: boolean\n  permissionResult: PermissionDecision\n  minContentHeight?: number\n  onFinalResponse: (value: 'submit' | 'cancel') => void\n}\n\nexport function SubmitQuestionsView({\n  questions,\n  currentQuestionIndex,\n  answers,\n  allQuestionsAnswered,\n  permissionResult,\n  minContentHeight,\n  onFinalResponse,\n}: Props): React.ReactNode {\n  return (\n    <Box flexDirection=\"column\" marginTop={1}>\n      <Divider color=\"inactive\" />\n      <Box\n        flexDirection=\"column\"\n        borderTop\n        borderColor=\"inactive\"\n        paddingTop={0}\n      >\n        <QuestionNavigationBar\n          questions={questions}\n          currentQuestionIndex={currentQuestionIndex}\n          answers={answers}\n        />\n        <PermissionRequestTitle title=\"Review your answers\" color=\"text\" />\n        <Box flexDirection=\"column\" marginTop={1} minHeight={minContentHeight}>\n          {!allQuestionsAnswered && (\n            <Box marginBottom={1}>\n              <Text color=\"warning\">\n                {figures.warning} You have not answered all questions\n              </Text>\n            </Box>\n          )}\n          {Object.keys(answers).length > 0 && (\n            <Box flexDirection=\"column\" marginBottom={1}>\n              {questions\n                .filter((q: Question) => q?.question && answers[q.question])\n                .map((q: Question) => {\n                  const answer = answers[q?.question]\n\n                  return (\n                    <Box\n                      key={q?.question || 'answer'}\n                      flexDirection=\"column\"\n                      marginLeft={1}\n                    >\n                      <Text>\n                        {figures.bullet} {q?.question || 'Question'}\n                      </Text>\n                      <Box marginLeft={2}>\n                        <Text color=\"success\">\n                          {figures.arrowRight} {answer}\n                        </Text>\n                      </Box>\n                    </Box>\n                  )\n                })}\n            </Box>\n          )}\n\n          <PermissionRuleExplanation\n            permissionResult={permissionResult}\n            toolType=\"tool\"\n          />\n          <Text color=\"inactive\">Ready to submit your answers?</Text>\n          <Box marginTop={1}>\n            <Select\n              options={[\n                {\n                  type: 'text' as const,\n                  label: 'Submit answers',\n                  value: 'submit',\n                },\n                { type: 'text' as const, label: 'Cancel', value: 'cancel' },\n              ]}\n              onChange={value => onFinalResponse(value as 'submit' | 'cancel')}\n              onCancel={() => onFinalResponse('cancel')}\n            />\n          </Box>\n        </Box>\n      </Box>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/components/permissions/AskUserQuestionPermissionRequest/use-multiple-choice-state.ts b/src/components/permissions/AskUserQuestionPermissionRequest/use-multiple-choice-state.ts new file mode 100644 index 0000000000000000000000000000000000000000..d500e8dafb71f2410d4a08b26d61fe2cbd40f552 --- /dev/null +++ b/src/components/permissions/AskUserQuestionPermissionRequest/use-multiple-choice-state.ts @@ -0,0 +1,179 @@ +import { useCallback, useReducer } from 'react' + +export type AnswerValue = string + +export type QuestionState = { + selectedValue?: string | string[] + textInputValue: string +} + +type State = { + currentQuestionIndex: number + answers: Record + questionStates: Record + isInTextInput: boolean +} + +type Action = + | { type: 'next-question' } + | { type: 'prev-question' } + | { + type: 'update-question-state' + questionText: string + updates: Partial + isMultiSelect: boolean + } + | { + type: 'set-answer' + questionText: string + answer: string + shouldAdvance: boolean + } + | { type: 'set-text-input-mode'; isInInput: boolean } + +function reducer(state: State, action: Action): State { + switch (action.type) { + case 'next-question': + return { + ...state, + currentQuestionIndex: state.currentQuestionIndex + 1, + isInTextInput: false, + } + + case 'prev-question': + return { + ...state, + currentQuestionIndex: Math.max(0, state.currentQuestionIndex - 1), + isInTextInput: false, + } + + case 'update-question-state': { + const existing = state.questionStates[action.questionText] + const newState: QuestionState = { + selectedValue: + action.updates.selectedValue ?? + existing?.selectedValue ?? + (action.isMultiSelect ? [] : undefined), + textInputValue: + action.updates.textInputValue ?? existing?.textInputValue ?? '', + } + + return { + ...state, + questionStates: { + ...state.questionStates, + [action.questionText]: newState, + }, + } + } + + case 'set-answer': { + const newState = { + ...state, + answers: { + ...state.answers, + [action.questionText]: action.answer, + }, + } + + if (action.shouldAdvance) { + return { + ...newState, + currentQuestionIndex: newState.currentQuestionIndex + 1, + isInTextInput: false, + } + } + + return newState + } + + case 'set-text-input-mode': + return { + ...state, + isInTextInput: action.isInInput, + } + } +} + +const INITIAL_STATE: State = { + currentQuestionIndex: 0, + answers: {}, + questionStates: {}, + isInTextInput: false, +} + +export type MultipleChoiceState = { + currentQuestionIndex: number + answers: Record + questionStates: Record + isInTextInput: boolean + nextQuestion: () => void + prevQuestion: () => void + updateQuestionState: ( + questionText: string, + updates: Partial, + isMultiSelect: boolean, + ) => void + setAnswer: ( + questionText: string, + answer: string, + shouldAdvance?: boolean, + ) => void + setTextInputMode: (isInInput: boolean) => void +} + +export function useMultipleChoiceState(): MultipleChoiceState { + const [state, dispatch] = useReducer(reducer, INITIAL_STATE) + + const nextQuestion = useCallback(() => { + dispatch({ type: 'next-question' }) + }, []) + + const prevQuestion = useCallback(() => { + dispatch({ type: 'prev-question' }) + }, []) + + const updateQuestionState = useCallback( + ( + questionText: string, + updates: Partial, + isMultiSelect: boolean, + ) => { + dispatch({ + type: 'update-question-state', + questionText, + updates, + isMultiSelect, + }) + }, + [], + ) + + const setAnswer = useCallback( + (questionText: string, answer: string, shouldAdvance: boolean = true) => { + dispatch({ + type: 'set-answer', + questionText, + answer, + shouldAdvance, + }) + }, + [], + ) + + const setTextInputMode = useCallback((isInInput: boolean) => { + dispatch({ type: 'set-text-input-mode', isInInput }) + }, []) + + return { + currentQuestionIndex: state.currentQuestionIndex, + answers: state.answers, + questionStates: state.questionStates, + isInTextInput: state.isInTextInput, + nextQuestion, + prevQuestion, + updateQuestionState, + setAnswer, + setTextInputMode, + } +} diff --git a/src/components/permissions/ExitPlanModePermissionRequest/ExitPlanModePermissionRequest.tsx b/src/components/permissions/ExitPlanModePermissionRequest/ExitPlanModePermissionRequest.tsx new file mode 100644 index 0000000000000000000000000000000000000000..8e0ca6c5e070dcdd9e78a3756b5cc72dda04dd2e --- /dev/null +++ b/src/components/permissions/ExitPlanModePermissionRequest/ExitPlanModePermissionRequest.tsx @@ -0,0 +1,768 @@ +import { feature } from 'bun:bundle'; +import type { UUID } from 'crypto'; +import figures from 'figures'; +import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'; +import { useNotifications } from 'src/context/notifications.js'; +import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js'; +import { useAppState, useAppStateStore, useSetAppState } from 'src/state/AppState.js'; +import { getSdkBetas, getSessionId, isSessionPersistenceDisabled, setHasExitedPlanMode, setNeedsAutoModeExitAttachment, setNeedsPlanModeExitAttachment } from '../../../bootstrap/state.js'; +import { generateSessionName } from '../../../commands/rename/generateSessionName.js'; +import { launchUltraplan } from '../../../commands/ultraplan.js'; +import type { KeyboardEvent } from '../../../ink/events/keyboard-event.js'; +import { Box, Text } from '../../../ink.js'; +import type { AppState } from '../../../state/AppStateStore.js'; +import { AGENT_TOOL_NAME } from '../../../tools/AgentTool/constants.js'; +import { EXIT_PLAN_MODE_V2_TOOL_NAME } from '../../../tools/ExitPlanModeTool/constants.js'; +import type { AllowedPrompt } from '../../../tools/ExitPlanModeTool/ExitPlanModeV2Tool.js'; +import { TEAM_CREATE_TOOL_NAME } from '../../../tools/TeamCreateTool/constants.js'; +import { isAgentSwarmsEnabled } from '../../../utils/agentSwarmsEnabled.js'; +import { calculateContextPercentages, getContextWindowForModel } from '../../../utils/context.js'; +import { getExternalEditor } from '../../../utils/editor.js'; +import { getDisplayPath } from '../../../utils/file.js'; +import { toIDEDisplayName } from '../../../utils/ide.js'; +import { logError } from '../../../utils/log.js'; +import { enqueuePendingNotification } from '../../../utils/messageQueueManager.js'; +import { createUserMessage } from '../../../utils/messages.js'; +import { getMainLoopModel, getRuntimeMainLoopModel } from '../../../utils/model/model.js'; +import { createPromptRuleContent, isClassifierPermissionsEnabled, PROMPT_PREFIX } from '../../../utils/permissions/bashClassifier.js'; +import { type PermissionMode, toExternalPermissionMode } from '../../../utils/permissions/PermissionMode.js'; +import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'; +import { isAutoModeGateEnabled, restoreDangerousPermissions, stripDangerousPermissionsForAutoMode } from '../../../utils/permissions/permissionSetup.js'; +import { getPewterLedgerVariant, isPlanModeInterviewPhaseEnabled } from '../../../utils/planModeV2.js'; +import { getPlan, getPlanFilePath } from '../../../utils/plans.js'; +import { editFileInEditor, editPromptInEditor } from '../../../utils/promptEditor.js'; +import { getCurrentSessionTitle, getTranscriptPath, saveAgentName, saveCustomTitle } from '../../../utils/sessionStorage.js'; +import { getSettings_DEPRECATED } from '../../../utils/settings/settings.js'; +import { type OptionWithDescription, Select } from '../../CustomSelect/index.js'; +import { Markdown } from '../../Markdown.js'; +import { PermissionDialog } from '../PermissionDialog.js'; +import type { PermissionRequestProps } from '../PermissionRequest.js'; +import { PermissionRuleExplanation } from '../PermissionRuleExplanation.js'; + +/* eslint-disable @typescript-eslint/no-require-imports */ +const autoModeStateModule = feature('TRANSCRIPT_CLASSIFIER') ? require('../../../utils/permissions/autoModeState.js') as typeof import('../../../utils/permissions/autoModeState.js') : null; +import type { Base64ImageSource, ImageBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs'; +/* eslint-enable @typescript-eslint/no-require-imports */ +import type { PastedContent } from '../../../utils/config.js'; +import type { ImageDimensions } from '../../../utils/imageResizer.js'; +import { maybeResizeAndDownsampleImageBlock } from '../../../utils/imageResizer.js'; +import { cacheImagePath, storeImage } from '../../../utils/imageStore.js'; +type ResponseValue = 'yes-bypass-permissions' | 'yes-accept-edits' | 'yes-accept-edits-keep-context' | 'yes-default-keep-context' | 'yes-resume-auto-mode' | 'yes-auto-clear-context' | 'ultraplan' | 'no'; + +/** + * Build permission updates for plan approval, including prompt-based rules if provided. + * Prompt-based rules are only added when classifier permissions are enabled (Ant-only). + */ +export function buildPermissionUpdates(mode: PermissionMode, allowedPrompts?: AllowedPrompt[]): PermissionUpdate[] { + const updates: PermissionUpdate[] = [{ + type: 'setMode', + mode: toExternalPermissionMode(mode), + destination: 'session' + }]; + + // Add prompt-based permission rules if provided (Ant-only feature) + if (isClassifierPermissionsEnabled() && allowedPrompts && allowedPrompts.length > 0) { + updates.push({ + type: 'addRules', + rules: allowedPrompts.map(p => ({ + toolName: p.tool, + ruleContent: createPromptRuleContent(p.prompt) + })), + behavior: 'allow', + destination: 'session' + }); + } + return updates; +} + +/** + * Auto-name the session from the plan content when the user accepts a plan, + * if they haven't already named it via /rename or --name. Fire-and-forget. + * Mirrors /rename: kebab-case name, updates the prompt-border badge. + */ +export function autoNameSessionFromPlan(plan: string, setAppState: (updater: (prev: AppState) => AppState) => void, isClearContext: boolean): void { + if (isSessionPersistenceDisabled() || getSettings_DEPRECATED()?.cleanupPeriodDays === 0) { + return; + } + // On clear-context, the current session is about to be abandoned — its + // title (which may have been set by a PRIOR auto-name) is irrelevant. + // Checking it would make the feature self-defeating after first use. + if (!isClearContext && getCurrentSessionTitle(getSessionId())) return; + void generateSessionName( + // generateSessionName tail-slices to the last 1000 chars (correct for + // conversations, where recency matters). Plans front-load the goal and + // end with testing steps — head-slice so Haiku sees the summary. + [createUserMessage({ + content: plan.slice(0, 1000) + })], new AbortController().signal).then(async name => { + // On clear-context acceptance, regenerateSessionId() has run by now — + // this intentionally names the NEW execution session. Do not "fix" by + // capturing sessionId once; that would name the abandoned planning session. + if (!name || getCurrentSessionTitle(getSessionId())) return; + const sessionId = getSessionId() as UUID; + const fullPath = getTranscriptPath(); + await saveCustomTitle(sessionId, name, fullPath, 'auto'); + await saveAgentName(sessionId, name, fullPath, 'auto'); + setAppState(prev => { + if (prev.standaloneAgentContext?.name === name) return prev; + return { + ...prev, + standaloneAgentContext: { + ...prev.standaloneAgentContext, + name + } + }; + }); + }).catch(logError); +} +export function ExitPlanModePermissionRequest({ + toolUseConfirm, + onDone, + onReject, + workerBadge, + setStickyFooter +}: PermissionRequestProps): React.ReactNode { + const toolPermissionContext = useAppState(s => s.toolPermissionContext); + const setAppState = useSetAppState(); + const store = useAppStateStore(); + const { + addNotification + } = useNotifications(); + // Feedback text from the 'No' option's input. Threaded through onAllow as + // acceptFeedback when the user approves — lets users annotate the plan + // ("also update the README") without a reject+re-plan round-trip. + const [planFeedback, setPlanFeedback] = useState(''); + const [pastedContents, setPastedContents] = useState>({}); + const nextPasteIdRef = useRef(0); + const showClearContext = useAppState(s => s.settings.showClearContextOnPlanAccept) ?? false; + const ultraplanSessionUrl = useAppState(s => s.ultraplanSessionUrl); + const ultraplanLaunching = useAppState(s => s.ultraplanLaunching); + // Hide the Ultraplan button while a session is active or launching — + // selecting it would dismiss the dialog and reject locally before + // launchUltraplan can notice the session exists and return "already polling". + // feature() must sit directly in an if/ternary (bun:bundle DCE constraint). + const showUltraplan = feature('ULTRAPLAN') ? !ultraplanSessionUrl && !ultraplanLaunching : false; + const usage = toolUseConfirm.assistantMessage.message.usage; + const { + mode, + isAutoModeAvailable, + isBypassPermissionsModeAvailable + } = toolPermissionContext; + const options = useMemo(() => buildPlanApprovalOptions({ + showClearContext, + showUltraplan, + usedPercent: showClearContext ? getContextUsedPercent(usage, mode) : null, + isAutoModeAvailable, + isBypassPermissionsModeAvailable, + onFeedbackChange: setPlanFeedback + }), [showClearContext, showUltraplan, usage, mode, isAutoModeAvailable, isBypassPermissionsModeAvailable]); + function onImagePaste(base64Image: string, mediaType?: string, filename?: string, dimensions?: ImageDimensions, _sourcePath?: string) { + const pasteId = nextPasteIdRef.current++; + const newContent: PastedContent = { + id: pasteId, + type: 'image', + content: base64Image, + mediaType: mediaType || 'image/png', + filename: filename || 'Pasted image', + dimensions + }; + cacheImagePath(newContent); + void storeImage(newContent); + setPastedContents(prev => ({ + ...prev, + [pasteId]: newContent + })); + } + const onRemoveImage = useCallback((id: number) => { + setPastedContents(prev => { + const next = { + ...prev + }; + delete next[id]; + return next; + }); + }, []); + const imageAttachments = Object.values(pastedContents).filter(c => c.type === 'image'); + const hasImages = imageAttachments.length > 0; + + // TODO: Delete the branch after moving to V2 + // Use tool name to detect V2 instead of checking input.plan, because PR #10394 + // injects plan content into input.plan for hooks/SDK, which broke the old detection + // (see issue #10878) + const isV2 = toolUseConfirm.tool.name === EXIT_PLAN_MODE_V2_TOOL_NAME; + const inputPlan = isV2 ? undefined : toolUseConfirm.input.plan as string | undefined; + const planFilePath = isV2 ? getPlanFilePath() : undefined; + + // Extract allowed prompts requested by the plan (Ant-only feature) + const allowedPrompts = toolUseConfirm.input.allowedPrompts as AllowedPrompt[] | undefined; + + // Get the raw plan to check if it's empty + const rawPlan = inputPlan ?? getPlan(); + const isEmpty = !rawPlan || rawPlan.trim() === ''; + + // Capture the variant once on mount. GrowthBook reads from a disk cache + // so the value is stable across a single planning session. undefined = + // control arm. The variant is a fixed 3-value enum of short literals, + // not user input. + const [planStructureVariant] = useState(() => (getPewterLedgerVariant() ?? undefined) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS); + const [currentPlan, setCurrentPlan] = useState(() => { + if (inputPlan) return inputPlan; + const plan = getPlan(); + return plan ?? 'No plan found. Please write your plan to the plan file first.'; + }); + const [showSaveMessage, setShowSaveMessage] = useState(false); + // Track Ctrl+G local edits so updatedInput can include the plan (the tool + // only echoes the plan in tool_result when input.plan is set — otherwise + // the model already has it in context from writing the plan file). + const [planEditedLocally, setPlanEditedLocally] = useState(false); + + // Auto-hide save message after 5 seconds + useEffect(() => { + if (showSaveMessage) { + const timer = setTimeout(setShowSaveMessage, 5000, false); + return () => clearTimeout(timer); + } + }, [showSaveMessage]); + + // Handle Ctrl+G to edit plan in $EDITOR, Shift+Tab for auto-accept edits + const handleKeyDown = (e: KeyboardEvent): void => { + if (e.ctrl && e.key === 'g') { + e.preventDefault(); + logEvent('tengu_plan_external_editor_used', {}); + void (async () => { + if (isV2 && planFilePath) { + const result = await editFileInEditor(planFilePath); + if (result.error) { + addNotification({ + key: 'external-editor-error', + text: result.error, + color: 'warning', + priority: 'high' + }); + } + if (result.content !== null) { + if (result.content !== currentPlan) setPlanEditedLocally(true); + setCurrentPlan(result.content); + setShowSaveMessage(true); + } + } else { + const result = await editPromptInEditor(currentPlan); + if (result.error) { + addNotification({ + key: 'external-editor-error', + text: result.error, + color: 'warning', + priority: 'high' + }); + } + if (result.content !== null && result.content !== currentPlan) { + setCurrentPlan(result.content); + setShowSaveMessage(true); + } + } + })(); + return; + } + + // Shift+Tab immediately selects "auto-accept edits" + if (e.shift && e.key === 'tab') { + e.preventDefault(); + void handleResponse(showClearContext ? 'yes-accept-edits' : 'yes-accept-edits-keep-context'); + return; + } + }; + async function handleResponse(value: ResponseValue): Promise { + const trimmedFeedback = planFeedback.trim(); + const acceptFeedback = trimmedFeedback || undefined; + + // Ultraplan: reject locally, teleport the plan to CCR as a seed draft. + // Dialog dismisses immediately so the query loop unblocks; the teleport + // runs detached and its launch message lands via the command queue. + if (value === 'ultraplan') { + logEvent('tengu_plan_exit', { + planLengthChars: currentPlan.length, + outcome: 'ultraplan' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(), + planStructureVariant + }); + onDone(); + onReject(); + toolUseConfirm.onReject('Plan being refined via Ultraplan — please wait for the result.'); + void launchUltraplan({ + blurb: '', + seedPlan: currentPlan, + getAppState: store.getState, + setAppState: store.setState, + signal: new AbortController().signal + }).then(msg => enqueuePendingNotification({ + value: msg, + mode: 'task-notification' + })).catch(logError); + return; + } + + // V1: pass plan in input. V2: plan is on disk, but if the user edited it + // via Ctrl+G we pass it through so the tool echoes the edit in tool_result + // (otherwise the model never sees the user's changes). + const updatedInput = isV2 && !planEditedLocally ? {} : { + plan: currentPlan + }; + + // If auto was active during plan (from auto mode or opt-in) and NOT going + // to auto, deactivate auto + restore permissions + fire exit attachment. + if (feature('TRANSCRIPT_CLASSIFIER')) { + const goingToAuto = (value === 'yes-resume-auto-mode' || value === 'yes-auto-clear-context') && isAutoModeGateEnabled(); + // isAutoModeActive() is the authoritative signal — prePlanMode/ + // strippedDangerousRules are stale after transitionPlanAutoMode + // deactivates mid-plan (would cause duplicate exit attachment). + const autoWasUsedDuringPlan = autoModeStateModule?.isAutoModeActive() ?? false; + if (value !== 'no' && !goingToAuto && autoWasUsedDuringPlan) { + autoModeStateModule?.setAutoModeActive(false); + setNeedsAutoModeExitAttachment(true); + setAppState(prev => ({ + ...prev, + toolPermissionContext: { + ...restoreDangerousPermissions(prev.toolPermissionContext), + prePlanMode: undefined + } + })); + } + } + + // Clear-context options: set pending plan implementation and reject the dialog + // The REPL will handle context clear and trigger a fresh query + // Keep-context options skip this block and go through the normal flow below + const isResumeAutoOption = feature('TRANSCRIPT_CLASSIFIER') ? value === 'yes-resume-auto-mode' : false; + const isKeepContextOption = value === 'yes-accept-edits-keep-context' || value === 'yes-default-keep-context' || isResumeAutoOption; + if (value !== 'no') { + autoNameSessionFromPlan(currentPlan, setAppState, !isKeepContextOption); + } + if (value !== 'no' && !isKeepContextOption) { + // Determine the permission mode based on the selected option + let mode: PermissionMode = 'default'; + if (value === 'yes-bypass-permissions') { + mode = 'bypassPermissions'; + } else if (value === 'yes-accept-edits') { + mode = 'acceptEdits'; + } else if (feature('TRANSCRIPT_CLASSIFIER') && value === 'yes-auto-clear-context' && isAutoModeGateEnabled()) { + // REPL's processInitialMessage handles stripDangerousPermissions + mode, + // but does NOT set autoModeActive. Gate-off falls through to 'default'. + mode = 'auto'; + autoModeStateModule?.setAutoModeActive(true); + } + + // Log plan exit event + logEvent('tengu_plan_exit', { + planLengthChars: currentPlan.length, + outcome: value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + clearContext: true, + interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(), + planStructureVariant, + hasFeedback: !!acceptFeedback + }); + + // Set initial message - REPL will handle context clear and fresh query + // Add verification instruction if the feature is enabled + // Dead code elimination: CLAUDE_CODE_VERIFY_PLAN='false' in external builds, so === 'true' check allows Bun to eliminate the string + const verificationInstruction = undefined === 'true' ? `\n\nIMPORTANT: When you have finished implementing the plan, you MUST call the "VerifyPlanExecution" tool directly (NOT the ${AGENT_TOOL_NAME} tool or an agent) to trigger background verification.` : ''; + + // Capture the transcript path before context is cleared (session ID will be regenerated) + const transcriptPath = getTranscriptPath(); + const transcriptHint = `\n\nIf you need specific details from before exiting plan mode (like exact code snippets, error messages, or content you generated), read the full transcript at: ${transcriptPath}`; + const teamHint = isAgentSwarmsEnabled() ? `\n\nIf this plan can be broken down into multiple independent tasks, consider using the ${TEAM_CREATE_TOOL_NAME} tool to create a team and parallelize the work.` : ''; + const feedbackSuffix = acceptFeedback ? `\n\nUser feedback on this plan: ${acceptFeedback}` : ''; + setAppState(prev => ({ + ...prev, + initialMessage: { + message: { + ...createUserMessage({ + content: `Implement the following plan:\n\n${currentPlan}${verificationInstruction}${transcriptHint}${teamHint}${feedbackSuffix}` + }), + planContent: currentPlan + }, + clearContext: true, + mode, + allowedPrompts + } + })); + setHasExitedPlanMode(true); + onDone(); + onReject(); + // Reject the tool use to unblock the query loop + // The REPL will see pendingInitialQuery and trigger fresh query + toolUseConfirm.onReject(); + return; + } + + // Handle auto keep-context option — needs special handling because + // buildPermissionUpdates maps auto to 'default' via toExternalPermissionMode. + // We set the mode directly via setAppState and sync the bootstrap state. + if (feature('TRANSCRIPT_CLASSIFIER') && value === 'yes-resume-auto-mode' && isAutoModeGateEnabled()) { + logEvent('tengu_plan_exit', { + planLengthChars: currentPlan.length, + outcome: value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + clearContext: false, + interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(), + planStructureVariant, + hasFeedback: !!acceptFeedback + }); + setHasExitedPlanMode(true); + setNeedsPlanModeExitAttachment(true); + autoModeStateModule?.setAutoModeActive(true); + setAppState(prev => ({ + ...prev, + toolPermissionContext: stripDangerousPermissionsForAutoMode({ + ...prev.toolPermissionContext, + mode: 'auto', + prePlanMode: undefined + }) + })); + onDone(); + toolUseConfirm.onAllow(updatedInput, [], acceptFeedback); + return; + } + + // Handle keep-context options (goes through normal onAllow flow) + // yes-resume-auto-mode falls through here when the auto mode gate is + // disabled (e.g. circuit breaker fired after the dialog rendered). + // Without this fallback the function would return without resolving the + // dialog, leaving the query loop blocked and safety state corrupted. + const keepContextModes: Record = { + 'yes-accept-edits-keep-context': toolPermissionContext.isBypassPermissionsModeAvailable ? 'bypassPermissions' : 'acceptEdits', + 'yes-default-keep-context': 'default', + ...(feature('TRANSCRIPT_CLASSIFIER') ? { + 'yes-resume-auto-mode': 'default' as const + } : {}) + }; + const keepContextMode = keepContextModes[value]; + if (keepContextMode) { + logEvent('tengu_plan_exit', { + planLengthChars: currentPlan.length, + outcome: value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + clearContext: false, + interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(), + planStructureVariant, + hasFeedback: !!acceptFeedback + }); + setHasExitedPlanMode(true); + setNeedsPlanModeExitAttachment(true); + onDone(); + toolUseConfirm.onAllow(updatedInput, buildPermissionUpdates(keepContextMode, allowedPrompts), acceptFeedback); + return; + } + + // Handle standard approval options + const standardModes: Record = { + 'yes-bypass-permissions': 'bypassPermissions', + 'yes-accept-edits': 'acceptEdits' + }; + const standardMode = standardModes[value]; + if (standardMode) { + logEvent('tengu_plan_exit', { + planLengthChars: currentPlan.length, + outcome: value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(), + planStructureVariant, + hasFeedback: !!acceptFeedback + }); + setHasExitedPlanMode(true); + setNeedsPlanModeExitAttachment(true); + onDone(); + toolUseConfirm.onAllow(updatedInput, buildPermissionUpdates(standardMode, allowedPrompts), acceptFeedback); + return; + } + + // Handle 'no' - stay in plan mode + if (value === 'no') { + if (!trimmedFeedback && !hasImages) { + // No feedback yet - user is still on the input field + return; + } + logEvent('tengu_plan_exit', { + planLengthChars: currentPlan.length, + outcome: 'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(), + planStructureVariant + }); + + // Convert pasted images to ImageBlockParam[] with resizing + let imageBlocks: ImageBlockParam[] | undefined; + if (hasImages) { + imageBlocks = await Promise.all(imageAttachments.map(async img => { + const block: ImageBlockParam = { + type: 'image', + source: { + type: 'base64', + media_type: (img.mediaType || 'image/png') as Base64ImageSource['media_type'], + data: img.content + } + }; + const resized = await maybeResizeAndDownsampleImageBlock(block); + return resized.block; + })); + } + onDone(); + onReject(); + toolUseConfirm.onReject(trimmedFeedback || (hasImages ? '(See attached image)' : undefined), imageBlocks && imageBlocks.length > 0 ? imageBlocks : undefined); + } + } + const editor = getExternalEditor(); + const editorName = editor ? toIDEDisplayName(editor) : null; + + // Sticky footer: when setStickyFooter is provided (fullscreen mode), the + // Select options render in FullscreenLayout's `bottom` slot so they stay + // visible while the user scrolls through a long plan. handleResponse is + // wrapped in a ref so the JSX (set once per options/images change) can call + // the latest closure without re-registering on every keystroke. React + // reconciles the sticky-footer Select by type, preserving focus/input state. + const handleResponseRef = useRef(handleResponse); + handleResponseRef.current = handleResponse; + const handleCancelRef = useRef<() => void>(undefined); + handleCancelRef.current = () => { + logEvent('tengu_plan_exit', { + planLengthChars: currentPlan.length, + outcome: 'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(), + planStructureVariant + }); + onDone(); + onReject(); + toolUseConfirm.onReject(); + }; + const useStickyFooter = !isEmpty && !!setStickyFooter; + useLayoutEffect(() => { + if (!useStickyFooter) return; + setStickyFooter( + Would you like to proceed? + + { + logEvent('tengu_plan_exit', { + planLengthChars: 0, + outcome: 'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(), + planStructureVariant + }); + onDone(); + onReject(); + toolUseConfirm.onReject(); + }} /> + + + ; + } + return + + + + Here is Claude's plan: + + + {currentPlan} + + + + {isClassifierPermissionsEnabled() && allowedPrompts && allowedPrompts.length > 0 && + Requested permissions: + {allowedPrompts.map((p, i) => + {' '}· {p.tool}({PROMPT_PREFIX} {p.prompt}) + )} + } + {!useStickyFooter && <> + + Claude has written up a plan and is ready to execute. Would + you like to proceed? + + + ; + $[32] = onCancel; + $[33] = t11; + $[34] = t13; + } else { + t13 = $[34]; + } + let t14; + if ($[35] !== ruleDescription || $[36] !== t13 || $[37] !== t9) { + t14 = {t9}{ruleDescription}{t10}{t13}; + $[35] = ruleDescription; + $[36] = t13; + $[37] = t9; + $[38] = t14; + } else { + t14 = $[38]; + } + let t15; + if ($[39] !== footer || $[40] !== t14) { + t15 = <>{t14}{footer}; + $[39] = footer; + $[40] = t14; + $[41] = t15; + } else { + t15 = $[41]; + } + return t15; +} +type RulesTabContentProps = { + options: Option[]; + searchQuery: string; + isSearchMode: boolean; + isFocused: boolean; + onSelect: (value: string) => void; + onCancel: () => void; + lastFocusedRuleKey: string | undefined; + cursorOffset?: number; + onHeaderFocusChange?: (focused: boolean) => void; +}; + +// Component for rendering rules tab content with full width support +function RulesTabContent(props) { + const $ = _c(26); + const { + options, + searchQuery, + isSearchMode, + isFocused, + onSelect, + onCancel, + lastFocusedRuleKey, + cursorOffset, + onHeaderFocusChange + } = props; + const tabWidth = useTabsWidth(); + const { + headerFocused, + focusHeader, + blurHeader + } = useTabHeaderFocus(); + let t0; + let t1; + if ($[0] !== blurHeader || $[1] !== headerFocused || $[2] !== isSearchMode) { + t0 = () => { + if (isSearchMode && headerFocused) { + blurHeader(); + } + }; + t1 = [isSearchMode, headerFocused, blurHeader]; + $[0] = blurHeader; + $[1] = headerFocused; + $[2] = isSearchMode; + $[3] = t0; + $[4] = t1; + } else { + t0 = $[3]; + t1 = $[4]; + } + useEffect(t0, t1); + let t2; + let t3; + if ($[5] !== headerFocused || $[6] !== onHeaderFocusChange) { + t2 = () => { + onHeaderFocusChange?.(headerFocused); + }; + t3 = [headerFocused, onHeaderFocusChange]; + $[5] = headerFocused; + $[6] = onHeaderFocusChange; + $[7] = t2; + $[8] = t3; + } else { + t2 = $[7]; + t3 = $[8]; + } + useEffect(t2, t3); + const t4 = isSearchMode && !headerFocused; + let t5; + if ($[9] !== cursorOffset || $[10] !== isFocused || $[11] !== searchQuery || $[12] !== t4 || $[13] !== tabWidth) { + t5 = ; + $[9] = cursorOffset; + $[10] = isFocused; + $[11] = searchQuery; + $[12] = t4; + $[13] = tabWidth; + $[14] = t5; + } else { + t5 = $[14]; + } + const t6 = Math.min(10, options.length); + const t7 = isSearchMode || headerFocused; + let t8; + if ($[15] !== focusHeader || $[16] !== lastFocusedRuleKey || $[17] !== onCancel || $[18] !== onSelect || $[19] !== options || $[20] !== t6 || $[21] !== t7) { + t8 = ; + $[25] = focusHeader; + $[26] = headerFocused; + $[27] = options; + $[28] = t12; + $[29] = t13; + } else { + t13 = $[29]; + } + return t13; +} +function _temp3() { + return new Set(); +} +function _temp2() { + return new Set(); +} +function _temp() { + return getAutoModeDenials(); +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","Box","Text","useInput","AutoModeDenial","getAutoModeDenials","Select","StatusIcon","useTabHeaderFocus","Props","onHeaderFocusChange","focused","onStateChange","state","approved","Set","retry","denials","RecentDenialsTab","t0","$","_c","headerFocused","focusHeader","t1","t2","_temp","setApproved","_temp2","setRetry","_temp3","focusedIdx","setFocusedIdx","t3","t4","t5","Symbol","for","value","idx","Number","prev","next","has","delete","add","handleSelect","t6","value_0","handleFocus","t7","input","_key","prev_0","next_0","prev_1","next_1","t8","length","t9","isActive","t10","t11","d","idx_0","isApproved","suffix","label","display","String","map","options","t12","Math","min","t13"],"sources":["RecentDenialsTab.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useCallback, useEffect, useState } from 'react'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- 'r' is a view-specific key, not a global keybinding\nimport { Box, Text, useInput } from '../../../ink.js'\nimport {\n  type AutoModeDenial,\n  getAutoModeDenials,\n} from '../../../utils/autoModeDenials.js'\nimport { Select } from '../../CustomSelect/select.js'\nimport { StatusIcon } from '../../design-system/StatusIcon.js'\nimport { useTabHeaderFocus } from '../../design-system/Tabs.js'\n\ntype Props = {\n  onHeaderFocusChange?: (focused: boolean) => void\n  /** Called when approved/retry state changes so parent can act on exit */\n  onStateChange: (state: {\n    approved: Set<number>\n    retry: Set<number>\n    denials: readonly AutoModeDenial[]\n  }) => void\n}\n\nexport function RecentDenialsTab({\n  onHeaderFocusChange,\n  onStateChange,\n}: Props): React.ReactNode {\n  const { headerFocused, focusHeader } = useTabHeaderFocus()\n  useEffect(() => {\n    onHeaderFocusChange?.(headerFocused)\n  }, [headerFocused, onHeaderFocusChange])\n\n  // Snapshot on mount — approved/retry Sets key by index, and the live store\n  // prepends. A concurrent denial would shift all indices mid-edit.\n  const [denials] = useState(() => getAutoModeDenials())\n\n  const [approved, setApproved] = useState<Set<number>>(() => new Set())\n  const [retry, setRetry] = useState<Set<number>>(() => new Set())\n  const [focusedIdx, setFocusedIdx] = useState(0)\n\n  useEffect(() => {\n    onStateChange({ approved, retry, denials })\n  }, [approved, retry, denials, onStateChange])\n\n  const handleSelect = useCallback((value: string) => {\n    const idx = Number(value)\n    setApproved(prev => {\n      const next = new Set(prev)\n      if (next.has(idx)) next.delete(idx)\n      else next.add(idx)\n      return next\n    })\n  }, [])\n\n  const handleFocus = useCallback((value: string) => {\n    setFocusedIdx(Number(value))\n  }, [])\n\n  useInput(\n    (input, _key) => {\n      if (input === 'r') {\n        setRetry(prev => {\n          const next = new Set(prev)\n          if (next.has(focusedIdx)) next.delete(focusedIdx)\n          else next.add(focusedIdx)\n          return next\n        })\n        // Retry implies approve\n        setApproved(prev => {\n          if (prev.has(focusedIdx)) return prev\n          const next = new Set(prev)\n          next.add(focusedIdx)\n          return next\n        })\n      }\n    },\n    { isActive: denials.length > 0 },\n  )\n\n  if (denials.length === 0) {\n    return (\n      <Text dimColor>\n        No recent denials. Commands denied by the auto mode classifier will\n        appear here.\n      </Text>\n    )\n  }\n\n  const options = denials.map((d, idx) => {\n    const isApproved = approved.has(idx)\n    const suffix = retry.has(idx) ? ' (retry)' : ''\n    return {\n      label: (\n        <Text>\n          <StatusIcon status={isApproved ? 'success' : 'error'} withSpace />\n          {d.display}\n          <Text dimColor>{suffix}</Text>\n        </Text>\n      ),\n      value: String(idx),\n    }\n  })\n\n  return (\n    <Box flexDirection=\"column\">\n      <Text>Commands recently denied by the auto mode classifier.</Text>\n      <Box marginTop={1}>\n        <Select\n          options={options}\n          onChange={handleSelect}\n          onFocus={handleFocus}\n          visibleOptionCount={Math.min(10, options.length)}\n          isDisabled={headerFocused}\n          onUpFromFirstItem={focusHeader}\n        />\n      </Box>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/components/permissions/shellPermissionHelpers.tsx b/src/components/permissions/shellPermissionHelpers.tsx new file mode 100644 index 0000000000000000000000000000000000000000..e4408a605c1413f74846d296a63ff65b1d38ef6f --- /dev/null +++ b/src/components/permissions/shellPermissionHelpers.tsx @@ -0,0 +1,164 @@ +import { basename, sep } from 'path'; +import React, { type ReactNode } from 'react'; +import { getOriginalCwd } from '../../bootstrap/state.js'; +import { Text } from '../../ink.js'; +import type { PermissionUpdate } from '../../utils/permissions/PermissionUpdateSchema.js'; +import { permissionRuleExtractPrefix } from '../../utils/permissions/shellRuleMatching.js'; +function commandListDisplay(commands: string[]): ReactNode { + switch (commands.length) { + case 0: + return ''; + case 1: + return {commands[0]}; + case 2: + return + {commands[0]} and {commands[1]} + ; + default: + return + {commands.slice(0, -1).join(', ')}, and{' '} + {commands.slice(-1)[0]} + ; + } +} +function commandListDisplayTruncated(commands: string[]): ReactNode { + // Check if the plain text representation would be too long + const plainText = commands.join(', '); + if (plainText.length > 50) { + return 'similar'; + } + return commandListDisplay(commands); +} +function formatPathList(paths: string[]): ReactNode { + if (paths.length === 0) return ''; + + // Extract directory names from paths + const names = paths.map(p => basename(p) || p); + if (names.length === 1) { + return + {names[0]} + {sep} + ; + } + if (names.length === 2) { + return + {names[0]} + {sep} and {names[1]} + {sep} + ; + } + + // For 3+, show first two with "and N more" + return + {names[0]} + {sep}, {names[1]} + {sep} and {paths.length - 2} more + ; +} + +/** + * Generate the label for the "Yes, and apply suggestions" option in shell + * permission dialogs (Bash, PowerShell). Parametrized by the shell tool name + * and an optional command transform (e.g., Bash strips output redirections so + * filenames don't show as commands). + */ +export function generateShellSuggestionsLabel(suggestions: PermissionUpdate[], shellToolName: string, commandTransform?: (command: string) => string): ReactNode | null { + // Collect all rules for display + const allRules = suggestions.filter(s => s.type === 'addRules').flatMap(s => s.rules || []); + + // Separate Read rules from shell rules + const readRules = allRules.filter(r => r.toolName === 'Read'); + const shellRules = allRules.filter(r => r.toolName === shellToolName); + + // Get directory info + const directories = suggestions.filter(s => s.type === 'addDirectories').flatMap(s => s.directories || []); + + // Extract paths from Read rules (keep separate from directories) + const readPaths = readRules.map(r => r.ruleContent?.replace('/**', '') || '').filter(p => p); + + // Extract shell command prefixes, optionally transforming for display + const shellCommands = [...new Set(shellRules.flatMap(rule => { + if (!rule.ruleContent) return []; + const command = permissionRuleExtractPrefix(rule.ruleContent) ?? rule.ruleContent; + return commandTransform ? commandTransform(command) : command; + }))]; + + // Check what we have + const hasDirectories = directories.length > 0; + const hasReadPaths = readPaths.length > 0; + const hasCommands = shellCommands.length > 0; + + // Handle single type cases + if (hasReadPaths && !hasDirectories && !hasCommands) { + // Only Read rules - use "reading from" language + if (readPaths.length === 1) { + const firstPath = readPaths[0]!; + const dirName = basename(firstPath) || firstPath; + return + Yes, allow reading from {dirName} + {sep} from this project + ; + } + + // Multiple read paths + return + Yes, allow reading from {formatPathList(readPaths)} from this project + ; + } + if (hasDirectories && !hasReadPaths && !hasCommands) { + // Only directory permissions - use "access to" language + if (directories.length === 1) { + const firstDir = directories[0]!; + const dirName = basename(firstDir) || firstDir; + return + Yes, and always allow access to {dirName} + {sep} from this project + ; + } + + // Multiple directories + return + Yes, and always allow access to {formatPathList(directories)} from this + project + ; + } + if (hasCommands && !hasDirectories && !hasReadPaths) { + // Only shell command permissions + return + {"Yes, and don't ask again for "} + {commandListDisplayTruncated(shellCommands)} commands in{' '} + {getOriginalCwd()} + ; + } + + // Handle mixed cases + if ((hasDirectories || hasReadPaths) && !hasCommands) { + // Combine directories and read paths since they're both path access + const allPaths = [...directories, ...readPaths]; + if (hasDirectories && hasReadPaths) { + // Mixed - use generic "access to" + return + Yes, and always allow access to {formatPathList(allPaths)} from this + project + ; + } + } + if ((hasDirectories || hasReadPaths) && hasCommands) { + // Build descriptive message for both types + const allPaths = [...directories, ...readPaths]; + + // Keep it concise but informative + if (allPaths.length === 1 && shellCommands.length === 1) { + return + Yes, and allow access to {formatPathList(allPaths)} and{' '} + {commandListDisplayTruncated(shellCommands)} commands + ; + } + return + Yes, and allow {formatPathList(allPaths)} access and{' '} + {commandListDisplayTruncated(shellCommands)} commands + ; + } + return null; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["basename","sep","React","ReactNode","getOriginalCwd","Text","PermissionUpdate","permissionRuleExtractPrefix","commandListDisplay","commands","length","slice","join","commandListDisplayTruncated","plainText","formatPathList","paths","names","map","p","generateShellSuggestionsLabel","suggestions","shellToolName","commandTransform","command","allRules","filter","s","type","flatMap","rules","readRules","r","toolName","shellRules","directories","readPaths","ruleContent","replace","shellCommands","Set","rule","hasDirectories","hasReadPaths","hasCommands","firstPath","dirName","firstDir","allPaths"],"sources":["shellPermissionHelpers.tsx"],"sourcesContent":["import { basename, sep } from 'path'\nimport React, { type ReactNode } from 'react'\nimport { getOriginalCwd } from '../../bootstrap/state.js'\nimport { Text } from '../../ink.js'\nimport type { PermissionUpdate } from '../../utils/permissions/PermissionUpdateSchema.js'\nimport { permissionRuleExtractPrefix } from '../../utils/permissions/shellRuleMatching.js'\n\nfunction commandListDisplay(commands: string[]): ReactNode {\n  switch (commands.length) {\n    case 0:\n      return ''\n    case 1:\n      return <Text bold>{commands[0]}</Text>\n    case 2:\n      return (\n        <Text>\n          <Text bold>{commands[0]}</Text> and <Text bold>{commands[1]}</Text>\n        </Text>\n      )\n    default:\n      return (\n        <Text>\n          <Text bold>{commands.slice(0, -1).join(', ')}</Text>, and{' '}\n          <Text bold>{commands.slice(-1)[0]}</Text>\n        </Text>\n      )\n  }\n}\n\nfunction commandListDisplayTruncated(commands: string[]): ReactNode {\n  // Check if the plain text representation would be too long\n  const plainText = commands.join(', ')\n  if (plainText.length > 50) {\n    return 'similar'\n  }\n  return commandListDisplay(commands)\n}\n\nfunction formatPathList(paths: string[]): ReactNode {\n  if (paths.length === 0) return ''\n\n  // Extract directory names from paths\n  const names = paths.map(p => basename(p) || p)\n\n  if (names.length === 1) {\n    return (\n      <Text>\n        <Text bold>{names[0]}</Text>\n        {sep}\n      </Text>\n    )\n  }\n  if (names.length === 2) {\n    return (\n      <Text>\n        <Text bold>{names[0]}</Text>\n        {sep} and <Text bold>{names[1]}</Text>\n        {sep}\n      </Text>\n    )\n  }\n\n  // For 3+, show first two with \"and N more\"\n  return (\n    <Text>\n      <Text bold>{names[0]}</Text>\n      {sep}, <Text bold>{names[1]}</Text>\n      {sep} and {paths.length - 2} more\n    </Text>\n  )\n}\n\n/**\n * Generate the label for the \"Yes, and apply suggestions\" option in shell\n * permission dialogs (Bash, PowerShell). Parametrized by the shell tool name\n * and an optional command transform (e.g., Bash strips output redirections so\n * filenames don't show as commands).\n */\nexport function generateShellSuggestionsLabel(\n  suggestions: PermissionUpdate[],\n  shellToolName: string,\n  commandTransform?: (command: string) => string,\n): ReactNode | null {\n  // Collect all rules for display\n  const allRules = suggestions\n    .filter(s => s.type === 'addRules')\n    .flatMap(s => s.rules || [])\n\n  // Separate Read rules from shell rules\n  const readRules = allRules.filter(r => r.toolName === 'Read')\n  const shellRules = allRules.filter(r => r.toolName === shellToolName)\n\n  // Get directory info\n  const directories = suggestions\n    .filter(s => s.type === 'addDirectories')\n    .flatMap(s => s.directories || [])\n\n  // Extract paths from Read rules (keep separate from directories)\n  const readPaths = readRules\n    .map(r => r.ruleContent?.replace('/**', '') || '')\n    .filter(p => p)\n\n  // Extract shell command prefixes, optionally transforming for display\n  const shellCommands = [\n    ...new Set(\n      shellRules.flatMap(rule => {\n        if (!rule.ruleContent) return []\n        const command =\n          permissionRuleExtractPrefix(rule.ruleContent) ?? rule.ruleContent\n        return commandTransform ? commandTransform(command) : command\n      }),\n    ),\n  ]\n\n  // Check what we have\n  const hasDirectories = directories.length > 0\n  const hasReadPaths = readPaths.length > 0\n  const hasCommands = shellCommands.length > 0\n\n  // Handle single type cases\n  if (hasReadPaths && !hasDirectories && !hasCommands) {\n    // Only Read rules - use \"reading from\" language\n    if (readPaths.length === 1) {\n      const firstPath = readPaths[0]!\n      const dirName = basename(firstPath) || firstPath\n      return (\n        <Text>\n          Yes, allow reading from <Text bold>{dirName}</Text>\n          {sep} from this project\n        </Text>\n      )\n    }\n\n    // Multiple read paths\n    return (\n      <Text>\n        Yes, allow reading from {formatPathList(readPaths)} from this project\n      </Text>\n    )\n  }\n\n  if (hasDirectories && !hasReadPaths && !hasCommands) {\n    // Only directory permissions - use \"access to\" language\n    if (directories.length === 1) {\n      const firstDir = directories[0]!\n      const dirName = basename(firstDir) || firstDir\n      return (\n        <Text>\n          Yes, and always allow access to <Text bold>{dirName}</Text>\n          {sep} from this project\n        </Text>\n      )\n    }\n\n    // Multiple directories\n    return (\n      <Text>\n        Yes, and always allow access to {formatPathList(directories)} from this\n        project\n      </Text>\n    )\n  }\n\n  if (hasCommands && !hasDirectories && !hasReadPaths) {\n    // Only shell command permissions\n    return (\n      <Text>\n        {\"Yes, and don't ask again for \"}\n        {commandListDisplayTruncated(shellCommands)} commands in{' '}\n        <Text bold>{getOriginalCwd()}</Text>\n      </Text>\n    )\n  }\n\n  // Handle mixed cases\n  if ((hasDirectories || hasReadPaths) && !hasCommands) {\n    // Combine directories and read paths since they're both path access\n    const allPaths = [...directories, ...readPaths]\n    if (hasDirectories && hasReadPaths) {\n      // Mixed - use generic \"access to\"\n      return (\n        <Text>\n          Yes, and always allow access to {formatPathList(allPaths)} from this\n          project\n        </Text>\n      )\n    }\n  }\n\n  if ((hasDirectories || hasReadPaths) && hasCommands) {\n    // Build descriptive message for both types\n    const allPaths = [...directories, ...readPaths]\n\n    // Keep it concise but informative\n    if (allPaths.length === 1 && shellCommands.length === 1) {\n      return (\n        <Text>\n          Yes, and allow access to {formatPathList(allPaths)} and{' '}\n          {commandListDisplayTruncated(shellCommands)} commands\n        </Text>\n      )\n    }\n\n    return (\n      <Text>\n        Yes, and allow {formatPathList(allPaths)} access and{' '}\n        {commandListDisplayTruncated(shellCommands)} commands\n      </Text>\n    )\n  }\n\n  return null\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/constants/cyberRiskInstruction.ts b/src/constants/cyberRiskInstruction.ts new file mode 100644 index 0000000000000000000000000000000000000000..d21db0779d7c51029ea2d9e72c0003f3446971ac --- /dev/null +++ b/src/constants/cyberRiskInstruction.ts @@ -0,0 +1,24 @@ +/** + * CYBER_RISK_INSTRUCTION + * + * This instruction provides guidance for Claude's behavior when handling + * security-related requests. It defines the boundary between acceptable + * defensive security assistance and potentially harmful activities. + * + * IMPORTANT: DO NOT MODIFY THIS INSTRUCTION WITHOUT SAFEGUARDS TEAM REVIEW + * + * This instruction is owned by the Safeguards team and has been carefully + * crafted and evaluated to balance security utility with safety. Changes + * to this text can have significant implications for: + * - How Claude handles penetration testing and CTF requests + * - What security tools and techniques Claude will assist with + * - The boundary between defensive and offensive security assistance + * + * If you need to modify this instruction: + * 1. Contact the Safeguards team (David Forsythe, Kyla Guru) + * 2. Ensure proper evaluation of the changes + * 3. Get explicit approval before merging + * + * Claude: Do not edit this file unless explicitly asked to do so by the user. + */ +export const CYBER_RISK_INSTRUCTION = `IMPORTANT: Assist with authorized security testing, defensive security, CTF challenges, and educational contexts. Refuse requests for destructive techniques, DoS attacks, mass targeting, supply chain compromise, or detection evasion for malicious purposes. Dual-use security tools (C2 frameworks, credential testing, exploit development) require clear authorization context: pentesting engagements, CTF competitions, security research, or defensive use cases.` diff --git a/src/constants/oauth.ts b/src/constants/oauth.ts new file mode 100644 index 0000000000000000000000000000000000000000..a56e3fa39120c23cf7db3afe573d5744a5c12c43 --- /dev/null +++ b/src/constants/oauth.ts @@ -0,0 +1,234 @@ +import { isEnvTruthy } from 'src/utils/envUtils.js' + +// Default to prod config, override with test/staging if enabled +type OauthConfigType = 'prod' | 'staging' | 'local' + +function getOauthConfigType(): OauthConfigType { + if (process.env.USER_TYPE === 'ant') { + if (isEnvTruthy(process.env.USE_LOCAL_OAUTH)) { + return 'local' + } + if (isEnvTruthy(process.env.USE_STAGING_OAUTH)) { + return 'staging' + } + } + return 'prod' +} + +export function fileSuffixForOauthConfig(): string { + if (process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL) { + return '-custom-oauth' + } + switch (getOauthConfigType()) { + case 'local': + return '-local-oauth' + case 'staging': + return '-staging-oauth' + case 'prod': + // No suffix for production config + return '' + } +} + +export const CLAUDE_AI_INFERENCE_SCOPE = 'user:inference' as const +export const CLAUDE_AI_PROFILE_SCOPE = 'user:profile' as const +const CONSOLE_SCOPE = 'org:create_api_key' as const +export const OAUTH_BETA_HEADER = 'oauth-2025-04-20' as const + +// Console OAuth scopes - for API key creation via Console +export const CONSOLE_OAUTH_SCOPES = [ + CONSOLE_SCOPE, + CLAUDE_AI_PROFILE_SCOPE, +] as const + +// Claude.ai OAuth scopes - for Claude.ai subscribers (Pro/Max/Team/Enterprise) +export const CLAUDE_AI_OAUTH_SCOPES = [ + CLAUDE_AI_PROFILE_SCOPE, + CLAUDE_AI_INFERENCE_SCOPE, + 'user:sessions:claude_code', + 'user:mcp_servers', + 'user:file_upload', +] as const + +// All OAuth scopes - union of all scopes used in Claude CLI +// When logging in, request all scopes in order to handle both Console -> Claude.ai redirect +// Ensure that `OAuthConsentPage` in apps repo is kept in sync with this list. +export const ALL_OAUTH_SCOPES = Array.from( + new Set([...CONSOLE_OAUTH_SCOPES, ...CLAUDE_AI_OAUTH_SCOPES]), +) + +type OauthConfig = { + BASE_API_URL: string + CONSOLE_AUTHORIZE_URL: string + CLAUDE_AI_AUTHORIZE_URL: string + /** + * The claude.ai web origin. Separate from CLAUDE_AI_AUTHORIZE_URL because + * that now routes through claude.com/cai/* for attribution — deriving + * .origin from it would give claude.com, breaking links to /code, + * /settings/connectors, and other claude.ai web pages. + */ + CLAUDE_AI_ORIGIN: string + TOKEN_URL: string + API_KEY_URL: string + ROLES_URL: string + CONSOLE_SUCCESS_URL: string + CLAUDEAI_SUCCESS_URL: string + MANUAL_REDIRECT_URL: string + CLIENT_ID: string + OAUTH_FILE_SUFFIX: string + MCP_PROXY_URL: string + MCP_PROXY_PATH: string +} + +// Production OAuth configuration - Used in normal operation +const PROD_OAUTH_CONFIG = { + BASE_API_URL: 'https://api.anthropic.com', + CONSOLE_AUTHORIZE_URL: 'https://platform.claude.com/oauth/authorize', + // Bounces through claude.com/cai/* so CLI sign-ins connect to claude.com + // visits for attribution. 307s to claude.ai/oauth/authorize in two hops. + CLAUDE_AI_AUTHORIZE_URL: 'https://claude.com/cai/oauth/authorize', + CLAUDE_AI_ORIGIN: 'https://claude.ai', + TOKEN_URL: 'https://platform.claude.com/v1/oauth/token', + API_KEY_URL: 'https://api.anthropic.com/api/oauth/claude_cli/create_api_key', + ROLES_URL: 'https://api.anthropic.com/api/oauth/claude_cli/roles', + CONSOLE_SUCCESS_URL: + 'https://platform.claude.com/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code', + CLAUDEAI_SUCCESS_URL: + 'https://platform.claude.com/oauth/code/success?app=claude-code', + MANUAL_REDIRECT_URL: 'https://platform.claude.com/oauth/code/callback', + CLIENT_ID: '9d1c250a-e61b-44d9-88ed-5944d1962f5e', + // No suffix for production config + OAUTH_FILE_SUFFIX: '', + MCP_PROXY_URL: 'https://mcp-proxy.anthropic.com', + MCP_PROXY_PATH: '/v1/mcp/{server_id}', +} as const + +/** + * Client ID Metadata Document URL for MCP OAuth (CIMD / SEP-991). + * When an MCP auth server advertises client_id_metadata_document_supported: true, + * Claude Code uses this URL as its client_id instead of Dynamic Client Registration. + * The URL must point to a JSON document hosted by Anthropic. + * See: https://datatracker.ietf.org/doc/html/draft-ietf-oauth-client-id-metadata-document-00 + */ +export const MCP_CLIENT_METADATA_URL = + 'https://claude.ai/oauth/claude-code-client-metadata' + +// Staging OAuth configuration - only included in ant builds with staging flag +// Uses literal check for dead code elimination +const STAGING_OAUTH_CONFIG = + process.env.USER_TYPE === 'ant' + ? ({ + BASE_API_URL: 'https://api-staging.anthropic.com', + CONSOLE_AUTHORIZE_URL: + 'https://platform.staging.ant.dev/oauth/authorize', + CLAUDE_AI_AUTHORIZE_URL: + 'https://claude-ai.staging.ant.dev/oauth/authorize', + CLAUDE_AI_ORIGIN: 'https://claude-ai.staging.ant.dev', + TOKEN_URL: 'https://platform.staging.ant.dev/v1/oauth/token', + API_KEY_URL: + 'https://api-staging.anthropic.com/api/oauth/claude_cli/create_api_key', + ROLES_URL: + 'https://api-staging.anthropic.com/api/oauth/claude_cli/roles', + CONSOLE_SUCCESS_URL: + 'https://platform.staging.ant.dev/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code', + CLAUDEAI_SUCCESS_URL: + 'https://platform.staging.ant.dev/oauth/code/success?app=claude-code', + MANUAL_REDIRECT_URL: + 'https://platform.staging.ant.dev/oauth/code/callback', + CLIENT_ID: '22422756-60c9-4084-8eb7-27705fd5cf9a', + OAUTH_FILE_SUFFIX: '-staging-oauth', + MCP_PROXY_URL: 'https://mcp-proxy-staging.anthropic.com', + MCP_PROXY_PATH: '/v1/mcp/{server_id}', + } as const) + : undefined + +// Three local dev servers: :8000 api-proxy (`api dev start -g ccr`), +// :4000 claude-ai frontend, :3000 Console frontend. Env vars let +// scripts/claude-localhost override if your layout differs. +function getLocalOauthConfig(): OauthConfig { + const api = + process.env.CLAUDE_LOCAL_OAUTH_API_BASE?.replace(/\/$/, '') ?? + 'http://localhost:8000' + const apps = + process.env.CLAUDE_LOCAL_OAUTH_APPS_BASE?.replace(/\/$/, '') ?? + 'http://localhost:4000' + const consoleBase = + process.env.CLAUDE_LOCAL_OAUTH_CONSOLE_BASE?.replace(/\/$/, '') ?? + 'http://localhost:3000' + return { + BASE_API_URL: api, + CONSOLE_AUTHORIZE_URL: `${consoleBase}/oauth/authorize`, + CLAUDE_AI_AUTHORIZE_URL: `${apps}/oauth/authorize`, + CLAUDE_AI_ORIGIN: apps, + TOKEN_URL: `${api}/v1/oauth/token`, + API_KEY_URL: `${api}/api/oauth/claude_cli/create_api_key`, + ROLES_URL: `${api}/api/oauth/claude_cli/roles`, + CONSOLE_SUCCESS_URL: `${consoleBase}/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code`, + CLAUDEAI_SUCCESS_URL: `${consoleBase}/oauth/code/success?app=claude-code`, + MANUAL_REDIRECT_URL: `${consoleBase}/oauth/code/callback`, + CLIENT_ID: '22422756-60c9-4084-8eb7-27705fd5cf9a', + OAUTH_FILE_SUFFIX: '-local-oauth', + MCP_PROXY_URL: 'http://localhost:8205', + MCP_PROXY_PATH: '/v1/toolbox/shttp/mcp/{server_id}', + } +} + +// Allowed base URLs for CLAUDE_CODE_CUSTOM_OAUTH_URL override. +// Only FedStart/PubSec deployments are permitted to prevent OAuth tokens +// from being sent to arbitrary endpoints. +const ALLOWED_OAUTH_BASE_URLS = [ + 'https://beacon.claude-ai.staging.ant.dev', + 'https://claude.fedstart.com', + 'https://claude-staging.fedstart.com', +] + +// Default to prod config, override with test/staging if enabled +export function getOauthConfig(): OauthConfig { + let config: OauthConfig = (() => { + switch (getOauthConfigType()) { + case 'local': + return getLocalOauthConfig() + case 'staging': + return STAGING_OAUTH_CONFIG ?? PROD_OAUTH_CONFIG + case 'prod': + return PROD_OAUTH_CONFIG + } + })() + + // Allow overriding all OAuth URLs to point to an approved FedStart deployment. + // Only allowlisted base URLs are accepted to prevent credential leakage. + const oauthBaseUrl = process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL + if (oauthBaseUrl) { + const base = oauthBaseUrl.replace(/\/$/, '') + if (!ALLOWED_OAUTH_BASE_URLS.includes(base)) { + throw new Error( + 'CLAUDE_CODE_CUSTOM_OAUTH_URL is not an approved endpoint.', + ) + } + config = { + ...config, + BASE_API_URL: base, + CONSOLE_AUTHORIZE_URL: `${base}/oauth/authorize`, + CLAUDE_AI_AUTHORIZE_URL: `${base}/oauth/authorize`, + CLAUDE_AI_ORIGIN: base, + TOKEN_URL: `${base}/v1/oauth/token`, + API_KEY_URL: `${base}/api/oauth/claude_cli/create_api_key`, + ROLES_URL: `${base}/api/oauth/claude_cli/roles`, + CONSOLE_SUCCESS_URL: `${base}/oauth/code/success?app=claude-code`, + CLAUDEAI_SUCCESS_URL: `${base}/oauth/code/success?app=claude-code`, + MANUAL_REDIRECT_URL: `${base}/oauth/code/callback`, + OAUTH_FILE_SUFFIX: '-custom-oauth', + } + } + + // Allow CLIENT_ID override via environment variable (e.g., for Xcode integration) + const clientIdOverride = process.env.CLAUDE_CODE_OAUTH_CLIENT_ID + if (clientIdOverride) { + config = { + ...config, + CLIENT_ID: clientIdOverride, + } + } + + return config +} diff --git a/src/constants/toolLimits.ts b/src/constants/toolLimits.ts new file mode 100644 index 0000000000000000000000000000000000000000..131560a94b8d1729bd3339db983bd63ba9c36872 --- /dev/null +++ b/src/constants/toolLimits.ts @@ -0,0 +1,56 @@ +/** + * Constants related to tool result size limits + */ + +/** + * Default maximum size in characters for tool results before they get persisted + * to disk. When exceeded, the result is saved to a file and the model receives + * a preview with the file path instead of the full content. + * + * Individual tools may declare a lower maxResultSizeChars, but this constant + * acts as a system-wide cap regardless of what tools declare. + */ +export const DEFAULT_MAX_RESULT_SIZE_CHARS = 50_000 + +/** + * Maximum size for tool results in tokens. + * Based on analysis of tool result sizes, we set this to a reasonable upper bound + * to prevent excessively large tool results from consuming too much context. + * + * This is approximately 400KB of text (assuming ~4 bytes per token). + */ +export const MAX_TOOL_RESULT_TOKENS = 100_000 + +/** + * Bytes per token estimate for calculating token count from byte size. + * This is a conservative estimate - actual token count may vary. + */ +export const BYTES_PER_TOKEN = 4 + +/** + * Maximum size for tool results in bytes (derived from token limit). + */ +export const MAX_TOOL_RESULT_BYTES = MAX_TOOL_RESULT_TOKENS * BYTES_PER_TOKEN + +/** + * Default maximum aggregate size in characters for tool_result blocks within + * a SINGLE user message (one turn's batch of parallel tool results). When a + * message's blocks together exceed this, the largest blocks in that message + * are persisted to disk and replaced with previews until under budget. + * Messages are evaluated independently — a 150K result in one turn and a + * 150K result in the next are both untouched. + * + * This prevents N parallel tools from each hitting the per-tool max and + * collectively producing e.g. 10 × 40K = 400K in one turn's user message. + * + * Overridable at runtime via GrowthBook flag tengu_hawthorn_window — see + * getPerMessageBudgetLimit() in toolResultStorage.ts. + */ +export const MAX_TOOL_RESULTS_PER_MESSAGE_CHARS = 200_000 + +/** + * Maximum character length for tool summary strings in compact views. + * Used by getToolUseSummary() implementations to truncate long inputs + * for display in grouped agent rendering. + */ +export const TOOL_SUMMARY_MAX_LENGTH = 50 diff --git a/src/context/modalContext.tsx b/src/context/modalContext.tsx new file mode 100644 index 0000000000000000000000000000000000000000..031de7cda8bbba4a3ac9624f9ca490b3e542f439 --- /dev/null +++ b/src/context/modalContext.tsx @@ -0,0 +1,58 @@ +import { c as _c } from "react/compiler-runtime"; +import { createContext, type RefObject, useContext } from 'react'; +import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js'; + +/** + * Set by FullscreenLayout when rendering content in its `modal` slot — + * the absolute-positioned bottom-anchored pane for slash-command dialogs. + * Consumers use this to: + * + * - Suppress top-level framing — `Pane` skips its full-terminal-width + * `Divider` (FullscreenLayout already draws the ▔ divider). + * - Size Select pagination to the available rows — the modal's inner + * area is smaller than the terminal (rows minus transcript peek minus + * divider), so components that cap their visible option count from + * `useTerminalSize().rows` would overflow without this context. + * - Reset scroll on tab switch — Tabs keys its ScrollBox by + * `selectedTabIndex`, remounting on tab switch so scrollTop resets to 0 + * without scrollTo() timing games. + * + * null = not inside the modal slot. + */ +type ModalCtx = { + rows: number; + columns: number; + scrollRef: RefObject | null; +}; +export const ModalContext = createContext(null); +export function useIsInsideModal() { + return useContext(ModalContext) !== null; +} + +/** + * Available content rows/columns when inside a Modal, else falls back to + * the provided terminal size. Use instead of `useTerminalSize()` when a + * component caps its visible content height — the modal's inner area is + * smaller than the terminal. + */ +export function useModalOrTerminalSize(fallback) { + const $ = _c(3); + const ctx = useContext(ModalContext); + let t0; + if ($[0] !== ctx || $[1] !== fallback) { + t0 = ctx ? { + rows: ctx.rows, + columns: ctx.columns + } : fallback; + $[0] = ctx; + $[1] = fallback; + $[2] = t0; + } else { + t0 = $[2]; + } + return t0; +} +export function useModalScrollRef() { + return useContext(ModalContext)?.scrollRef ?? null; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjcmVhdGVDb250ZXh0IiwiUmVmT2JqZWN0IiwidXNlQ29udGV4dCIsIlNjcm9sbEJveEhhbmRsZSIsIk1vZGFsQ3R4Iiwicm93cyIsImNvbHVtbnMiLCJzY3JvbGxSZWYiLCJNb2RhbENvbnRleHQiLCJ1c2VJc0luc2lkZU1vZGFsIiwidXNlTW9kYWxPclRlcm1pbmFsU2l6ZSIsImZhbGxiYWNrIiwiJCIsIl9jIiwiY3R4IiwidDAiLCJ1c2VNb2RhbFNjcm9sbFJlZiJdLCJzb3VyY2VzIjpbIm1vZGFsQ29udGV4dC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlQ29udGV4dCwgdHlwZSBSZWZPYmplY3QsIHVzZUNvbnRleHQgfSBmcm9tICdyZWFjdCdcbmltcG9ydCB0eXBlIHsgU2Nyb2xsQm94SGFuZGxlIH0gZnJvbSAnLi4vaW5rL2NvbXBvbmVudHMvU2Nyb2xsQm94LmpzJ1xuXG4vKipcbiAqIFNldCBieSBGdWxsc2NyZWVuTGF5b3V0IHdoZW4gcmVuZGVyaW5nIGNvbnRlbnQgaW4gaXRzIGBtb2RhbGAgc2xvdCDigJRcbiAqIHRoZSBhYnNvbHV0ZS1wb3NpdGlvbmVkIGJvdHRvbS1hbmNob3JlZCBwYW5lIGZvciBzbGFzaC1jb21tYW5kIGRpYWxvZ3MuXG4gKiBDb25zdW1lcnMgdXNlIHRoaXMgdG86XG4gKlxuICogLSBTdXBwcmVzcyB0b3AtbGV2ZWwgZnJhbWluZyDigJQgYFBhbmVgIHNraXBzIGl0cyBmdWxsLXRlcm1pbmFsLXdpZHRoXG4gKiAgIGBEaXZpZGVyYCAoRnVsbHNjcmVlbkxheW91dCBhbHJlYWR5IGRyYXdzIHRoZSDilpQgZGl2aWRlcikuXG4gKiAtIFNpemUgU2VsZWN0IHBhZ2luYXRpb24gdG8gdGhlIGF2YWlsYWJsZSByb3dzIOKAlCB0aGUgbW9kYWwncyBpbm5lclxuICogICBhcmVhIGlzIHNtYWxsZXIgdGhhbiB0aGUgdGVybWluYWwgKHJvd3MgbWludXMgdHJhbnNjcmlwdCBwZWVrIG1pbnVzXG4gKiAgIGRpdmlkZXIpLCBzbyBjb21wb25lbnRzIHRoYXQgY2FwIHRoZWlyIHZpc2libGUgb3B0aW9uIGNvdW50IGZyb21cbiAqICAgYHVzZVRlcm1pbmFsU2l6ZSgpLnJvd3NgIHdvdWxkIG92ZXJmbG93IHdpdGhvdXQgdGhpcyBjb250ZXh0LlxuICogLSBSZXNldCBzY3JvbGwgb24gdGFiIHN3aXRjaCDigJQgVGFicyBrZXlzIGl0cyBTY3JvbGxCb3ggYnlcbiAqICAgYHNlbGVjdGVkVGFiSW5kZXhgLCByZW1vdW50aW5nIG9uIHRhYiBzd2l0Y2ggc28gc2Nyb2xsVG9wIHJlc2V0cyB0byAwXG4gKiAgIHdpdGhvdXQgc2Nyb2xsVG8oKSB0aW1pbmcgZ2FtZXMuXG4gKlxuICogbnVsbCA9IG5vdCBpbnNpZGUgdGhlIG1vZGFsIHNsb3QuXG4gKi9cbnR5cGUgTW9kYWxDdHggPSB7XG4gIHJvd3M6IG51bWJlclxuICBjb2x1bW5zOiBudW1iZXJcbiAgc2Nyb2xsUmVmOiBSZWZPYmplY3Q8U2Nyb2xsQm94SGFuZGxlIHwgbnVsbD4gfCBudWxsXG59XG5leHBvcnQgY29uc3QgTW9kYWxDb250ZXh0ID0gY3JlYXRlQ29udGV4dDxNb2RhbEN0eCB8IG51bGw+KG51bGwpXG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VJc0luc2lkZU1vZGFsKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gdXNlQ29udGV4dChNb2RhbENvbnRleHQpICE9PSBudWxsXG59XG5cbi8qKlxuICogQXZhaWxhYmxlIGNvbnRlbnQgcm93cy9jb2x1bW5zIHdoZW4gaW5zaWRlIGEgTW9kYWwsIGVsc2UgZmFsbHMgYmFjayB0b1xuICogdGhlIHByb3ZpZGVkIHRlcm1pbmFsIHNpemUuIFVzZSBpbnN0ZWFkIG9mIGB1c2VUZXJtaW5hbFNpemUoKWAgd2hlbiBhXG4gKiBjb21wb25lbnQgY2FwcyBpdHMgdmlzaWJsZSBjb250ZW50IGhlaWdodCDigJQgdGhlIG1vZGFsJ3MgaW5uZXIgYXJlYSBpc1xuICogc21hbGxlciB0aGFuIHRoZSB0ZXJtaW5hbC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHVzZU1vZGFsT3JUZXJtaW5hbFNpemUoZmFsbGJhY2s6IHtcbiAgcm93czogbnVtYmVyXG4gIGNvbHVtbnM6IG51bWJlclxufSk6IHsgcm93czogbnVtYmVyOyBjb2x1bW5zOiBudW1iZXIgfSB7XG4gIGNvbnN0IGN0eCA9IHVzZUNvbnRleHQoTW9kYWxDb250ZXh0KVxuICByZXR1cm4gY3R4ID8geyByb3dzOiBjdHgucm93cywgY29sdW1uczogY3R4LmNvbHVtbnMgfSA6IGZhbGxiYWNrXG59XG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VNb2RhbFNjcm9sbFJlZigpOiBSZWZPYmplY3Q8U2Nyb2xsQm94SGFuZGxlIHwgbnVsbD4gfCBudWxsIHtcbiAgcmV0dXJuIHVzZUNvbnRleHQoTW9kYWxDb250ZXh0KT8uc2Nyb2xsUmVmID8/IG51bGxcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUFBLFNBQVNBLGFBQWEsRUFBRSxLQUFLQyxTQUFTLEVBQUVDLFVBQVUsUUFBUSxPQUFPO0FBQ2pFLGNBQWNDLGVBQWUsUUFBUSxnQ0FBZ0M7O0FBRXJFO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQSxLQUFLQyxRQUFRLEdBQUc7RUFDZEMsSUFBSSxFQUFFLE1BQU07RUFDWkMsT0FBTyxFQUFFLE1BQU07RUFDZkMsU0FBUyxFQUFFTixTQUFTLENBQUNFLGVBQWUsR0FBRyxJQUFJLENBQUMsR0FBRyxJQUFJO0FBQ3JELENBQUM7QUFDRCxPQUFPLE1BQU1LLFlBQVksR0FBR1IsYUFBYSxDQUFDSSxRQUFRLEdBQUcsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDO0FBRWhFLE9BQU8sU0FBQUssaUJBQUE7RUFBQSxPQUNFUCxVQUFVLENBQUNNLFlBQVksQ0FBQyxLQUFLLElBQUk7QUFBQTs7QUFHMUM7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsT0FBTyxTQUFBRSx1QkFBQUMsUUFBQTtFQUFBLE1BQUFDLENBQUEsR0FBQUMsRUFBQTtFQUlMLE1BQUFDLEdBQUEsR0FBWVosVUFBVSxDQUFDTSxZQUFZLENBQUM7RUFBQSxJQUFBTyxFQUFBO0VBQUEsSUFBQUgsQ0FBQSxRQUFBRSxHQUFBLElBQUFGLENBQUEsUUFBQUQsUUFBQTtJQUM3QkksRUFBQSxHQUFBRCxHQUFHLEdBQUg7TUFBQVQsSUFBQSxFQUFjUyxHQUFHLENBQUFULElBQUs7TUFBQUMsT0FBQSxFQUFXUSxHQUFHLENBQUFSO0lBQW9CLENBQUMsR0FBekRLLFFBQXlEO0lBQUFDLENBQUEsTUFBQUUsR0FBQTtJQUFBRixDQUFBLE1BQUFELFFBQUE7SUFBQUMsQ0FBQSxNQUFBRyxFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBSCxDQUFBO0VBQUE7RUFBQSxPQUF6REcsRUFBeUQ7QUFBQTtBQUdsRSxPQUFPLFNBQUFDLGtCQUFBO0VBQUEsT0FDRWQsVUFBVSxDQUFDTSxZQUF1QixDQUFDLEVBQUFELFNBQVEsSUFBM0MsSUFBMkM7QUFBQSIsImlnbm9yZUxpc3QiOltdfQ== \ No newline at end of file diff --git a/src/context/notifications.tsx b/src/context/notifications.tsx new file mode 100644 index 0000000000000000000000000000000000000000..8c214db5748cd83413571534d798927899870c71 --- /dev/null +++ b/src/context/notifications.tsx @@ -0,0 +1,240 @@ +import type * as React from 'react'; +import { useCallback, useEffect } from 'react'; +import { useAppStateStore, useSetAppState } from 'src/state/AppState.js'; +import type { Theme } from '../utils/theme.js'; +type Priority = 'low' | 'medium' | 'high' | 'immediate'; +type BaseNotification = { + key: string; + /** + * Keys of notifications that this notification invalidates. + * If a notification is invalidated, it will be removed from the queue + * and, if currently displayed, cleared immediately. + */ + invalidates?: string[]; + priority: Priority; + timeoutMs?: number; + /** + * Combine notifications with the same key, like Array.reduce(). + * Called as fold(accumulator, incoming) when a notification with a matching + * key already exists in the queue or is currently displayed. + * Returns the merged notification (should carry fold forward for future merges). + */ + fold?: (accumulator: Notification, incoming: Notification) => Notification; +}; +type TextNotification = BaseNotification & { + text: string; + color?: keyof Theme; +}; +type JSXNotification = BaseNotification & { + jsx: React.ReactNode; +}; +type AddNotificationFn = (content: Notification) => void; +type RemoveNotificationFn = (key: string) => void; +export type Notification = TextNotification | JSXNotification; +const DEFAULT_TIMEOUT_MS = 8000; + +// Track current timeout to clear it when immediate notifications arrive +let currentTimeoutId: NodeJS.Timeout | null = null; +export function useNotifications(): { + addNotification: AddNotificationFn; + removeNotification: RemoveNotificationFn; +} { + const store = useAppStateStore(); + const setAppState = useSetAppState(); + + // Process queue when current notification finishes or queue changes + const processQueue = useCallback(() => { + setAppState(prev => { + const next = getNext(prev.notifications.queue); + if (prev.notifications.current !== null || !next) { + return prev; + } + currentTimeoutId = setTimeout((setAppState, nextKey, processQueue) => { + currentTimeoutId = null; + setAppState(prev => { + // Compare by key instead of reference to handle re-created notifications + if (prev.notifications.current?.key !== nextKey) { + return prev; + } + return { + ...prev, + notifications: { + queue: prev.notifications.queue, + current: null + } + }; + }); + processQueue(); + }, next.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, next.key, processQueue); + return { + ...prev, + notifications: { + queue: prev.notifications.queue.filter(_ => _ !== next), + current: next + } + }; + }); + }, [setAppState]); + const addNotification = useCallback((notif: Notification) => { + // Handle immediate priority notifications + if (notif.priority === 'immediate') { + // Clear any existing timeout since we're showing a new immediate notification + if (currentTimeoutId) { + clearTimeout(currentTimeoutId); + currentTimeoutId = null; + } + + // Set up timeout for the immediate notification + currentTimeoutId = setTimeout((setAppState, notif, processQueue) => { + currentTimeoutId = null; + setAppState(prev => { + // Compare by key instead of reference to handle re-created notifications + if (prev.notifications.current?.key !== notif.key) { + return prev; + } + return { + ...prev, + notifications: { + queue: prev.notifications.queue.filter(_ => !notif.invalidates?.includes(_.key)), + current: null + } + }; + }); + processQueue(); + }, notif.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, notif, processQueue); + + // Show the immediate notification right away + setAppState(prev => ({ + ...prev, + notifications: { + current: notif, + queue: + // Only re-queue the current notification if it's not immediate + [...(prev.notifications.current ? [prev.notifications.current] : []), ...prev.notifications.queue].filter(_ => _.priority !== 'immediate' && !notif.invalidates?.includes(_.key)) + } + })); + return; // IMPORTANT: Exit addNotification for immediate notifications + } + + // Handle non-immediate notifications + setAppState(prev => { + // Check if we can fold into an existing notification with the same key + if (notif.fold) { + // Fold into current notification if keys match + if (prev.notifications.current?.key === notif.key) { + const folded = notif.fold(prev.notifications.current, notif); + // Reset timeout for the folded notification + if (currentTimeoutId) { + clearTimeout(currentTimeoutId); + currentTimeoutId = null; + } + currentTimeoutId = setTimeout((setAppState, foldedKey, processQueue) => { + currentTimeoutId = null; + setAppState(p => { + if (p.notifications.current?.key !== foldedKey) { + return p; + } + return { + ...p, + notifications: { + queue: p.notifications.queue, + current: null + } + }; + }); + processQueue(); + }, folded.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, folded.key, processQueue); + return { + ...prev, + notifications: { + current: folded, + queue: prev.notifications.queue + } + }; + } + + // Fold into queued notification if keys match + const queueIdx = prev.notifications.queue.findIndex(_ => _.key === notif.key); + if (queueIdx !== -1) { + const folded = notif.fold(prev.notifications.queue[queueIdx]!, notif); + const newQueue = [...prev.notifications.queue]; + newQueue[queueIdx] = folded; + return { + ...prev, + notifications: { + current: prev.notifications.current, + queue: newQueue + } + }; + } + } + + // Only add to queue if not already present (prevent duplicates) + const queuedKeys = new Set(prev.notifications.queue.map(_ => _.key)); + const shouldAdd = !queuedKeys.has(notif.key) && prev.notifications.current?.key !== notif.key; + if (!shouldAdd) return prev; + const invalidatesCurrent = prev.notifications.current !== null && notif.invalidates?.includes(prev.notifications.current.key); + if (invalidatesCurrent && currentTimeoutId) { + clearTimeout(currentTimeoutId); + currentTimeoutId = null; + } + return { + ...prev, + notifications: { + current: invalidatesCurrent ? null : prev.notifications.current, + queue: [...prev.notifications.queue.filter(_ => _.priority !== 'immediate' && !notif.invalidates?.includes(_.key)), notif] + } + }; + }); + + // Process queue after adding the notification + processQueue(); + }, [setAppState, processQueue]); + const removeNotification = useCallback((key: string) => { + setAppState(prev => { + const isCurrent = prev.notifications.current?.key === key; + const inQueue = prev.notifications.queue.some(n => n.key === key); + if (!isCurrent && !inQueue) { + return prev; + } + if (isCurrent && currentTimeoutId) { + clearTimeout(currentTimeoutId); + currentTimeoutId = null; + } + return { + ...prev, + notifications: { + current: isCurrent ? null : prev.notifications.current, + queue: prev.notifications.queue.filter(n => n.key !== key) + } + }; + }); + processQueue(); + }, [setAppState, processQueue]); + + // Process queue on mount if there are notifications in the initial state. + // Imperative read (not useAppState) — a subscription in a mount-only + // effect would be vestigial and make every caller re-render on queue changes. + // eslint-disable-next-line react-hooks/exhaustive-deps + // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only effect, store is a stable context ref + useEffect(() => { + if (store.getState().notifications.queue.length > 0) { + processQueue(); + } + }, []); + return { + addNotification, + removeNotification + }; +} +const PRIORITIES: Record = { + immediate: 0, + high: 1, + medium: 2, + low: 3 +}; +export function getNext(queue: Notification[]): Notification | undefined { + if (queue.length === 0) return undefined; + return queue.reduce((min, n) => PRIORITIES[n.priority] < PRIORITIES[min.priority] ? n : min); +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useAppStateStore","useSetAppState","Theme","Priority","BaseNotification","key","invalidates","priority","timeoutMs","fold","accumulator","Notification","incoming","TextNotification","text","color","JSXNotification","jsx","ReactNode","AddNotificationFn","content","RemoveNotificationFn","DEFAULT_TIMEOUT_MS","currentTimeoutId","NodeJS","Timeout","useNotifications","addNotification","removeNotification","store","setAppState","processQueue","prev","next","getNext","notifications","queue","current","setTimeout","nextKey","filter","_","notif","clearTimeout","includes","folded","foldedKey","p","queueIdx","findIndex","newQueue","queuedKeys","Set","map","shouldAdd","has","invalidatesCurrent","isCurrent","inQueue","some","n","getState","length","PRIORITIES","Record","immediate","high","medium","low","undefined","reduce","min"],"sources":["notifications.tsx"],"sourcesContent":["import type * as React from 'react'\nimport { useCallback, useEffect } from 'react'\nimport { useAppStateStore, useSetAppState } from 'src/state/AppState.js'\nimport type { Theme } from '../utils/theme.js'\n\ntype Priority = 'low' | 'medium' | 'high' | 'immediate'\n\ntype BaseNotification = {\n  key: string\n  /**\n   * Keys of notifications that this notification invalidates.\n   * If a notification is invalidated, it will be removed from the queue\n   * and, if currently displayed, cleared immediately.\n   */\n  invalidates?: string[]\n  priority: Priority\n  timeoutMs?: number\n  /**\n   * Combine notifications with the same key, like Array.reduce().\n   * Called as fold(accumulator, incoming) when a notification with a matching\n   * key already exists in the queue or is currently displayed.\n   * Returns the merged notification (should carry fold forward for future merges).\n   */\n  fold?: (accumulator: Notification, incoming: Notification) => Notification\n}\n\ntype TextNotification = BaseNotification & {\n  text: string\n  color?: keyof Theme\n}\n\ntype JSXNotification = BaseNotification & {\n  jsx: React.ReactNode\n}\n\ntype AddNotificationFn = (content: Notification) => void\ntype RemoveNotificationFn = (key: string) => void\n\nexport type Notification = TextNotification | JSXNotification\n\nconst DEFAULT_TIMEOUT_MS = 8000\n\n// Track current timeout to clear it when immediate notifications arrive\nlet currentTimeoutId: NodeJS.Timeout | null = null\n\nexport function useNotifications(): {\n  addNotification: AddNotificationFn\n  removeNotification: RemoveNotificationFn\n} {\n  const store = useAppStateStore()\n  const setAppState = useSetAppState()\n\n  // Process queue when current notification finishes or queue changes\n  const processQueue = useCallback(() => {\n    setAppState(prev => {\n      const next = getNext(prev.notifications.queue)\n      if (prev.notifications.current !== null || !next) {\n        return prev\n      }\n\n      currentTimeoutId = setTimeout(\n        (setAppState, nextKey, processQueue) => {\n          currentTimeoutId = null\n          setAppState(prev => {\n            // Compare by key instead of reference to handle re-created notifications\n            if (prev.notifications.current?.key !== nextKey) {\n              return prev\n            }\n            return {\n              ...prev,\n              notifications: {\n                queue: prev.notifications.queue,\n                current: null,\n              },\n            }\n          })\n          processQueue()\n        },\n        next.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n        setAppState,\n        next.key,\n        processQueue,\n      )\n\n      return {\n        ...prev,\n        notifications: {\n          queue: prev.notifications.queue.filter(_ => _ !== next),\n          current: next,\n        },\n      }\n    })\n  }, [setAppState])\n\n  const addNotification = useCallback<AddNotificationFn>(\n    (notif: Notification) => {\n      // Handle immediate priority notifications\n      if (notif.priority === 'immediate') {\n        // Clear any existing timeout since we're showing a new immediate notification\n        if (currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        // Set up timeout for the immediate notification\n        currentTimeoutId = setTimeout(\n          (setAppState, notif, processQueue) => {\n            currentTimeoutId = null\n            setAppState(prev => {\n              // Compare by key instead of reference to handle re-created notifications\n              if (prev.notifications.current?.key !== notif.key) {\n                return prev\n              }\n              return {\n                ...prev,\n                notifications: {\n                  queue: prev.notifications.queue.filter(\n                    _ => !notif.invalidates?.includes(_.key),\n                  ),\n                  current: null,\n                },\n              }\n            })\n            processQueue()\n          },\n          notif.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n          setAppState,\n          notif,\n          processQueue,\n        )\n\n        // Show the immediate notification right away\n        setAppState(prev => ({\n          ...prev,\n          notifications: {\n            current: notif,\n            queue:\n              // Only re-queue the current notification if it's not immediate\n              [\n                ...(prev.notifications.current\n                  ? [prev.notifications.current]\n                  : []),\n                ...prev.notifications.queue,\n              ].filter(\n                _ =>\n                  _.priority !== 'immediate' &&\n                  !notif.invalidates?.includes(_.key),\n              ),\n          },\n        }))\n        return // IMPORTANT: Exit addNotification for immediate notifications\n      }\n\n      // Handle non-immediate notifications\n      setAppState(prev => {\n        // Check if we can fold into an existing notification with the same key\n        if (notif.fold) {\n          // Fold into current notification if keys match\n          if (prev.notifications.current?.key === notif.key) {\n            const folded = notif.fold(prev.notifications.current, notif)\n            // Reset timeout for the folded notification\n            if (currentTimeoutId) {\n              clearTimeout(currentTimeoutId)\n              currentTimeoutId = null\n            }\n            currentTimeoutId = setTimeout(\n              (setAppState, foldedKey, processQueue) => {\n                currentTimeoutId = null\n                setAppState(p => {\n                  if (p.notifications.current?.key !== foldedKey) {\n                    return p\n                  }\n                  return {\n                    ...p,\n                    notifications: {\n                      queue: p.notifications.queue,\n                      current: null,\n                    },\n                  }\n                })\n                processQueue()\n              },\n              folded.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n              setAppState,\n              folded.key,\n              processQueue,\n            )\n\n            return {\n              ...prev,\n              notifications: {\n                current: folded,\n                queue: prev.notifications.queue,\n              },\n            }\n          }\n\n          // Fold into queued notification if keys match\n          const queueIdx = prev.notifications.queue.findIndex(\n            _ => _.key === notif.key,\n          )\n          if (queueIdx !== -1) {\n            const folded = notif.fold(\n              prev.notifications.queue[queueIdx]!,\n              notif,\n            )\n            const newQueue = [...prev.notifications.queue]\n            newQueue[queueIdx] = folded\n            return {\n              ...prev,\n              notifications: {\n                current: prev.notifications.current,\n                queue: newQueue,\n              },\n            }\n          }\n        }\n\n        // Only add to queue if not already present (prevent duplicates)\n        const queuedKeys = new Set(prev.notifications.queue.map(_ => _.key))\n        const shouldAdd =\n          !queuedKeys.has(notif.key) &&\n          prev.notifications.current?.key !== notif.key\n\n        if (!shouldAdd) return prev\n\n        const invalidatesCurrent =\n          prev.notifications.current !== null &&\n          notif.invalidates?.includes(prev.notifications.current.key)\n\n        if (invalidatesCurrent && currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        return {\n          ...prev,\n          notifications: {\n            current: invalidatesCurrent ? null : prev.notifications.current,\n            queue: [\n              ...prev.notifications.queue.filter(\n                _ =>\n                  _.priority !== 'immediate' &&\n                  !notif.invalidates?.includes(_.key),\n              ),\n              notif,\n            ],\n          },\n        }\n      })\n\n      // Process queue after adding the notification\n      processQueue()\n    },\n    [setAppState, processQueue],\n  )\n\n  const removeNotification = useCallback<RemoveNotificationFn>(\n    (key: string) => {\n      setAppState(prev => {\n        const isCurrent = prev.notifications.current?.key === key\n        const inQueue = prev.notifications.queue.some(n => n.key === key)\n\n        if (!isCurrent && !inQueue) {\n          return prev\n        }\n\n        if (isCurrent && currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        return {\n          ...prev,\n          notifications: {\n            current: isCurrent ? null : prev.notifications.current,\n            queue: prev.notifications.queue.filter(n => n.key !== key),\n          },\n        }\n      })\n\n      processQueue()\n    },\n    [setAppState, processQueue],\n  )\n\n  // Process queue on mount if there are notifications in the initial state.\n  // Imperative read (not useAppState) — a subscription in a mount-only\n  // effect would be vestigial and make every caller re-render on queue changes.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only effect, store is a stable context ref\n  useEffect(() => {\n    if (store.getState().notifications.queue.length > 0) {\n      processQueue()\n    }\n  }, [])\n\n  return { addNotification, removeNotification }\n}\n\nconst PRIORITIES: Record<Priority, number> = {\n  immediate: 0,\n  high: 1,\n  medium: 2,\n  low: 3,\n}\nexport function getNext(queue: Notification[]): Notification | undefined {\n  if (queue.length === 0) return undefined\n  return queue.reduce((min, n) =>\n    PRIORITIES[n.priority] < PRIORITIES[min.priority] ? n : min,\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/context/overlayContext.tsx b/src/context/overlayContext.tsx new file mode 100644 index 0000000000000000000000000000000000000000..0f20f62c12137bc4b456d639354b18ee63078f80 --- /dev/null +++ b/src/context/overlayContext.tsx @@ -0,0 +1,151 @@ +import { c as _c } from "react/compiler-runtime"; +/** + * Overlay tracking for Escape key coordination. + * + * This solves the problem of escape key handling when overlays (like Select with onCancel) + * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't + * cancel requests when the user just wants to dismiss the overlay. + * + * Usage: + * 1. Call useRegisterOverlay() in any overlay component to automatically register it + * 2. Call useIsOverlayActive() to check if any overlay is currently active + * + * The hook automatically registers on mount and unregisters on unmount, + * so no manual cleanup or state management is needed. + */ +import { useContext, useEffect, useLayoutEffect } from 'react'; +import instances from '../ink/instances.js'; +import { AppStoreContext, useAppState } from '../state/AppState.js'; + +// Non-modal overlays that shouldn't disable TextInput focus +const NON_MODAL_OVERLAYS = new Set(['autocomplete']); + +/** + * Hook to register a component as an active overlay. + * Automatically registers on mount and unregisters on unmount. + * + * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select') + * @param enabled - Whether to register (default: true). Use this to conditionally register + * based on component props, e.g., only register when onCancel is provided. + * + * @example + * // Conditional registration based on whether cancel is supported + * function useSelectInput({ state }) { + * useRegisterOverlay('select', !!state.onCancel) + * // ... + * } + */ +export function useRegisterOverlay(id, t0) { + const $ = _c(8); + const enabled = t0 === undefined ? true : t0; + const store = useContext(AppStoreContext); + const setAppState = store?.setState; + let t1; + let t2; + if ($[0] !== enabled || $[1] !== id || $[2] !== setAppState) { + t1 = () => { + if (!enabled || !setAppState) { + return; + } + setAppState(prev => { + if (prev.activeOverlays.has(id)) { + return prev; + } + const next = new Set(prev.activeOverlays); + next.add(id); + return { + ...prev, + activeOverlays: next + }; + }); + return () => { + setAppState(prev_0 => { + if (!prev_0.activeOverlays.has(id)) { + return prev_0; + } + const next_0 = new Set(prev_0.activeOverlays); + next_0.delete(id); + return { + ...prev_0, + activeOverlays: next_0 + }; + }); + }; + }; + t2 = [id, enabled, setAppState]; + $[0] = enabled; + $[1] = id; + $[2] = setAppState; + $[3] = t1; + $[4] = t2; + } else { + t1 = $[3]; + t2 = $[4]; + } + useEffect(t1, t2); + let t3; + let t4; + if ($[5] !== enabled) { + t3 = () => { + if (!enabled) { + return; + } + return _temp; + }; + t4 = [enabled]; + $[5] = enabled; + $[6] = t3; + $[7] = t4; + } else { + t3 = $[6]; + t4 = $[7]; + } + useLayoutEffect(t3, t4); +} + +/** + * Hook to check if any overlay is currently active. + * This is reactive - the component will re-render when the overlay state changes. + * + * @returns true if any overlay is currently active + * + * @example + * function CancelRequestHandler() { + * const isOverlayActive = useIsOverlayActive() + * const isActive = !isOverlayActive && canCancelRunningTask + * useKeybinding('chat:cancel', handleCancel, { isActive }) + * } + */ +function _temp() { + return instances.get(process.stdout)?.invalidatePrevFrame(); +} +export function useIsOverlayActive() { + return useAppState(_temp2); +} + +/** + * Hook to check if any modal overlay is currently active. + * Modal overlays are overlays that should capture all input (like Select dialogs). + * Non-modal overlays (like autocomplete) don't disable TextInput focus. + * + * @returns true if any modal overlay is currently active + * + * @example + * // Use for TextInput focus - allows typing during autocomplete + * focus: !isSearchingHistory && !isModalOverlayActive + */ +function _temp2(s) { + return s.activeOverlays.size > 0; +} +export function useIsModalOverlayActive() { + return useAppState(_temp3); +} +function _temp3(s) { + for (const id of s.activeOverlays) { + if (!NON_MODAL_OVERLAYS.has(id)) { + return true; + } + } + return false; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useContext","useEffect","useLayoutEffect","instances","AppStoreContext","useAppState","NON_MODAL_OVERLAYS","Set","useRegisterOverlay","id","t0","$","_c","enabled","undefined","store","setAppState","setState","t1","t2","prev","activeOverlays","has","next","add","prev_0","next_0","delete","t3","t4","_temp","get","process","stdout","invalidatePrevFrame","useIsOverlayActive","_temp2","s","size","useIsModalOverlayActive","_temp3"],"sources":["overlayContext.tsx"],"sourcesContent":["/**\n * Overlay tracking for Escape key coordination.\n *\n * This solves the problem of escape key handling when overlays (like Select with onCancel)\n * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't\n * cancel requests when the user just wants to dismiss the overlay.\n *\n * Usage:\n * 1. Call useRegisterOverlay() in any overlay component to automatically register it\n * 2. Call useIsOverlayActive() to check if any overlay is currently active\n *\n * The hook automatically registers on mount and unregisters on unmount,\n * so no manual cleanup or state management is needed.\n */\nimport { useContext, useEffect, useLayoutEffect } from 'react'\nimport instances from '../ink/instances.js'\nimport { AppStoreContext, useAppState } from '../state/AppState.js'\n\n// Non-modal overlays that shouldn't disable TextInput focus\nconst NON_MODAL_OVERLAYS = new Set(['autocomplete'])\n\n/**\n * Hook to register a component as an active overlay.\n * Automatically registers on mount and unregisters on unmount.\n *\n * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select')\n * @param enabled - Whether to register (default: true). Use this to conditionally register\n *                  based on component props, e.g., only register when onCancel is provided.\n *\n * @example\n * // Conditional registration based on whether cancel is supported\n * function useSelectInput({ state }) {\n *   useRegisterOverlay('select', !!state.onCancel)\n *   // ...\n * }\n */\nexport function useRegisterOverlay(id: string, enabled = true): void {\n  // Use context directly so this is a no-op when rendered outside AppStateProvider\n  // (e.g., in isolated component tests that don't need the full app state tree).\n  const store = useContext(AppStoreContext)\n  const setAppState = store?.setState\n  useEffect(() => {\n    if (!enabled || !setAppState) return\n    setAppState(prev => {\n      if (prev.activeOverlays.has(id)) return prev\n      const next = new Set(prev.activeOverlays)\n      next.add(id)\n      return { ...prev, activeOverlays: next }\n    })\n    return () => {\n      setAppState(prev => {\n        if (!prev.activeOverlays.has(id)) return prev\n        const next = new Set(prev.activeOverlays)\n        next.delete(id)\n        return { ...prev, activeOverlays: next }\n      })\n    }\n  }, [id, enabled, setAppState])\n\n  // On overlay close, force the next render to full-damage diff instead\n  // of blit. A tall overlay (e.g. FuzzyPicker with a 20-line preview)\n  // shrinks the Ink-managed region on unmount; the blit fast path can\n  // copy stale cells from the overlay's previous frame into rows the\n  // shorter layout no longer reaches, leaving a ghost title/divider.\n  // useLayoutEffect so cleanup runs synchronously before the microtask-\n  // deferred onRender (scheduleRender queues a microtask from\n  // resetAfterCommit; passive-effect cleanup would land after it).\n  useLayoutEffect(() => {\n    if (!enabled) return\n    return () => instances.get(process.stdout)?.invalidatePrevFrame()\n  }, [enabled])\n}\n\n/**\n * Hook to check if any overlay is currently active.\n * This is reactive - the component will re-render when the overlay state changes.\n *\n * @returns true if any overlay is currently active\n *\n * @example\n * function CancelRequestHandler() {\n *   const isOverlayActive = useIsOverlayActive()\n *   const isActive = !isOverlayActive && canCancelRunningTask\n *   useKeybinding('chat:cancel', handleCancel, { isActive })\n * }\n */\nexport function useIsOverlayActive(): boolean {\n  return useAppState(s => s.activeOverlays.size > 0)\n}\n\n/**\n * Hook to check if any modal overlay is currently active.\n * Modal overlays are overlays that should capture all input (like Select dialogs).\n * Non-modal overlays (like autocomplete) don't disable TextInput focus.\n *\n * @returns true if any modal overlay is currently active\n *\n * @example\n * // Use for TextInput focus - allows typing during autocomplete\n * focus: !isSearchingHistory && !isModalOverlayActive\n */\nexport function useIsModalOverlayActive(): boolean {\n  return useAppState(s => {\n    for (const id of s.activeOverlays) {\n      if (!NON_MODAL_OVERLAYS.has(id)) return true\n    }\n    return false\n  })\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/context/voice.tsx b/src/context/voice.tsx new file mode 100644 index 0000000000000000000000000000000000000000..04e14ddc16a603aa5426a5eaa49816a9aa161289 --- /dev/null +++ b/src/context/voice.tsx @@ -0,0 +1,88 @@ +import { c as _c } from "react/compiler-runtime"; +import React, { createContext, useContext, useState, useSyncExternalStore } from 'react'; +import { createStore, type Store } from '../state/store.js'; +export type VoiceState = { + voiceState: 'idle' | 'recording' | 'processing'; + voiceError: string | null; + voiceInterimTranscript: string; + voiceAudioLevels: number[]; + voiceWarmingUp: boolean; +}; +const DEFAULT_STATE: VoiceState = { + voiceState: 'idle', + voiceError: null, + voiceInterimTranscript: '', + voiceAudioLevels: [], + voiceWarmingUp: false +}; +type VoiceStore = Store; +const VoiceContext = createContext(null); +type Props = { + children: React.ReactNode; +}; +export function VoiceProvider(t0) { + const $ = _c(3); + const { + children + } = t0; + const [store] = useState(_temp); + let t1; + if ($[0] !== children || $[1] !== store) { + t1 = {children}; + $[0] = children; + $[1] = store; + $[2] = t1; + } else { + t1 = $[2]; + } + return t1; +} +function _temp() { + return createStore(DEFAULT_STATE); +} +function useVoiceStore() { + const store = useContext(VoiceContext); + if (!store) { + throw new Error("useVoiceState must be used within a VoiceProvider"); + } + return store; +} + +/** + * Subscribe to a slice of voice state. Only re-renders when the selected + * value changes (compared via Object.is). + */ +export function useVoiceState(selector) { + const $ = _c(3); + const store = useVoiceStore(); + let t0; + if ($[0] !== selector || $[1] !== store) { + t0 = () => selector(store.getState()); + $[0] = selector; + $[1] = store; + $[2] = t0; + } else { + t0 = $[2]; + } + const get = t0; + return useSyncExternalStore(store.subscribe, get, get); +} + +/** + * Get the voice state setter. Stable reference — never causes re-renders. + * store.setState is synchronous: callers can read getVoiceState() immediately + * after to observe the new value (VoiceKeybindingHandler relies on this). + */ +export function useSetVoiceState() { + return useVoiceStore().setState; +} + +/** + * Get a synchronous reader for fresh state inside callbacks. Unlike + * useVoiceState (which subscribes), this doesn't cause re-renders — use + * inside event handlers that need to read state set earlier in the same tick. + */ +export function useGetVoiceState() { + return useVoiceStore().getState; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/src/coordinator/coordinatorMode.ts b/src/coordinator/coordinatorMode.ts new file mode 100644 index 0000000000000000000000000000000000000000..fc5dc4eb174d8895a7698cb74381d75bfd12868a --- /dev/null +++ b/src/coordinator/coordinatorMode.ts @@ -0,0 +1,369 @@ +import { feature } from 'bun:bundle' +import { ASYNC_AGENT_ALLOWED_TOOLS } from '../constants/tools.js' +import { checkStatsigFeatureGate_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 { AGENT_TOOL_NAME } from '../tools/AgentTool/constants.js' +import { BASH_TOOL_NAME } from '../tools/BashTool/toolName.js' +import { FILE_EDIT_TOOL_NAME } from '../tools/FileEditTool/constants.js' +import { FILE_READ_TOOL_NAME } from '../tools/FileReadTool/prompt.js' +import { SEND_MESSAGE_TOOL_NAME } from '../tools/SendMessageTool/constants.js' +import { SYNTHETIC_OUTPUT_TOOL_NAME } from '../tools/SyntheticOutputTool/SyntheticOutputTool.js' +import { TASK_STOP_TOOL_NAME } from '../tools/TaskStopTool/prompt.js' +import { TEAM_CREATE_TOOL_NAME } from '../tools/TeamCreateTool/constants.js' +import { TEAM_DELETE_TOOL_NAME } from '../tools/TeamDeleteTool/constants.js' +import { isEnvTruthy } from '../utils/envUtils.js' + +// Checks the same gate as isScratchpadEnabled() in +// utils/permissions/filesystem.ts. Duplicated here because importing +// filesystem.ts creates a circular dependency (filesystem -> permissions +// -> ... -> coordinatorMode). The actual scratchpad path is passed in via +// getCoordinatorUserContext's scratchpadDir parameter (dependency injection +// from QueryEngine.ts, which lives higher in the dep graph). +function isScratchpadGateEnabled(): boolean { + return checkStatsigFeatureGate_CACHED_MAY_BE_STALE('tengu_scratch') +} + +const INTERNAL_WORKER_TOOLS = new Set([ + TEAM_CREATE_TOOL_NAME, + TEAM_DELETE_TOOL_NAME, + SEND_MESSAGE_TOOL_NAME, + SYNTHETIC_OUTPUT_TOOL_NAME, +]) + +export function isCoordinatorMode(): boolean { + if (feature('COORDINATOR_MODE')) { + return isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE) + } + return false +} + +/** + * Checks if the current coordinator mode matches the session's stored mode. + * If mismatched, flips the environment variable so isCoordinatorMode() returns + * the correct value for the resumed session. Returns a warning message if + * the mode was switched, or undefined if no switch was needed. + */ +export function matchSessionMode( + sessionMode: 'coordinator' | 'normal' | undefined, +): string | undefined { + // No stored mode (old session before mode tracking) — do nothing + if (!sessionMode) { + return undefined + } + + const currentIsCoordinator = isCoordinatorMode() + const sessionIsCoordinator = sessionMode === 'coordinator' + + if (currentIsCoordinator === sessionIsCoordinator) { + return undefined + } + + // Flip the env var — isCoordinatorMode() reads it live, no caching + if (sessionIsCoordinator) { + process.env.CLAUDE_CODE_COORDINATOR_MODE = '1' + } else { + delete process.env.CLAUDE_CODE_COORDINATOR_MODE + } + + logEvent('tengu_coordinator_mode_switched', { + to: sessionMode as unknown as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, + }) + + return sessionIsCoordinator + ? 'Entered coordinator mode to match resumed session.' + : 'Exited coordinator mode to match resumed session.' +} + +export function getCoordinatorUserContext( + mcpClients: ReadonlyArray<{ name: string }>, + scratchpadDir?: string, +): { [k: string]: string } { + if (!isCoordinatorMode()) { + return {} + } + + const workerTools = isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE) + ? [BASH_TOOL_NAME, FILE_READ_TOOL_NAME, FILE_EDIT_TOOL_NAME] + .sort() + .join(', ') + : Array.from(ASYNC_AGENT_ALLOWED_TOOLS) + .filter(name => !INTERNAL_WORKER_TOOLS.has(name)) + .sort() + .join(', ') + + let content = `Workers spawned via the ${AGENT_TOOL_NAME} tool have access to these tools: ${workerTools}` + + if (mcpClients.length > 0) { + const serverNames = mcpClients.map(c => c.name).join(', ') + content += `\n\nWorkers also have access to MCP tools from connected MCP servers: ${serverNames}` + } + + if (scratchpadDir && isScratchpadGateEnabled()) { + content += `\n\nScratchpad directory: ${scratchpadDir}\nWorkers can read and write here without permission prompts. Use this for durable cross-worker knowledge — structure files however fits the work.` + } + + return { workerToolsContext: content } +} + +export function getCoordinatorSystemPrompt(): string { + const workerCapabilities = isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE) + ? 'Workers have access to Bash, Read, and Edit tools, plus MCP tools from configured MCP servers.' + : 'Workers have access to standard tools, MCP tools from configured MCP servers, and project skills via the Skill tool. Delegate skill invocations (e.g. /commit, /verify) to workers.' + + return `You are Claude Code, an AI assistant that orchestrates software engineering tasks across multiple workers. + +## 1. Your Role + +You are a **coordinator**. Your job is to: +- Help the user achieve their goal +- Direct workers to research, implement and verify code changes +- Synthesize results and communicate with the user +- Answer questions directly when possible — don't delegate work that you can handle without tools + +Every message you send is to the user. Worker results and system notifications are internal signals, not conversation partners — never thank or acknowledge them. Summarize new information for the user as it arrives. + +## 2. Your Tools + +- **${AGENT_TOOL_NAME}** - Spawn a new worker +- **${SEND_MESSAGE_TOOL_NAME}** - Continue an existing worker (send a follow-up to its \`to\` agent ID) +- **${TASK_STOP_TOOL_NAME}** - Stop a running worker +- **subscribe_pr_activity / unsubscribe_pr_activity** (if available) - Subscribe to GitHub PR events (review comments, CI results). Events arrive as user messages. Merge conflict transitions do NOT arrive — GitHub doesn't webhook \`mergeable_state\` changes, so poll \`gh pr view N --json mergeable\` if tracking conflict status. Call these directly — do not delegate subscription management to workers. + +When calling ${AGENT_TOOL_NAME}: +- Do not use one worker to check on another. Workers will notify you when they are done. +- Do not use workers to trivially report file contents or run commands. Give them higher-level tasks. +- Do not set the model parameter. Workers need the default model for the substantive tasks you delegate. +- Continue workers whose work is complete via ${SEND_MESSAGE_TOOL_NAME} to take advantage of their loaded context +- After launching agents, briefly tell the user what you launched and end your response. Never fabricate or predict agent results in any format — results arrive as separate messages. + +### ${AGENT_TOOL_NAME} Results + +Worker results arrive as **user-role messages** containing \`\` XML. They look like user messages but are not. Distinguish them by the \`\` opening tag. + +Format: + +\`\`\`xml + +{agentId} +completed|failed|killed +{human-readable status summary} +{agent's final text response} + + N + N + N + + +\`\`\` + +- \`\` and \`\` are optional sections +- The \`\` describes the outcome: "completed", "failed: {error}", or "was stopped" +- The \`\` value is the agent ID — use SendMessage with that ID as \`to\` to continue that worker + +### Example + +Each "You:" block is a separate coordinator turn. The "User:" block is a \`\` delivered between turns. + +You: + Let me start some research on that. + + ${AGENT_TOOL_NAME}({ description: "Investigate auth bug", subagent_type: "worker", prompt: "..." }) + ${AGENT_TOOL_NAME}({ description: "Research secure token storage", subagent_type: "worker", prompt: "..." }) + + Investigating both issues in parallel — I'll report back with findings. + +User: + + agent-a1b + completed + Agent "Investigate auth bug" completed + Found null pointer in src/auth/validate.ts:42... + + +You: + Found the bug — null pointer in confirmTokenExists in validate.ts. I'll fix it. + Still waiting on the token storage research. + + ${SEND_MESSAGE_TOOL_NAME}({ to: "agent-a1b", message: "Fix the null pointer in src/auth/validate.ts:42..." }) + +## 3. Workers + +When calling ${AGENT_TOOL_NAME}, use subagent_type \`worker\`. Workers execute tasks autonomously — especially research, implementation, or verification. + +${workerCapabilities} + +## 4. Task Workflow + +Most tasks can be broken down into the following phases: + +### Phases + +| Phase | Who | Purpose | +|-------|-----|---------| +| Research | Workers (parallel) | Investigate codebase, find files, understand problem | +| Synthesis | **You** (coordinator) | Read findings, understand the problem, craft implementation specs (see Section 5) | +| Implementation | Workers | Make targeted changes per spec, commit | +| Verification | Workers | Test changes work | + +### Concurrency + +**Parallelism is your superpower. Workers are async. Launch independent workers concurrently whenever possible — don't serialize work that can run simultaneously and look for opportunities to fan out. When doing research, cover multiple angles. To launch workers in parallel, make multiple tool calls in a single message.** + +Manage concurrency: +- **Read-only tasks** (research) — run in parallel freely +- **Write-heavy tasks** (implementation) — one at a time per set of files +- **Verification** can sometimes run alongside implementation on different file areas + +### What Real Verification Looks Like + +Verification means **proving the code works**, not confirming it exists. A verifier that rubber-stamps weak work undermines everything. + +- Run tests **with the feature enabled** — not just "tests pass" +- Run typechecks and **investigate errors** — don't dismiss as "unrelated" +- Be skeptical — if something looks off, dig in +- **Test independently** — prove the change works, don't rubber-stamp + +### Handling Worker Failures + +When a worker reports failure (tests failed, build errors, file not found): +- Continue the same worker with ${SEND_MESSAGE_TOOL_NAME} — it has the full error context +- If a correction attempt fails, try a different approach or report to the user + +### Stopping Workers + +Use ${TASK_STOP_TOOL_NAME} to stop a worker you sent in the wrong direction — for example, when you realize mid-flight that the approach is wrong, or the user changes requirements after you launched the worker. Pass the \`task_id\` from the ${AGENT_TOOL_NAME} tool's launch result. Stopped workers can be continued with ${SEND_MESSAGE_TOOL_NAME}. + +\`\`\` +// Launched a worker to refactor auth to use JWT +${AGENT_TOOL_NAME}({ description: "Refactor auth to JWT", subagent_type: "worker", prompt: "Replace session-based auth with JWT..." }) +// ... returns task_id: "agent-x7q" ... + +// User clarifies: "Actually, keep sessions — just fix the null pointer" +${TASK_STOP_TOOL_NAME}({ task_id: "agent-x7q" }) + +// Continue with corrected instructions +${SEND_MESSAGE_TOOL_NAME}({ to: "agent-x7q", message: "Stop the JWT refactor. Instead, fix the null pointer in src/auth/validate.ts:42..." }) +\`\`\` + +## 5. Writing Worker Prompts + +**Workers can't see your conversation.** Every prompt must be self-contained with everything the worker needs. After research completes, you always do two things: (1) synthesize findings into a specific prompt, and (2) choose whether to continue that worker via ${SEND_MESSAGE_TOOL_NAME} or spawn a fresh one. + +### Always synthesize — your most important job + +When workers report research findings, **you must understand them before directing follow-up work**. Read the findings. Identify the approach. Then write a prompt that proves you understood by including specific file paths, line numbers, and exactly what to change. + +Never write "based on your findings" or "based on the research." These phrases delegate understanding to the worker instead of doing it yourself. You never hand off understanding to another worker. + +\`\`\` +// Anti-pattern — lazy delegation (bad whether continuing or spawning) +${AGENT_TOOL_NAME}({ prompt: "Based on your findings, fix the auth bug", ... }) +${AGENT_TOOL_NAME}({ prompt: "The worker found an issue in the auth module. Please fix it.", ... }) + +// Good — synthesized spec (works with either continue or spawn) +${AGENT_TOOL_NAME}({ prompt: "Fix the null pointer in src/auth/validate.ts:42. The user field on Session (src/auth/types.ts:15) is undefined when sessions expire but the token remains cached. Add a null check before user.id access — if null, return 401 with 'Session expired'. Commit and report the hash.", ... }) +\`\`\` + +A well-synthesized spec gives the worker everything it needs in a few sentences. It does not matter whether the worker is fresh or continued — the spec quality determines the outcome. + +### Add a purpose statement + +Include a brief purpose so workers can calibrate depth and emphasis: + +- "This research will inform a PR description — focus on user-facing changes." +- "I need this to plan an implementation — report file paths, line numbers, and type signatures." +- "This is a quick check before we merge — just verify the happy path." + +### Choose continue vs. spawn by context overlap + +After synthesizing, decide whether the worker's existing context helps or hurts: + +| Situation | Mechanism | Why | +|-----------|-----------|-----| +| Research explored exactly the files that need editing | **Continue** (${SEND_MESSAGE_TOOL_NAME}) with synthesized spec | Worker already has the files in context AND now gets a clear plan | +| Research was broad but implementation is narrow | **Spawn fresh** (${AGENT_TOOL_NAME}) with synthesized spec | Avoid dragging along exploration noise; focused context is cleaner | +| Correcting a failure or extending recent work | **Continue** | Worker has the error context and knows what it just tried | +| Verifying code a different worker just wrote | **Spawn fresh** | Verifier should see the code with fresh eyes, not carry implementation assumptions | +| First implementation attempt used the wrong approach entirely | **Spawn fresh** | Wrong-approach context pollutes the retry; clean slate avoids anchoring on the failed path | +| Completely unrelated task | **Spawn fresh** | No useful context to reuse | + +There is no universal default. Think about how much of the worker's context overlaps with the next task. High overlap -> continue. Low overlap -> spawn fresh. + +### Continue mechanics + +When continuing a worker with ${SEND_MESSAGE_TOOL_NAME}, it has full context from its previous run: +\`\`\` +// Continuation — worker finished research, now give it a synthesized implementation spec +${SEND_MESSAGE_TOOL_NAME}({ to: "xyz-456", message: "Fix the null pointer in src/auth/validate.ts:42. The user field is undefined when Session.expired is true but the token is still cached. Add a null check before accessing user.id — if null, return 401 with 'Session expired'. Commit and report the hash." }) +\`\`\` + +\`\`\` +// Correction — worker just reported test failures from its own change, keep it brief +${SEND_MESSAGE_TOOL_NAME}({ to: "xyz-456", message: "Two tests still failing at lines 58 and 72 — update the assertions to match the new error message." }) +\`\`\` + +### Prompt tips + +**Good examples:** + +1. Implementation: "Fix the null pointer in src/auth/validate.ts:42. The user field can be undefined when the session expires. Add a null check and return early with an appropriate error. Commit and report the hash." + +2. Precise git operation: "Create a new branch from main called 'fix/session-expiry'. Cherry-pick only commit abc123 onto it. Push and create a draft PR targeting main. Add anthropics/claude-code as reviewer. Report the PR URL." + +3. Correction (continued worker, short): "The tests failed on the null check you added — validate.test.ts:58 expects 'Invalid session' but you changed it to 'Session expired'. Fix the assertion. Commit and report the hash." + +**Bad examples:** + +1. "Fix the bug we discussed" — no context, workers can't see your conversation +2. "Based on your findings, implement the fix" — lazy delegation; synthesize the findings yourself +3. "Create a PR for the recent changes" — ambiguous scope: which changes? which branch? draft? +4. "Something went wrong with the tests, can you look?" — no error message, no file path, no direction + +Additional tips: +- Include file paths, line numbers, error messages — workers start fresh and need complete context +- State what "done" looks like +- For implementation: "Run relevant tests and typecheck, then commit your changes and report the hash" — workers self-verify before reporting done. This is the first layer of QA; a separate verification worker is the second layer. +- For research: "Report findings — do not modify files" +- Be precise about git operations — specify branch names, commit hashes, draft vs ready, reviewers +- When continuing for corrections: reference what the worker did ("the null check you added") not what you discussed with the user +- For implementation: "Fix the root cause, not the symptom" — guide workers toward durable fixes +- For verification: "Prove the code works, don't just confirm it exists" +- For verification: "Try edge cases and error paths — don't just re-run what the implementation worker ran" +- For verification: "Investigate failures — don't dismiss as unrelated without evidence" + +## 6. Example Session + +User: "There's a null pointer in the auth module. Can you fix it?" + +You: + Let me investigate first. + + ${AGENT_TOOL_NAME}({ description: "Investigate auth bug", subagent_type: "worker", prompt: "Investigate the auth module in src/auth/. Find where null pointer exceptions could occur around session handling and token validation... Report specific file paths, line numbers, and types involved. Do not modify files." }) + ${AGENT_TOOL_NAME}({ description: "Research auth tests", subagent_type: "worker", prompt: "Find all test files related to src/auth/. Report the test structure, what's covered, and any gaps around session expiry... Do not modify files." }) + + Investigating from two angles — I'll report back with findings. + +User: + + agent-a1b + completed + Agent "Investigate auth bug" completed + Found null pointer in src/auth/validate.ts:42. The user field on Session is undefined when the session expires but ... + + +You: + Found the bug — null pointer in validate.ts:42. + + ${SEND_MESSAGE_TOOL_NAME}({ to: "agent-a1b", message: "Fix the null pointer in src/auth/validate.ts:42. Add a null check before accessing user.id — if null, ... Commit and report the hash." }) + + Fix is in progress. + +User: + How's it going? + +You: + Fix for the new test is in progress. Still waiting to hear back about the test suite.` +} diff --git a/src/entrypoints/cli.tsx b/src/entrypoints/cli.tsx new file mode 100644 index 0000000000000000000000000000000000000000..67326f890053cb527d70b58a38fa3bd41854cedd --- /dev/null +++ b/src/entrypoints/cli.tsx @@ -0,0 +1,303 @@ +import { feature } from 'bun:bundle'; + +// Bugfix for corepack auto-pinning, which adds yarnpkg to peoples' package.jsons +// eslint-disable-next-line custom-rules/no-top-level-side-effects +process.env.COREPACK_ENABLE_AUTO_PIN = '0'; + +// Set max heap size for child processes in CCR environments (containers have 16GB) +// eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level, custom-rules/safe-env-boolean-check +if (process.env.CLAUDE_CODE_REMOTE === 'true') { + // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level + const existing = process.env.NODE_OPTIONS || ''; + // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level + process.env.NODE_OPTIONS = existing ? `${existing} --max-old-space-size=8192` : '--max-old-space-size=8192'; +} + +// Harness-science L0 ablation baseline. Inlined here (not init.ts) because +// BashTool/AgentTool/PowerShellTool capture DISABLE_BACKGROUND_TASKS into +// module-level consts at import time — init() runs too late. feature() gate +// DCEs this entire block from external builds. +// eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level +if (feature('ABLATION_BASELINE') && process.env.CLAUDE_CODE_ABLATION_BASELINE) { + for (const k of ['CLAUDE_CODE_SIMPLE', 'CLAUDE_CODE_DISABLE_THINKING', 'DISABLE_INTERLEAVED_THINKING', 'DISABLE_COMPACT', 'DISABLE_AUTO_COMPACT', 'CLAUDE_CODE_DISABLE_AUTO_MEMORY', 'CLAUDE_CODE_DISABLE_BACKGROUND_TASKS']) { + // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level + process.env[k] ??= '1'; + } +} + +/** + * Bootstrap entrypoint - checks for special flags before loading the full CLI. + * All imports are dynamic to minimize module evaluation for fast paths. + * Fast-path for --version has zero imports beyond this file. + */ +async function main(): Promise { + const args = process.argv.slice(2); + + // Fast-path for --version/-v: zero module loading needed + if (args.length === 1 && (args[0] === '--version' || args[0] === '-v' || args[0] === '-V')) { + // MACRO.VERSION is inlined at build time + // biome-ignore lint/suspicious/noConsole:: intentional console output + console.log(`${MACRO.VERSION} (Claude Code)`); + return; + } + + // For all other paths, load the startup profiler + const { + profileCheckpoint + } = await import('../utils/startupProfiler.js'); + profileCheckpoint('cli_entry'); + + // Fast-path for --dump-system-prompt: output the rendered system prompt and exit. + // Used by prompt sensitivity evals to extract the system prompt at a specific commit. + // Ant-only: eliminated from external builds via feature flag. + if (feature('DUMP_SYSTEM_PROMPT') && args[0] === '--dump-system-prompt') { + profileCheckpoint('cli_dump_system_prompt_path'); + const { + enableConfigs + } = await import('../utils/config.js'); + enableConfigs(); + const { + getMainLoopModel + } = await import('../utils/model/model.js'); + const modelIdx = args.indexOf('--model'); + const model = modelIdx !== -1 && args[modelIdx + 1] || getMainLoopModel(); + const { + getSystemPrompt + } = await import('../constants/prompts.js'); + const prompt = await getSystemPrompt([], model); + // biome-ignore lint/suspicious/noConsole:: intentional console output + console.log(prompt.join('\n')); + return; + } + if (process.argv[2] === '--claude-in-chrome-mcp') { + profileCheckpoint('cli_claude_in_chrome_mcp_path'); + const { + runClaudeInChromeMcpServer + } = await import('../utils/claudeInChrome/mcpServer.js'); + await runClaudeInChromeMcpServer(); + return; + } else if (process.argv[2] === '--chrome-native-host') { + profileCheckpoint('cli_chrome_native_host_path'); + const { + runChromeNativeHost + } = await import('../utils/claudeInChrome/chromeNativeHost.js'); + await runChromeNativeHost(); + return; + } else if (feature('CHICAGO_MCP') && process.argv[2] === '--computer-use-mcp') { + profileCheckpoint('cli_computer_use_mcp_path'); + const { + runComputerUseMcpServer + } = await import('../utils/computerUse/mcpServer.js'); + await runComputerUseMcpServer(); + return; + } + + // Fast-path for `--daemon-worker=` (internal — supervisor spawns this). + // Must come before the daemon subcommand check: spawned per-worker, so + // perf-sensitive. No enableConfigs(), no analytics sinks at this layer — + // workers are lean. If a worker kind needs configs/auth (assistant will), + // it calls them inside its run() fn. + if (feature('DAEMON') && args[0] === '--daemon-worker') { + const { + runDaemonWorker + } = await import('../daemon/workerRegistry.js'); + await runDaemonWorker(args[1]); + return; + } + + // Fast-path for `claude remote-control` (also accepts legacy `claude remote` / `claude sync` / `claude bridge`): + // serve local machine as bridge environment. + // feature() must stay inline for build-time dead code elimination; + // isBridgeEnabled() checks the runtime GrowthBook gate. + if (feature('BRIDGE_MODE') && (args[0] === 'remote-control' || args[0] === 'rc' || args[0] === 'remote' || args[0] === 'sync' || args[0] === 'bridge')) { + profileCheckpoint('cli_bridge_path'); + const { + enableConfigs + } = await import('../utils/config.js'); + enableConfigs(); + const { + getBridgeDisabledReason, + checkBridgeMinVersion + } = await import('../bridge/bridgeEnabled.js'); + const { + BRIDGE_LOGIN_ERROR + } = await import('../bridge/types.js'); + const { + bridgeMain + } = await import('../bridge/bridgeMain.js'); + const { + exitWithError + } = await import('../utils/process.js'); + + // Auth check must come before the GrowthBook gate check — without auth, + // GrowthBook has no user context and would return a stale/default false. + // getBridgeDisabledReason awaits GB init, so the returned value is fresh + // (not the stale disk cache), but init still needs auth headers to work. + const { + getClaudeAIOAuthTokens + } = await import('../utils/auth.js'); + if (!getClaudeAIOAuthTokens()?.accessToken) { + exitWithError(BRIDGE_LOGIN_ERROR); + } + const disabledReason = await getBridgeDisabledReason(); + if (disabledReason) { + exitWithError(`Error: ${disabledReason}`); + } + const versionError = checkBridgeMinVersion(); + if (versionError) { + exitWithError(versionError); + } + + // Bridge is a remote control feature - check policy limits + const { + waitForPolicyLimitsToLoad, + isPolicyAllowed + } = await import('../services/policyLimits/index.js'); + await waitForPolicyLimitsToLoad(); + if (!isPolicyAllowed('allow_remote_control')) { + exitWithError("Error: Remote Control is disabled by your organization's policy."); + } + await bridgeMain(args.slice(1)); + return; + } + + // Fast-path for `claude daemon [subcommand]`: long-running supervisor. + if (feature('DAEMON') && args[0] === 'daemon') { + profileCheckpoint('cli_daemon_path'); + const { + enableConfigs + } = await import('../utils/config.js'); + enableConfigs(); + const { + initSinks + } = await import('../utils/sinks.js'); + initSinks(); + const { + daemonMain + } = await import('../daemon/main.js'); + await daemonMain(args.slice(1)); + return; + } + + // Fast-path for `claude ps|logs|attach|kill` and `--bg`/`--background`. + // Session management against the ~/.claude/sessions/ registry. Flag + // literals are inlined so bg.js only loads when actually dispatching. + if (feature('BG_SESSIONS') && (args[0] === 'ps' || args[0] === 'logs' || args[0] === 'attach' || args[0] === 'kill' || args.includes('--bg') || args.includes('--background'))) { + profileCheckpoint('cli_bg_path'); + const { + enableConfigs + } = await import('../utils/config.js'); + enableConfigs(); + const bg = await import('../cli/bg.js'); + switch (args[0]) { + case 'ps': + await bg.psHandler(args.slice(1)); + break; + case 'logs': + await bg.logsHandler(args[1]); + break; + case 'attach': + await bg.attachHandler(args[1]); + break; + case 'kill': + await bg.killHandler(args[1]); + break; + default: + await bg.handleBgFlag(args); + } + return; + } + + // Fast-path for template job commands. + if (feature('TEMPLATES') && (args[0] === 'new' || args[0] === 'list' || args[0] === 'reply')) { + profileCheckpoint('cli_templates_path'); + const { + templatesMain + } = await import('../cli/handlers/templateJobs.js'); + await templatesMain(args); + // process.exit (not return) — mountFleetView's Ink TUI can leave event + // loop handles that prevent natural exit. + // eslint-disable-next-line custom-rules/no-process-exit + process.exit(0); + } + + // Fast-path for `claude environment-runner`: headless BYOC runner. + // feature() must stay inline for build-time dead code elimination. + if (feature('BYOC_ENVIRONMENT_RUNNER') && args[0] === 'environment-runner') { + profileCheckpoint('cli_environment_runner_path'); + const { + environmentRunnerMain + } = await import('../environment-runner/main.js'); + await environmentRunnerMain(args.slice(1)); + return; + } + + // Fast-path for `claude self-hosted-runner`: headless self-hosted-runner + // targeting the SelfHostedRunnerWorkerService API (register + poll; poll IS + // heartbeat). feature() must stay inline for build-time dead code elimination. + if (feature('SELF_HOSTED_RUNNER') && args[0] === 'self-hosted-runner') { + profileCheckpoint('cli_self_hosted_runner_path'); + const { + selfHostedRunnerMain + } = await import('../self-hosted-runner/main.js'); + await selfHostedRunnerMain(args.slice(1)); + return; + } + + // Fast-path for --worktree --tmux: exec into tmux before loading full CLI + const hasTmuxFlag = args.includes('--tmux') || args.includes('--tmux=classic'); + if (hasTmuxFlag && (args.includes('-w') || args.includes('--worktree') || args.some(a => a.startsWith('--worktree=')))) { + profileCheckpoint('cli_tmux_worktree_fast_path'); + const { + enableConfigs + } = await import('../utils/config.js'); + enableConfigs(); + const { + isWorktreeModeEnabled + } = await import('../utils/worktreeModeEnabled.js'); + if (isWorktreeModeEnabled()) { + const { + execIntoTmuxWorktree + } = await import('../utils/worktree.js'); + const result = await execIntoTmuxWorktree(args); + if (result.handled) { + return; + } + // If not handled (e.g., error), fall through to normal CLI + if (result.error) { + const { + exitWithError + } = await import('../utils/process.js'); + exitWithError(result.error); + } + } + } + + // Redirect common update flag mistakes to the update subcommand + if (args.length === 1 && (args[0] === '--update' || args[0] === '--upgrade')) { + process.argv = [process.argv[0]!, process.argv[1]!, 'update']; + } + + // --bare: set SIMPLE early so gates fire during module eval / commander + // option building (not just inside the action handler). + if (args.includes('--bare')) { + process.env.CLAUDE_CODE_SIMPLE = '1'; + } + + // No special flags detected, load and run the full CLI + const { + startCapturingEarlyInput + } = await import('../utils/earlyInput.js'); + startCapturingEarlyInput(); + profileCheckpoint('cli_before_main_import'); + const { + main: cliMain + } = await import('../main.js'); + profileCheckpoint('cli_after_main_import'); + await cliMain(); + profileCheckpoint('cli_after_main_complete'); +} + +// eslint-disable-next-line custom-rules/no-top-level-side-effects +void main(); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","process","env","COREPACK_ENABLE_AUTO_PIN","CLAUDE_CODE_REMOTE","existing","NODE_OPTIONS","CLAUDE_CODE_ABLATION_BASELINE","k","main","Promise","args","argv","slice","length","console","log","MACRO","VERSION","profileCheckpoint","enableConfigs","getMainLoopModel","modelIdx","indexOf","model","getSystemPrompt","prompt","join","runClaudeInChromeMcpServer","runChromeNativeHost","runComputerUseMcpServer","runDaemonWorker","getBridgeDisabledReason","checkBridgeMinVersion","BRIDGE_LOGIN_ERROR","bridgeMain","exitWithError","getClaudeAIOAuthTokens","accessToken","disabledReason","versionError","waitForPolicyLimitsToLoad","isPolicyAllowed","initSinks","daemonMain","includes","bg","psHandler","logsHandler","attachHandler","killHandler","handleBgFlag","templatesMain","exit","environmentRunnerMain","selfHostedRunnerMain","hasTmuxFlag","some","a","startsWith","isWorktreeModeEnabled","execIntoTmuxWorktree","result","handled","error","CLAUDE_CODE_SIMPLE","startCapturingEarlyInput","cliMain"],"sources":["cli.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\n\n// Bugfix for corepack auto-pinning, which adds yarnpkg to peoples' package.jsons\n// eslint-disable-next-line custom-rules/no-top-level-side-effects\nprocess.env.COREPACK_ENABLE_AUTO_PIN = '0'\n\n// Set max heap size for child processes in CCR environments (containers have 16GB)\n// eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level, custom-rules/safe-env-boolean-check\nif (process.env.CLAUDE_CODE_REMOTE === 'true') {\n  // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level\n  const existing = process.env.NODE_OPTIONS || ''\n  // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level\n  process.env.NODE_OPTIONS = existing\n    ? `${existing} --max-old-space-size=8192`\n    : '--max-old-space-size=8192'\n}\n\n// Harness-science L0 ablation baseline. Inlined here (not init.ts) because\n// BashTool/AgentTool/PowerShellTool capture DISABLE_BACKGROUND_TASKS into\n// module-level consts at import time — init() runs too late. feature() gate\n// DCEs this entire block from external builds.\n// eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level\nif (feature('ABLATION_BASELINE') && process.env.CLAUDE_CODE_ABLATION_BASELINE) {\n  for (const k of [\n    'CLAUDE_CODE_SIMPLE',\n    'CLAUDE_CODE_DISABLE_THINKING',\n    'DISABLE_INTERLEAVED_THINKING',\n    'DISABLE_COMPACT',\n    'DISABLE_AUTO_COMPACT',\n    'CLAUDE_CODE_DISABLE_AUTO_MEMORY',\n    'CLAUDE_CODE_DISABLE_BACKGROUND_TASKS',\n  ]) {\n    // eslint-disable-next-line custom-rules/no-top-level-side-effects, custom-rules/no-process-env-top-level\n    process.env[k] ??= '1'\n  }\n}\n\n/**\n * Bootstrap entrypoint - checks for special flags before loading the full CLI.\n * All imports are dynamic to minimize module evaluation for fast paths.\n * Fast-path for --version has zero imports beyond this file.\n */\nasync function main(): Promise<void> {\n  const args = process.argv.slice(2)\n\n  // Fast-path for --version/-v: zero module loading needed\n  if (\n    args.length === 1 &&\n    (args[0] === '--version' || args[0] === '-v' || args[0] === '-V')\n  ) {\n    // MACRO.VERSION is inlined at build time\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`${MACRO.VERSION} (Claude Code)`)\n    return\n  }\n\n  // For all other paths, load the startup profiler\n  const { profileCheckpoint } = await import('../utils/startupProfiler.js')\n  profileCheckpoint('cli_entry')\n\n  // Fast-path for --dump-system-prompt: output the rendered system prompt and exit.\n  // Used by prompt sensitivity evals to extract the system prompt at a specific commit.\n  // Ant-only: eliminated from external builds via feature flag.\n  if (feature('DUMP_SYSTEM_PROMPT') && args[0] === '--dump-system-prompt') {\n    profileCheckpoint('cli_dump_system_prompt_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n    const { getMainLoopModel } = await import('../utils/model/model.js')\n    const modelIdx = args.indexOf('--model')\n    const model = (modelIdx !== -1 && args[modelIdx + 1]) || getMainLoopModel()\n    const { getSystemPrompt } = await import('../constants/prompts.js')\n    const prompt = await getSystemPrompt([], model)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(prompt.join('\\n'))\n    return\n  }\n\n  if (process.argv[2] === '--claude-in-chrome-mcp') {\n    profileCheckpoint('cli_claude_in_chrome_mcp_path')\n    const { runClaudeInChromeMcpServer } = await import(\n      '../utils/claudeInChrome/mcpServer.js'\n    )\n    await runClaudeInChromeMcpServer()\n    return\n  } else if (process.argv[2] === '--chrome-native-host') {\n    profileCheckpoint('cli_chrome_native_host_path')\n    const { runChromeNativeHost } = await import(\n      '../utils/claudeInChrome/chromeNativeHost.js'\n    )\n    await runChromeNativeHost()\n    return\n  } else if (\n    feature('CHICAGO_MCP') &&\n    process.argv[2] === '--computer-use-mcp'\n  ) {\n    profileCheckpoint('cli_computer_use_mcp_path')\n    const { runComputerUseMcpServer } = await import(\n      '../utils/computerUse/mcpServer.js'\n    )\n    await runComputerUseMcpServer()\n    return\n  }\n\n  // Fast-path for `--daemon-worker=<kind>` (internal — supervisor spawns this).\n  // Must come before the daemon subcommand check: spawned per-worker, so\n  // perf-sensitive. No enableConfigs(), no analytics sinks at this layer —\n  // workers are lean. If a worker kind needs configs/auth (assistant will),\n  // it calls them inside its run() fn.\n  if (feature('DAEMON') && args[0] === '--daemon-worker') {\n    const { runDaemonWorker } = await import('../daemon/workerRegistry.js')\n    await runDaemonWorker(args[1])\n    return\n  }\n\n  // Fast-path for `claude remote-control` (also accepts legacy `claude remote` / `claude sync` / `claude bridge`):\n  // serve local machine as bridge environment.\n  // feature() must stay inline for build-time dead code elimination;\n  // isBridgeEnabled() checks the runtime GrowthBook gate.\n  if (\n    feature('BRIDGE_MODE') &&\n    (args[0] === 'remote-control' ||\n      args[0] === 'rc' ||\n      args[0] === 'remote' ||\n      args[0] === 'sync' ||\n      args[0] === 'bridge')\n  ) {\n    profileCheckpoint('cli_bridge_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n\n    const { getBridgeDisabledReason, checkBridgeMinVersion } = await import(\n      '../bridge/bridgeEnabled.js'\n    )\n    const { BRIDGE_LOGIN_ERROR } = await import('../bridge/types.js')\n    const { bridgeMain } = await import('../bridge/bridgeMain.js')\n    const { exitWithError } = await import('../utils/process.js')\n\n    // Auth check must come before the GrowthBook gate check — without auth,\n    // GrowthBook has no user context and would return a stale/default false.\n    // getBridgeDisabledReason awaits GB init, so the returned value is fresh\n    // (not the stale disk cache), but init still needs auth headers to work.\n    const { getClaudeAIOAuthTokens } = await import('../utils/auth.js')\n    if (!getClaudeAIOAuthTokens()?.accessToken) {\n      exitWithError(BRIDGE_LOGIN_ERROR)\n    }\n    const disabledReason = await getBridgeDisabledReason()\n    if (disabledReason) {\n      exitWithError(`Error: ${disabledReason}`)\n    }\n    const versionError = checkBridgeMinVersion()\n    if (versionError) {\n      exitWithError(versionError)\n    }\n\n    // Bridge is a remote control feature - check policy limits\n    const { waitForPolicyLimitsToLoad, isPolicyAllowed } = await import(\n      '../services/policyLimits/index.js'\n    )\n    await waitForPolicyLimitsToLoad()\n    if (!isPolicyAllowed('allow_remote_control')) {\n      exitWithError(\n        \"Error: Remote Control is disabled by your organization's policy.\",\n      )\n    }\n\n    await bridgeMain(args.slice(1))\n    return\n  }\n\n  // Fast-path for `claude daemon [subcommand]`: long-running supervisor.\n  if (feature('DAEMON') && args[0] === 'daemon') {\n    profileCheckpoint('cli_daemon_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n    const { initSinks } = await import('../utils/sinks.js')\n    initSinks()\n    const { daemonMain } = await import('../daemon/main.js')\n    await daemonMain(args.slice(1))\n    return\n  }\n\n  // Fast-path for `claude ps|logs|attach|kill` and `--bg`/`--background`.\n  // Session management against the ~/.claude/sessions/ registry. Flag\n  // literals are inlined so bg.js only loads when actually dispatching.\n  if (\n    feature('BG_SESSIONS') &&\n    (args[0] === 'ps' ||\n      args[0] === 'logs' ||\n      args[0] === 'attach' ||\n      args[0] === 'kill' ||\n      args.includes('--bg') ||\n      args.includes('--background'))\n  ) {\n    profileCheckpoint('cli_bg_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n    const bg = await import('../cli/bg.js')\n    switch (args[0]) {\n      case 'ps':\n        await bg.psHandler(args.slice(1))\n        break\n      case 'logs':\n        await bg.logsHandler(args[1])\n        break\n      case 'attach':\n        await bg.attachHandler(args[1])\n        break\n      case 'kill':\n        await bg.killHandler(args[1])\n        break\n      default:\n        await bg.handleBgFlag(args)\n    }\n    return\n  }\n\n  // Fast-path for template job commands.\n  if (\n    feature('TEMPLATES') &&\n    (args[0] === 'new' || args[0] === 'list' || args[0] === 'reply')\n  ) {\n    profileCheckpoint('cli_templates_path')\n    const { templatesMain } = await import('../cli/handlers/templateJobs.js')\n    await templatesMain(args)\n    // process.exit (not return) — mountFleetView's Ink TUI can leave event\n    // loop handles that prevent natural exit.\n    // eslint-disable-next-line custom-rules/no-process-exit\n    process.exit(0)\n  }\n\n  // Fast-path for `claude environment-runner`: headless BYOC runner.\n  // feature() must stay inline for build-time dead code elimination.\n  if (feature('BYOC_ENVIRONMENT_RUNNER') && args[0] === 'environment-runner') {\n    profileCheckpoint('cli_environment_runner_path')\n    const { environmentRunnerMain } = await import(\n      '../environment-runner/main.js'\n    )\n    await environmentRunnerMain(args.slice(1))\n    return\n  }\n\n  // Fast-path for `claude self-hosted-runner`: headless self-hosted-runner\n  // targeting the SelfHostedRunnerWorkerService API (register + poll; poll IS\n  // heartbeat). feature() must stay inline for build-time dead code elimination.\n  if (feature('SELF_HOSTED_RUNNER') && args[0] === 'self-hosted-runner') {\n    profileCheckpoint('cli_self_hosted_runner_path')\n    const { selfHostedRunnerMain } = await import(\n      '../self-hosted-runner/main.js'\n    )\n    await selfHostedRunnerMain(args.slice(1))\n    return\n  }\n\n  // Fast-path for --worktree --tmux: exec into tmux before loading full CLI\n  const hasTmuxFlag = args.includes('--tmux') || args.includes('--tmux=classic')\n  if (\n    hasTmuxFlag &&\n    (args.includes('-w') ||\n      args.includes('--worktree') ||\n      args.some(a => a.startsWith('--worktree=')))\n  ) {\n    profileCheckpoint('cli_tmux_worktree_fast_path')\n    const { enableConfigs } = await import('../utils/config.js')\n    enableConfigs()\n    const { isWorktreeModeEnabled } = await import(\n      '../utils/worktreeModeEnabled.js'\n    )\n    if (isWorktreeModeEnabled()) {\n      const { execIntoTmuxWorktree } = await import('../utils/worktree.js')\n      const result = await execIntoTmuxWorktree(args)\n      if (result.handled) {\n        return\n      }\n      // If not handled (e.g., error), fall through to normal CLI\n      if (result.error) {\n        const { exitWithError } = await import('../utils/process.js')\n        exitWithError(result.error)\n      }\n    }\n  }\n\n  // Redirect common update flag mistakes to the update subcommand\n  if (\n    args.length === 1 &&\n    (args[0] === '--update' || args[0] === '--upgrade')\n  ) {\n    process.argv = [process.argv[0]!, process.argv[1]!, 'update']\n  }\n\n  // --bare: set SIMPLE early so gates fire during module eval / commander\n  // option building (not just inside the action handler).\n  if (args.includes('--bare')) {\n    process.env.CLAUDE_CODE_SIMPLE = '1'\n  }\n\n  // No special flags detected, load and run the full CLI\n  const { startCapturingEarlyInput } = await import('../utils/earlyInput.js')\n  startCapturingEarlyInput()\n  profileCheckpoint('cli_before_main_import')\n  const { main: cliMain } = await import('../main.js')\n  profileCheckpoint('cli_after_main_import')\n  await cliMain()\n  profileCheckpoint('cli_after_main_complete')\n}\n\n// eslint-disable-next-line custom-rules/no-top-level-side-effects\nvoid main()\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/entrypoints/init.ts b/src/entrypoints/init.ts new file mode 100644 index 0000000000000000000000000000000000000000..5e926cf031a262be4211b1b665387cdfff4f40f7 --- /dev/null +++ b/src/entrypoints/init.ts @@ -0,0 +1,348 @@ +import { profileCheckpoint } from '../utils/startupProfiler.js' +import '../bootstrap/state.js' +import '../utils/config.js' +import type { Attributes, MetricOptions } from '@opentelemetry/api' +import memoize from 'lodash-es/memoize.js' +import { getIsNonInteractiveSession } from 'src/bootstrap/state.js' +import type { AttributedCounter } from '../bootstrap/state.js' +import { getSessionCounter, setMeter } from '../bootstrap/state.js' +import { shutdownLspServerManager } from '../services/lsp/manager.js' +import { populateOAuthAccountInfoIfNeeded } from '../services/oauth/client.js' +import { + initializePolicyLimitsLoadingPromise, + isPolicyLimitsEligible, +} from '../services/policyLimits/index.js' +import { + initializeRemoteManagedSettingsLoadingPromise, + isEligibleForRemoteManagedSettings, + waitForRemoteManagedSettingsToLoad, +} from '../services/remoteManagedSettings/index.js' +import { preconnectAnthropicApi } from '../utils/apiPreconnect.js' +import { applyExtraCACertsFromConfig } from '../utils/caCertsConfig.js' +import { registerCleanup } from '../utils/cleanupRegistry.js' +import { enableConfigs, recordFirstStartTime } from '../utils/config.js' +import { logForDebugging } from '../utils/debug.js' +import { detectCurrentRepository } from '../utils/detectRepository.js' +import { logForDiagnosticsNoPII } from '../utils/diagLogs.js' +import { initJetBrainsDetection } from '../utils/envDynamic.js' +import { isEnvTruthy } from '../utils/envUtils.js' +import { ConfigParseError, errorMessage } from '../utils/errors.js' +// showInvalidConfigDialog is dynamically imported in the error path to avoid loading React at init +import { + gracefulShutdownSync, + setupGracefulShutdown, +} from '../utils/gracefulShutdown.js' +import { + applyConfigEnvironmentVariables, + applySafeConfigEnvironmentVariables, +} from '../utils/managedEnv.js' +import { configureGlobalMTLS } from '../utils/mtls.js' +import { + ensureScratchpadDir, + isScratchpadEnabled, +} from '../utils/permissions/filesystem.js' +// initializeTelemetry is loaded lazily via import() in setMeterState() to defer +// ~400KB of OpenTelemetry + protobuf modules until telemetry is actually initialized. +// gRPC exporters (~700KB via @grpc/grpc-js) are further lazy-loaded within instrumentation.ts. +import { configureGlobalAgents } from '../utils/proxy.js' +import { isBetaTracingEnabled } from '../utils/telemetry/betaSessionTracing.js' +import { getTelemetryAttributes } from '../utils/telemetryAttributes.js' +import { setShellIfWindows } from '../utils/windowsPaths.js' + +// initialize1PEventLogging is dynamically imported to defer OpenTelemetry sdk-logs/resources + +// Track if telemetry has been initialized to prevent double initialization +let telemetryInitialized = false + +export const init = memoize(async (): Promise => { + const initStartTime = Date.now() + logForDiagnosticsNoPII('info', 'init_started') + profileCheckpoint('init_function_start') + + // Validate configs are valid and enable configuration system + try { + const configsStart = Date.now() + enableConfigs() + logForDiagnosticsNoPII('info', 'init_configs_enabled', { + duration_ms: Date.now() - configsStart, + }) + profileCheckpoint('init_configs_enabled') + + // Apply only safe environment variables before trust dialog + // Full environment variables are applied after trust is established + const envVarsStart = Date.now() + applySafeConfigEnvironmentVariables() + + // Apply NODE_EXTRA_CA_CERTS from settings.json to process.env early, + // before any TLS connections. Bun caches the TLS cert store at boot + // via BoringSSL, so this must happen before the first TLS handshake. + applyExtraCACertsFromConfig() + + logForDiagnosticsNoPII('info', 'init_safe_env_vars_applied', { + duration_ms: Date.now() - envVarsStart, + }) + profileCheckpoint('init_safe_env_vars_applied') + + // Make sure things get flushed on exit + setupGracefulShutdown() + profileCheckpoint('init_after_graceful_shutdown') + + // Initialize 1P event logging (no security concerns, but deferred to avoid + // loading OpenTelemetry sdk-logs at startup). growthbook.js is already in + // the module cache by this point (firstPartyEventLogger imports it), so the + // second dynamic import adds no load cost. + void Promise.all([ + import('../services/analytics/firstPartyEventLogger.js'), + import('../services/analytics/growthbook.js'), + ]).then(([fp, gb]) => { + fp.initialize1PEventLogging() + // Rebuild the logger provider if tengu_1p_event_batch_config changes + // mid-session. Change detection (isEqual) is inside the handler so + // unchanged refreshes are no-ops. + gb.onGrowthBookRefresh(() => { + void fp.reinitialize1PEventLoggingIfConfigChanged() + }) + }) + profileCheckpoint('init_after_1p_event_logging') + + // Populate OAuth account info if it is not already cached in config. This is needed since the + // OAuth account info may not be populated when logging in through the VSCode extension. + void populateOAuthAccountInfoIfNeeded() + profileCheckpoint('init_after_oauth_populate') + + // Initialize JetBrains IDE detection asynchronously (populates cache for later sync access) + void initJetBrainsDetection() + profileCheckpoint('init_after_jetbrains_detection') + + // Detect GitHub repository asynchronously (populates cache for gitDiff PR linking) + void detectCurrentRepository() + + // Initialize the loading promise early so that other systems (like plugin hooks) + // can await remote settings loading. The promise includes a timeout to prevent + // deadlocks if loadRemoteManagedSettings() is never called (e.g., Agent SDK tests). + if (isEligibleForRemoteManagedSettings()) { + initializeRemoteManagedSettingsLoadingPromise() + } + if (isPolicyLimitsEligible()) { + initializePolicyLimitsLoadingPromise() + } + profileCheckpoint('init_after_remote_settings_check') + + // Record the first start time + recordFirstStartTime() + + // Configure global mTLS settings + const mtlsStart = Date.now() + logForDebugging('[init] configureGlobalMTLS starting') + configureGlobalMTLS() + logForDiagnosticsNoPII('info', 'init_mtls_configured', { + duration_ms: Date.now() - mtlsStart, + }) + logForDebugging('[init] configureGlobalMTLS complete') + + // Configure global HTTP agents (proxy and/or mTLS) + const proxyStart = Date.now() + logForDebugging('[init] configureGlobalAgents starting') + configureGlobalAgents() + logForDiagnosticsNoPII('info', 'init_proxy_configured', { + duration_ms: Date.now() - proxyStart, + }) + logForDebugging('[init] configureGlobalAgents complete') + profileCheckpoint('init_network_configured') + + // Preconnect to the Anthropic API — overlap TCP+TLS handshake + // (~100-200ms) with the ~100ms of action-handler work before the API + // request. After CA certs + proxy agents are configured so the warmed + // connection uses the right transport. Fire-and-forget; skipped for + // proxy/mTLS/unix/cloud-provider where the SDK's dispatcher wouldn't + // reuse the global pool. + preconnectAnthropicApi() + + // CCR upstreamproxy: start the local CONNECT relay so agent subprocesses + // can reach org-configured upstreams with credential injection. Gated on + // CLAUDE_CODE_REMOTE + GrowthBook; fail-open on any error. Lazy import so + // non-CCR startups don't pay the module load. The getUpstreamProxyEnv + // function is registered with subprocessEnv.ts so subprocess spawning can + // inject proxy vars without a static import of the upstreamproxy module. + if (isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) { + try { + const { initUpstreamProxy, getUpstreamProxyEnv } = await import( + '../upstreamproxy/upstreamproxy.js' + ) + const { registerUpstreamProxyEnvFn } = await import( + '../utils/subprocessEnv.js' + ) + registerUpstreamProxyEnvFn(getUpstreamProxyEnv) + await initUpstreamProxy() + } catch (err) { + logForDebugging( + `[init] upstreamproxy init failed: ${err instanceof Error ? err.message : String(err)}; continuing without proxy`, + { level: 'warn' }, + ) + } + } + + // Set up git-bash if relevant + setShellIfWindows() + + // Register LSP manager cleanup (initialization happens in main.tsx after --plugin-dir is processed) + registerCleanup(shutdownLspServerManager) + + // gh-32730: teams created by subagents (or main agent without + // explicit TeamDelete) were left on disk forever. Register cleanup + // for all teams created this session. Lazy import: swarm code is + // behind feature gate and most sessions never create teams. + registerCleanup(async () => { + const { cleanupSessionTeams } = await import( + '../utils/swarm/teamHelpers.js' + ) + await cleanupSessionTeams() + }) + + // Initialize scratchpad directory if enabled + if (isScratchpadEnabled()) { + const scratchpadStart = Date.now() + await ensureScratchpadDir() + logForDiagnosticsNoPII('info', 'init_scratchpad_created', { + duration_ms: Date.now() - scratchpadStart, + }) + } + + logForDiagnosticsNoPII('info', 'init_completed', { + duration_ms: Date.now() - initStartTime, + }) + profileCheckpoint('init_function_end') + } catch (error) { + if (error instanceof ConfigParseError) { + // Skip the interactive Ink dialog when we can't safely render it. + // The dialog breaks JSON consumers (e.g. desktop marketplace plugin + // manager running `plugin marketplace list --json` in a VM sandbox). + if (getIsNonInteractiveSession()) { + process.stderr.write( + `Configuration error in ${error.filePath}: ${error.message}\n`, + ) + gracefulShutdownSync(1) + return + } + + // Show the invalid config dialog with the error object and wait for it to complete + return import('../components/InvalidConfigDialog.js').then(m => + m.showInvalidConfigDialog({ error }), + ) + // Dialog itself handles process.exit, so we don't need additional cleanup here + } else { + // For non-config errors, rethrow them + throw error + } + } +}) + +/** + * Initialize telemetry after trust has been granted. + * For remote-settings-eligible users, waits for settings to load (non-blocking), + * then re-applies env vars (to include remote settings) before initializing telemetry. + * For non-eligible users, initializes telemetry immediately. + * This should only be called once, after the trust dialog has been accepted. + */ +export function initializeTelemetryAfterTrust(): void { + if ( + process.env.DISABLE_TELEMETRY || + process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC + ) { + logForDebugging('[3P telemetry] Telemetry disabled by environment') + return + } + + if (isEligibleForRemoteManagedSettings()) { + // For SDK/headless mode with beta tracing, initialize eagerly first + // to ensure the tracer is ready before the first query runs. + // The async path below will still run but doInitializeTelemetry() guards against double init. + if (getIsNonInteractiveSession() && isBetaTracingEnabled()) { + void doInitializeTelemetry().catch(error => { + logForDebugging( + `[3P telemetry] Eager telemetry init failed (beta tracing): ${errorMessage(error)}`, + { level: 'error' }, + ) + }) + } + logForDebugging( + '[3P telemetry] Waiting for remote managed settings before telemetry init', + ) + void waitForRemoteManagedSettingsToLoad() + .then(async () => { + logForDebugging( + '[3P telemetry] Remote managed settings loaded, initializing telemetry', + ) + // Re-apply env vars to pick up remote settings before initializing telemetry. + applyConfigEnvironmentVariables() + await doInitializeTelemetry() + }) + .catch(error => { + logForDebugging( + `[3P telemetry] Telemetry init failed (remote settings path): ${errorMessage(error)}`, + { level: 'error' }, + ) + }) + } else { + void doInitializeTelemetry().catch(error => { + logForDebugging( + `[3P telemetry] Telemetry init failed: ${errorMessage(error)}`, + { level: 'error' }, + ) + }) + } +} + +async function doInitializeTelemetry(): Promise { + if (telemetryInitialized) { + // Already initialized, nothing to do + return + } + + // Set flag before init to prevent double initialization + telemetryInitialized = true + try { + await setMeterState() + } catch (error) { + // Reset flag on failure so subsequent calls can retry + telemetryInitialized = false + throw error + } +} + +async function setMeterState(): Promise { + // Lazy-load instrumentation to defer ~400KB of OpenTelemetry + protobuf + const { initializeTelemetry } = await import( + '../utils/telemetry/instrumentation.js' + ) + // Initialize customer OTLP telemetry (metrics, logs, traces) + const meter = await initializeTelemetry() + if (meter) { + // Create factory function for attributed counters + const createAttributedCounter = ( + name: string, + options: MetricOptions, + ): AttributedCounter => { + const counter = meter?.createCounter(name, options) + + return { + add(value: number, additionalAttributes: Attributes = {}) { + // Always fetch fresh telemetry attributes to ensure they're up to date + const currentAttributes = getTelemetryAttributes() + const mergedAttributes = { + ...currentAttributes, + ...additionalAttributes, + } + counter?.add(value, mergedAttributes) + }, + } + } + + setMeter(meter, createAttributedCounter) + + // Increment session counter here because the startup telemetry path + // runs before this async initialization completes, so the counter + // would be null there. + getSessionCounter()?.add(1) + } +} diff --git a/src/entrypoints/mcp.ts b/src/entrypoints/mcp.ts new file mode 100644 index 0000000000000000000000000000000000000000..deaf9d6a582aad798e1a422bdcf3edd437112a7c --- /dev/null +++ b/src/entrypoints/mcp.ts @@ -0,0 +1,196 @@ +import { Server } from '@modelcontextprotocol/sdk/server/index.js' +import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js' +import { + CallToolRequestSchema, + type CallToolResult, + ListToolsRequestSchema, + type ListToolsResult, + type Tool, +} from '@modelcontextprotocol/sdk/types.js' +import { getDefaultAppState } from 'src/state/AppStateStore.js' +import review from '../commands/review.js' +import type { Command } from '../commands.js' +import { + findToolByName, + getEmptyToolPermissionContext, + type ToolUseContext, +} from '../Tool.js' +import { getTools } from '../tools.js' +import { createAbortController } from '../utils/abortController.js' +import { createFileStateCacheWithSizeLimit } from '../utils/fileStateCache.js' +import { logError } from '../utils/log.js' +import { createAssistantMessage } from '../utils/messages.js' +import { getMainLoopModel } from '../utils/model/model.js' +import { hasPermissionsToUseTool } from '../utils/permissions/permissions.js' +import { setCwd } from '../utils/Shell.js' +import { jsonStringify } from '../utils/slowOperations.js' +import { getErrorParts } from '../utils/toolErrors.js' +import { zodToJsonSchema } from '../utils/zodToJsonSchema.js' + +type ToolInput = Tool['inputSchema'] +type ToolOutput = Tool['outputSchema'] + +const MCP_COMMANDS: Command[] = [review] + +export async function startMCPServer( + cwd: string, + debug: boolean, + verbose: boolean, +): Promise { + // Use size-limited LRU cache for readFileState to prevent unbounded memory growth + // 100 files and 25MB limit should be sufficient for MCP server operations + const READ_FILE_STATE_CACHE_SIZE = 100 + const readFileStateCache = createFileStateCacheWithSizeLimit( + READ_FILE_STATE_CACHE_SIZE, + ) + setCwd(cwd) + const server = new Server( + { + name: 'claude/tengu', + version: MACRO.VERSION, + }, + { + capabilities: { + tools: {}, + }, + }, + ) + + server.setRequestHandler( + ListToolsRequestSchema, + async (): Promise => { + // TODO: Also re-expose any MCP tools + const toolPermissionContext = getEmptyToolPermissionContext() + const tools = getTools(toolPermissionContext) + return { + tools: await Promise.all( + tools.map(async tool => { + let outputSchema: ToolOutput | undefined + if (tool.outputSchema) { + const convertedSchema = zodToJsonSchema(tool.outputSchema) + // MCP SDK requires outputSchema to have type: "object" at root level + // Skip schemas with anyOf/oneOf at root (from z.union, z.discriminatedUnion, etc.) + // See: https://github.com/anthropics/claude-code/issues/8014 + if ( + typeof convertedSchema === 'object' && + convertedSchema !== null && + 'type' in convertedSchema && + convertedSchema.type === 'object' + ) { + outputSchema = convertedSchema as ToolOutput + } + } + return { + ...tool, + description: await tool.prompt({ + getToolPermissionContext: async () => toolPermissionContext, + tools, + agents: [], + }), + inputSchema: zodToJsonSchema(tool.inputSchema) as ToolInput, + outputSchema, + } + }), + ), + } + }, + ) + + server.setRequestHandler( + CallToolRequestSchema, + async ({ params: { name, arguments: args } }): Promise => { + const toolPermissionContext = getEmptyToolPermissionContext() + // TODO: Also re-expose any MCP tools + const tools = getTools(toolPermissionContext) + const tool = findToolByName(tools, name) + if (!tool) { + throw new Error(`Tool ${name} not found`) + } + + // Assume MCP servers do not read messages separately from the tool + // call arguments. + const toolUseContext: ToolUseContext = { + abortController: createAbortController(), + options: { + commands: MCP_COMMANDS, + tools, + mainLoopModel: getMainLoopModel(), + thinkingConfig: { type: 'disabled' }, + mcpClients: [], + mcpResources: {}, + isNonInteractiveSession: true, + debug, + verbose, + agentDefinitions: { activeAgents: [], allAgents: [] }, + }, + getAppState: () => getDefaultAppState(), + setAppState: () => {}, + messages: [], + readFileState: readFileStateCache, + setInProgressToolUseIDs: () => {}, + setResponseLength: () => {}, + updateFileHistoryState: () => {}, + updateAttributionState: () => {}, + } + + // TODO: validate input types with zod + try { + if (!tool.isEnabled()) { + throw new Error(`Tool ${name} is not enabled`) + } + const validationResult = await tool.validateInput?.( + (args as never) ?? {}, + toolUseContext, + ) + if (validationResult && !validationResult.result) { + throw new Error( + `Tool ${name} input is invalid: ${validationResult.message}`, + ) + } + const finalResult = await tool.call( + (args ?? {}) as never, + toolUseContext, + hasPermissionsToUseTool, + createAssistantMessage({ + content: [], + }), + ) + + return { + content: [ + { + type: 'text' as const, + text: + typeof finalResult === 'string' + ? finalResult + : jsonStringify(finalResult.data), + }, + ], + } + } catch (error) { + logError(error) + + const parts = + error instanceof Error ? getErrorParts(error) : [String(error)] + const errorText = parts.filter(Boolean).join('\n').trim() || 'Error' + + return { + isError: true, + content: [ + { + type: 'text', + text: errorText, + }, + ], + } + } + }, + ) + + async function runServer() { + const transport = new StdioServerTransport() + await server.connect(transport) + } + + return await runServer() +} diff --git a/src/hooks/renderPlaceholder.ts b/src/hooks/renderPlaceholder.ts new file mode 100644 index 0000000000000000000000000000000000000000..50913ff01a554cdd0e98835bb7524ee469f69ea0 --- /dev/null +++ b/src/hooks/renderPlaceholder.ts @@ -0,0 +1,51 @@ +import chalk from 'chalk' + +type PlaceholderRendererProps = { + placeholder?: string + value: string + showCursor?: boolean + focus?: boolean + terminalFocus: boolean + invert?: (text: string) => string + hidePlaceholderText?: boolean +} + +export function renderPlaceholder({ + placeholder, + value, + showCursor, + focus, + terminalFocus = true, + invert = chalk.inverse, + hidePlaceholderText = false, +}: PlaceholderRendererProps): { + renderedPlaceholder: string | undefined + showPlaceholder: boolean +} { + let renderedPlaceholder: string | undefined = undefined + + if (placeholder) { + if (hidePlaceholderText) { + // Voice recording: show only the cursor, no placeholder text + renderedPlaceholder = + showCursor && focus && terminalFocus ? invert(' ') : '' + } else { + renderedPlaceholder = chalk.dim(placeholder) + + // Show inverse cursor only when both input and terminal are focused + if (showCursor && focus && terminalFocus) { + renderedPlaceholder = + placeholder.length > 0 + ? invert(placeholder[0]!) + chalk.dim(placeholder.slice(1)) + : invert(' ') + } + } + } + + const showPlaceholder = value.length === 0 && Boolean(placeholder) + + return { + renderedPlaceholder, + showPlaceholder, + } +} diff --git a/src/hooks/useAfterFirstRender.ts b/src/hooks/useAfterFirstRender.ts new file mode 100644 index 0000000000000000000000000000000000000000..d5ec2249fd1fbb0bc01604c971eccc30c132b9da --- /dev/null +++ b/src/hooks/useAfterFirstRender.ts @@ -0,0 +1,17 @@ +import { useEffect } from 'react' +import { isEnvTruthy } from '../utils/envUtils.js' + +export function useAfterFirstRender(): void { + useEffect(() => { + if ( + process.env.USER_TYPE === 'ant' && + isEnvTruthy(process.env.CLAUDE_CODE_EXIT_AFTER_FIRST_RENDER) + ) { + process.stderr.write( + `\nStartup time: ${Math.round(process.uptime() * 1000)}ms\n`, + ) + // eslint-disable-next-line custom-rules/no-process-exit + process.exit(0) + } + }, []) +} diff --git a/src/hooks/useAssistantHistory.ts b/src/hooks/useAssistantHistory.ts new file mode 100644 index 0000000000000000000000000000000000000000..c5348d20e04d5c4bdfcd21fc2dc8abadb693f1f0 --- /dev/null +++ b/src/hooks/useAssistantHistory.ts @@ -0,0 +1,250 @@ +import { randomUUID } from 'crypto' +import { + type RefObject, + useCallback, + useEffect, + useLayoutEffect, + useRef, +} from 'react' +import { + createHistoryAuthCtx, + fetchLatestEvents, + fetchOlderEvents, + type HistoryAuthCtx, + type HistoryPage, +} from '../assistant/sessionHistory.js' +import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js' +import type { RemoteSessionConfig } from '../remote/RemoteSessionManager.js' +import { convertSDKMessage } from '../remote/sdkMessageAdapter.js' +import type { Message, SystemInformationalMessage } from '../types/message.js' +import { logForDebugging } from '../utils/debug.js' + +type Props = { + /** Gated on viewerOnly — non-viewer sessions have no remote history to page. */ + config: RemoteSessionConfig | undefined + setMessages: React.Dispatch> + scrollRef: RefObject + /** Called after prepend from the layout effect with message count + height + * delta. Lets useUnseenDivider shift dividerIndex + dividerYRef. */ + onPrepend?: (indexDelta: number, heightDelta: number) => void +} + +type Result = { + /** Trigger for ScrollKeybindingHandler's onScroll composition. */ + maybeLoadOlder: (handle: ScrollBoxHandle) => void +} + +/** Fire loadOlder when scrolled within this many rows of the top. */ +const PREFETCH_THRESHOLD_ROWS = 40 + +/** Max chained page loads to fill the viewport on mount. Bounds the loop if + * events convert to zero visible messages (everything filtered). */ +const MAX_FILL_PAGES = 10 + +const SENTINEL_LOADING = 'loading older messages…' +const SENTINEL_LOADING_FAILED = + 'failed to load older messages — scroll up to retry' +const SENTINEL_START = 'start of session' + +/** Convert a HistoryPage to REPL Message[] using the same opts as viewer mode. */ +function pageToMessages(page: HistoryPage): Message[] { + const out: Message[] = [] + for (const ev of page.events) { + const c = convertSDKMessage(ev, { + convertUserTextMessages: true, + convertToolResults: true, + }) + if (c.type === 'message') out.push(c.message) + } + return out +} + +/** + * Lazy-load `claude assistant` history on scroll-up. + * + * On mount: fetch newest page via anchor_to_latest, prepend to messages. + * On scroll-up near top: fetch next-older page via before_id, prepend with + * scroll anchoring (viewport stays put). + * + * No-op unless config.viewerOnly. REPL only calls this hook inside a + * feature('KAIROS') gate, so build-time elimination is handled there. + */ +export function useAssistantHistory({ + config, + setMessages, + scrollRef, + onPrepend, +}: Props): Result { + const enabled = config?.viewerOnly === true + + // Cursor state: ref-only (no re-render on cursor change). `null` = no + // older pages. `undefined` = initial page not fetched yet. + const cursorRef = useRef(undefined) + const ctxRef = useRef(null) + const inflightRef = useRef(false) + + // Scroll-anchor: snapshot height + prepended count before setMessages; + // compensate in useLayoutEffect after React commits. getFreshScrollHeight + // reads Yoga directly so the value is correct post-commit. + const anchorRef = useRef<{ beforeHeight: number; count: number } | null>(null) + + // Fill-viewport chaining: after the initial page commits, if content doesn't + // fill the viewport yet, load another page. Self-chains via the layout effect + // until filled or the budget runs out. Budget set once on initial load; user + // scroll-ups don't need it (maybeLoadOlder re-fires on next wheel event). + const fillBudgetRef = useRef(0) + + // Stable sentinel UUID — reused across swaps so virtual-scroll treats it + // as one item (text-only mutation, not remove+insert). + const sentinelUuidRef = useRef(randomUUID()) + + function mkSentinel(text: string): SystemInformationalMessage { + return { + type: 'system', + subtype: 'informational', + content: text, + isMeta: false, + timestamp: new Date().toISOString(), + uuid: sentinelUuidRef.current, + level: 'info', + } + } + + /** Prepend a page at the front, with scroll-anchor snapshot for non-initial. + * Replaces the sentinel (always at index 0 when present) in-place. */ + const prepend = useCallback( + (page: HistoryPage, isInitial: boolean) => { + const msgs = pageToMessages(page) + cursorRef.current = page.hasMore ? page.firstId : null + + if (!isInitial) { + const s = scrollRef.current + anchorRef.current = s + ? { beforeHeight: s.getFreshScrollHeight(), count: msgs.length } + : null + } + + const sentinel = page.hasMore ? null : mkSentinel(SENTINEL_START) + setMessages(prev => { + // Drop existing sentinel (index 0, known stable UUID — O(1)). + const base = + prev[0]?.uuid === sentinelUuidRef.current ? prev.slice(1) : prev + return sentinel ? [sentinel, ...msgs, ...base] : [...msgs, ...base] + }) + + logForDebugging( + `[useAssistantHistory] ${isInitial ? 'initial' : 'older'} page: ${msgs.length} msgs (raw ${page.events.length}), hasMore=${page.hasMore}`, + ) + }, + // eslint-disable-next-line react-hooks/exhaustive-deps -- scrollRef is a stable ref; mkSentinel reads refs only + [setMessages], + ) + + // Initial fetch on mount — best-effort. + useEffect(() => { + if (!enabled || !config) return + let cancelled = false + void (async () => { + const ctx = await createHistoryAuthCtx(config.sessionId).catch(() => null) + if (!ctx || cancelled) return + ctxRef.current = ctx + const page = await fetchLatestEvents(ctx) + if (cancelled || !page) return + fillBudgetRef.current = MAX_FILL_PAGES + prepend(page, true) + })() + return () => { + cancelled = true + } + // config identity is stable (created once in main.tsx, never recreated) + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [enabled]) + + const loadOlder = useCallback(async () => { + if (!enabled || inflightRef.current) return + const cursor = cursorRef.current + const ctx = ctxRef.current + if (!cursor || !ctx) return // null=exhausted, undefined=initial pending + inflightRef.current = true + // Swap sentinel to "loading…" — O(1) slice since sentinel is at index 0. + setMessages(prev => { + const base = + prev[0]?.uuid === sentinelUuidRef.current ? prev.slice(1) : prev + return [mkSentinel(SENTINEL_LOADING), ...base] + }) + try { + const page = await fetchOlderEvents(ctx, cursor) + if (!page) { + // Fetch failed — revert sentinel back to "start" placeholder so the user + // can retry on next scroll-up. Cursor is preserved (not nulled out). + setMessages(prev => { + const base = + prev[0]?.uuid === sentinelUuidRef.current ? prev.slice(1) : prev + return [mkSentinel(SENTINEL_LOADING_FAILED), ...base] + }) + return + } + prepend(page, false) + } finally { + inflightRef.current = false + } + // eslint-disable-next-line react-hooks/exhaustive-deps -- mkSentinel reads refs only + }, [enabled, prepend, setMessages]) + + // Scroll-anchor compensation — after React commits the prepended items, + // shift scrollTop by the height delta so the viewport stays put. Also + // fire onPrepend here (not in prepend()) so dividerIndex + baseline ref + // are shifted with the ACTUAL height delta, not an estimate. + // No deps: runs every render; cheap no-op when anchorRef is null. + useLayoutEffect(() => { + const anchor = anchorRef.current + if (anchor === null) return + anchorRef.current = null + const s = scrollRef.current + if (!s || s.isSticky()) return // sticky = pinned bottom; prepend is invisible + const delta = s.getFreshScrollHeight() - anchor.beforeHeight + if (delta > 0) s.scrollBy(delta) + onPrepend?.(anchor.count, delta) + }) + + // Fill-viewport chain: after paint, if content doesn't exceed the viewport, + // load another page. Runs as useEffect (not layout effect) so Ink has + // painted and scrollViewportHeight is populated. Self-chains via next + // render's effect; budget caps the chain. + // + // The ScrollBox content wrapper has flexGrow:1 flexShrink:0 — it's clamped + // to ≥ viewport. So `content < viewport` is never true; `<=` detects "no + // overflow yet" correctly. Stops once there's at least something to scroll. + useEffect(() => { + if ( + fillBudgetRef.current <= 0 || + !cursorRef.current || + inflightRef.current + ) { + return + } + const s = scrollRef.current + if (!s) return + const contentH = s.getFreshScrollHeight() + const viewH = s.getViewportHeight() + logForDebugging( + `[useAssistantHistory] fill-check: content=${contentH} viewport=${viewH} budget=${fillBudgetRef.current}`, + ) + if (contentH <= viewH) { + fillBudgetRef.current-- + void loadOlder() + } else { + fillBudgetRef.current = 0 + } + }) + + // Trigger wrapper for onScroll composition in REPL. + const maybeLoadOlder = useCallback( + (handle: ScrollBoxHandle) => { + if (handle.getScrollTop() < PREFETCH_THRESHOLD_ROWS) void loadOlder() + }, + [loadOlder], + ) + + return { maybeLoadOlder } +} diff --git a/src/hooks/useBackgroundTaskNavigation.ts b/src/hooks/useBackgroundTaskNavigation.ts new file mode 100644 index 0000000000000000000000000000000000000000..c1a9b14fd78cebf34f96b6e652f6229858b92278 --- /dev/null +++ b/src/hooks/useBackgroundTaskNavigation.ts @@ -0,0 +1,251 @@ +import { useEffect, useRef } from 'react' +import { KeyboardEvent } from '../ink/events/keyboard-event.js' +// eslint-disable-next-line custom-rules/prefer-use-keybindings -- backward-compat bridge until REPL wires handleKeyDown to +import { useInput } from '../ink.js' +import { + type AppState, + useAppState, + useSetAppState, +} from '../state/AppState.js' +import { + enterTeammateView, + exitTeammateView, +} from '../state/teammateViewHelpers.js' +import { + getRunningTeammatesSorted, + InProcessTeammateTask, +} from '../tasks/InProcessTeammateTask/InProcessTeammateTask.js' +import { + type InProcessTeammateTaskState, + isInProcessTeammateTask, +} from '../tasks/InProcessTeammateTask/types.js' +import { isBackgroundTask } from '../tasks/types.js' + +// Step teammate selection by delta, wrapping across leader(-1)..teammates(0..n-1)..hide(n). +// First step from a collapsed tree expands it and parks on leader. +function stepTeammateSelection( + delta: 1 | -1, + setAppState: (updater: (prev: AppState) => AppState) => void, +): void { + setAppState(prev => { + const currentCount = getRunningTeammatesSorted(prev.tasks).length + if (currentCount === 0) return prev + + if (prev.expandedView !== 'teammates') { + return { + ...prev, + expandedView: 'teammates' as const, + viewSelectionMode: 'selecting-agent', + selectedIPAgentIndex: -1, + } + } + + const maxIdx = currentCount // hide row + const cur = prev.selectedIPAgentIndex + const next = + delta === 1 + ? cur >= maxIdx + ? -1 + : cur + 1 + : cur <= -1 + ? maxIdx + : cur - 1 + return { + ...prev, + selectedIPAgentIndex: next, + viewSelectionMode: 'selecting-agent', + } + }) +} + +/** + * Custom hook that handles Shift+Up/Down keyboard navigation for background tasks. + * When teammates (swarm) are present, navigates between leader and teammates. + * When only non-teammate background tasks exist, opens the background tasks dialog. + * Also handles Enter to confirm selection, 'f' to view transcript, and 'k' to kill. + */ +export function useBackgroundTaskNavigation(options?: { + onOpenBackgroundTasks?: () => void +}): { handleKeyDown: (e: KeyboardEvent) => void } { + const tasks = useAppState(s => s.tasks) + const viewSelectionMode = useAppState(s => s.viewSelectionMode) + const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId) + const selectedIPAgentIndex = useAppState(s => s.selectedIPAgentIndex) + const setAppState = useSetAppState() + + // Filter to running teammates and sort alphabetically to match TeammateSpinnerTree display + const teammateTasks = getRunningTeammatesSorted(tasks) + const teammateCount = teammateTasks.length + + // Check for non-teammate background tasks (local_agent, local_bash, etc.) + const hasNonTeammateBackgroundTasks = Object.values(tasks).some( + t => isBackgroundTask(t) && t.type !== 'in_process_teammate', + ) + + // Track previous teammate count to detect when teammates are removed + const prevTeammateCountRef = useRef(teammateCount) + + // Clamp selection index if teammates are removed or reset when count becomes 0 + useEffect(() => { + const prevCount = prevTeammateCountRef.current + prevTeammateCountRef.current = teammateCount + + setAppState(prev => { + const currentTeammates = getRunningTeammatesSorted(prev.tasks) + const currentCount = currentTeammates.length + + // When teammates are removed (count goes from >0 to 0), reset selection + // Only reset if we previously had teammates (not on initial mount with 0) + // Don't clobber viewSelectionMode if actively viewing a teammate transcript — + // the user may be reviewing a completed teammate and needs escape to exit + if ( + currentCount === 0 && + prevCount > 0 && + prev.selectedIPAgentIndex !== -1 + ) { + if (prev.viewSelectionMode === 'viewing-agent') { + return { + ...prev, + selectedIPAgentIndex: -1, + } + } + return { + ...prev, + selectedIPAgentIndex: -1, + viewSelectionMode: 'none', + } + } + + // Clamp if index is out of bounds + // Max valid index is currentCount (the "hide" row) when spinner tree is shown + const maxIndex = + prev.expandedView === 'teammates' ? currentCount : currentCount - 1 + if (currentCount > 0 && prev.selectedIPAgentIndex > maxIndex) { + return { + ...prev, + selectedIPAgentIndex: maxIndex, + } + } + + return prev + }) + }, [teammateCount, setAppState]) + + // Get the selected teammate's task info + const getSelectedTeammate = (): { + taskId: string + task: InProcessTeammateTaskState + } | null => { + if (teammateCount === 0) return null + const selectedIndex = selectedIPAgentIndex + const task = teammateTasks[selectedIndex] + if (!task) return null + + return { taskId: task.id, task } + } + + const handleKeyDown = (e: KeyboardEvent): void => { + // Escape in viewing mode: + // - If teammate is running: abort current work only (stops current turn, teammate stays alive) + // - If teammate is not running (completed/killed/failed): exit the view back to leader + if (e.key === 'escape' && viewSelectionMode === 'viewing-agent') { + e.preventDefault() + const taskId = viewingAgentTaskId + if (taskId) { + const task = tasks[taskId] + if (isInProcessTeammateTask(task) && task.status === 'running') { + // Abort currentWorkAbortController (stops current turn) NOT abortController (kills teammate) + task.currentWorkAbortController?.abort() + return + } + } + // Teammate is not running or task doesn't exist — exit the view + exitTeammateView(setAppState) + return + } + + // Escape in selection mode: exit selection without aborting leader + if (e.key === 'escape' && viewSelectionMode === 'selecting-agent') { + e.preventDefault() + setAppState(prev => ({ + ...prev, + viewSelectionMode: 'none', + selectedIPAgentIndex: -1, + })) + return + } + + // Shift+Up/Down for teammate transcript switching (with wrapping) + // Index -1 represents the leader, 0+ are teammates + // When showSpinnerTree is true, index === teammateCount is the "hide" row + if (e.shift && (e.key === 'up' || e.key === 'down')) { + e.preventDefault() + if (teammateCount > 0) { + stepTeammateSelection(e.key === 'down' ? 1 : -1, setAppState) + } else if (hasNonTeammateBackgroundTasks) { + options?.onOpenBackgroundTasks?.() + } + return + } + + // 'f' to view selected teammate's transcript (only in selecting mode) + if ( + e.key === 'f' && + viewSelectionMode === 'selecting-agent' && + teammateCount > 0 + ) { + e.preventDefault() + const selected = getSelectedTeammate() + if (selected) { + enterTeammateView(selected.taskId, setAppState) + } + return + } + + // Enter to confirm selection (only when in selecting mode) + if (e.key === 'return' && viewSelectionMode === 'selecting-agent') { + e.preventDefault() + if (selectedIPAgentIndex === -1) { + exitTeammateView(setAppState) + } else if (selectedIPAgentIndex >= teammateCount) { + // "Hide" row selected - collapse the spinner tree + setAppState(prev => ({ + ...prev, + expandedView: 'none' as const, + viewSelectionMode: 'none', + selectedIPAgentIndex: -1, + })) + } else { + const selected = getSelectedTeammate() + if (selected) { + enterTeammateView(selected.taskId, setAppState) + } + } + return + } + + // k to kill selected teammate (only in selecting mode) + if ( + e.key === 'k' && + viewSelectionMode === 'selecting-agent' && + selectedIPAgentIndex >= 0 + ) { + e.preventDefault() + const selected = getSelectedTeammate() + if (selected && selected.task.status === 'running') { + void InProcessTeammateTask.kill(selected.taskId, setAppState) + } + return + } + } + + // Backward-compat bridge: REPL.tsx doesn't yet wire handleKeyDown to + // . Subscribe via useInput and adapt InputEvent → + // KeyboardEvent until the consumer is migrated (separate PR). + // TODO(onKeyDown-migration): remove once REPL passes handleKeyDown. + useInput((_input, _key, event) => { + handleKeyDown(new KeyboardEvent(event.keypress)) + }) + + return { handleKeyDown } +} diff --git a/src/hooks/useBlink.ts b/src/hooks/useBlink.ts new file mode 100644 index 0000000000000000000000000000000000000000..33cac69747ca503a105625d6083c648edd86d5df --- /dev/null +++ b/src/hooks/useBlink.ts @@ -0,0 +1,34 @@ +import { type DOMElement, useAnimationFrame, useTerminalFocus } from '../ink.js' + +const BLINK_INTERVAL_MS = 600 + +/** + * Hook for synchronized blinking animations that pause when offscreen. + * + * Returns a ref to attach to the animated element and the current blink state. + * All instances blink together because they derive state from the same + * animation clock. The clock only runs when at least one subscriber is visible. + * Pauses when the terminal is blurred. + * + * @param enabled - Whether blinking is active + * @returns [ref, isVisible] - Ref to attach to element, true when visible in blink cycle + * + * @example + * function BlinkingDot({ shouldAnimate }) { + * const [ref, isVisible] = useBlink(shouldAnimate) + * return {isVisible ? '●' : ' '} + * } + */ +export function useBlink( + enabled: boolean, + intervalMs: number = BLINK_INTERVAL_MS, +): [ref: (element: DOMElement | null) => void, isVisible: boolean] { + const focused = useTerminalFocus() + const [ref, time] = useAnimationFrame(enabled && focused ? intervalMs : null) + + if (!enabled || !focused) return [ref, true] + + // Derive blink state from time - all instances see the same time so they sync + const isVisible = Math.floor(time / intervalMs) % 2 === 0 + return [ref, isVisible] +} diff --git a/src/hooks/useCanUseTool.tsx b/src/hooks/useCanUseTool.tsx new file mode 100644 index 0000000000000000000000000000000000000000..1eb77d56acfe08262ecdfa0e1c5af2431d6d8a77 --- /dev/null +++ b/src/hooks/useCanUseTool.tsx @@ -0,0 +1,204 @@ +import { c as _c } from "react/compiler-runtime"; +import { feature } from 'bun:bundle'; +import { APIUserAbortError } from '@anthropic-ai/sdk'; +import * as React from 'react'; +import { useCallback } from 'react'; +import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js'; +import { sanitizeToolNameForAnalytics } from 'src/services/analytics/metadata.js'; +import type { ToolUseConfirm } from '../components/permissions/PermissionRequest.js'; +import { Text } from '../ink.js'; +import type { ToolPermissionContext, Tool as ToolType, ToolUseContext } from '../Tool.js'; +import { consumeSpeculativeClassifierCheck, peekSpeculativeClassifierCheck } from '../tools/BashTool/bashPermissions.js'; +import { BASH_TOOL_NAME } from '../tools/BashTool/toolName.js'; +import type { AssistantMessage } from '../types/message.js'; +import { recordAutoModeDenial } from '../utils/autoModeDenials.js'; +import { clearClassifierChecking, setClassifierApproval, setYoloClassifierApproval } from '../utils/classifierApprovals.js'; +import { logForDebugging } from '../utils/debug.js'; +import { AbortError } from '../utils/errors.js'; +import { logError } from '../utils/log.js'; +import type { PermissionDecision } from '../utils/permissions/PermissionResult.js'; +import { hasPermissionsToUseTool } from '../utils/permissions/permissions.js'; +import { jsonStringify } from '../utils/slowOperations.js'; +import { handleCoordinatorPermission } from './toolPermission/handlers/coordinatorHandler.js'; +import { handleInteractivePermission } from './toolPermission/handlers/interactiveHandler.js'; +import { handleSwarmWorkerPermission } from './toolPermission/handlers/swarmWorkerHandler.js'; +import { createPermissionContext, createPermissionQueueOps } from './toolPermission/PermissionContext.js'; +import { logPermissionDecision } from './toolPermission/permissionLogging.js'; +export type CanUseToolFn = Record> = (tool: ToolType, input: Input, toolUseContext: ToolUseContext, assistantMessage: AssistantMessage, toolUseID: string, forceDecision?: PermissionDecision) => Promise>; +function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) { + const $ = _c(3); + let t0; + if ($[0] !== setToolPermissionContext || $[1] !== setToolUseConfirmQueue) { + t0 = async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => new Promise(resolve => { + const ctx = createPermissionContext(tool, input, toolUseContext, assistantMessage, toolUseID, setToolPermissionContext, createPermissionQueueOps(setToolUseConfirmQueue)); + if (ctx.resolveIfAborted(resolve)) { + return; + } + const decisionPromise = forceDecision !== undefined ? Promise.resolve(forceDecision) : hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseID); + return decisionPromise.then(async result => { + if (result.behavior === "allow") { + if (ctx.resolveIfAborted(resolve)) { + return; + } + if (feature("TRANSCRIPT_CLASSIFIER") && result.decisionReason?.type === "classifier" && result.decisionReason.classifier === "auto-mode") { + setYoloClassifierApproval(toolUseID, result.decisionReason.reason); + } + ctx.logDecision({ + decision: "accept", + source: "config" + }); + resolve(ctx.buildAllow(result.updatedInput ?? input, { + decisionReason: result.decisionReason + })); + return; + } + const appState = toolUseContext.getAppState(); + const description = await tool.description(input as never, { + isNonInteractiveSession: toolUseContext.options.isNonInteractiveSession, + toolPermissionContext: appState.toolPermissionContext, + tools: toolUseContext.options.tools + }); + if (ctx.resolveIfAborted(resolve)) { + return; + } + switch (result.behavior) { + case "deny": + { + logPermissionDecision({ + tool, + input, + toolUseContext, + messageId: ctx.messageId, + toolUseID + }, { + decision: "reject", + source: "config" + }); + if (feature("TRANSCRIPT_CLASSIFIER") && result.decisionReason?.type === "classifier" && result.decisionReason.classifier === "auto-mode") { + recordAutoModeDenial({ + toolName: tool.name, + display: description, + reason: result.decisionReason.reason ?? "", + timestamp: Date.now() + }); + toolUseContext.addNotification?.({ + key: "auto-mode-denied", + priority: "immediate", + jsx: <>{tool.userFacingName(input).toLowerCase()} denied by auto mode · /permissions + }); + } + resolve(result); + return; + } + case "ask": + { + if (appState.toolPermissionContext.awaitAutomatedChecksBeforeDialog) { + const coordinatorDecision = await handleCoordinatorPermission({ + ctx, + ...(feature("BASH_CLASSIFIER") ? { + pendingClassifierCheck: result.pendingClassifierCheck + } : {}), + updatedInput: result.updatedInput, + suggestions: result.suggestions, + permissionMode: appState.toolPermissionContext.mode + }); + if (coordinatorDecision) { + resolve(coordinatorDecision); + return; + } + } + if (ctx.resolveIfAborted(resolve)) { + return; + } + const swarmDecision = await handleSwarmWorkerPermission({ + ctx, + description, + ...(feature("BASH_CLASSIFIER") ? { + pendingClassifierCheck: result.pendingClassifierCheck + } : {}), + updatedInput: result.updatedInput, + suggestions: result.suggestions + }); + if (swarmDecision) { + resolve(swarmDecision); + return; + } + if (feature("BASH_CLASSIFIER") && result.pendingClassifierCheck && tool.name === BASH_TOOL_NAME && !appState.toolPermissionContext.awaitAutomatedChecksBeforeDialog) { + const speculativePromise = peekSpeculativeClassifierCheck((input as { + command: string; + }).command); + if (speculativePromise) { + const raceResult = await Promise.race([speculativePromise.then(_temp), new Promise(_temp2)]); + if (ctx.resolveIfAborted(resolve)) { + return; + } + if (raceResult.type === "result" && raceResult.result.matches && raceResult.result.confidence === "high" && feature("BASH_CLASSIFIER")) { + consumeSpeculativeClassifierCheck((input as { + command: string; + }).command); + const matchedRule = raceResult.result.matchedDescription ?? undefined; + if (matchedRule) { + setClassifierApproval(toolUseID, matchedRule); + } + ctx.logDecision({ + decision: "accept", + source: { + type: "classifier" + } + }); + resolve(ctx.buildAllow(result.updatedInput ?? input as Record, { + decisionReason: { + type: "classifier" as const, + classifier: "bash_allow" as const, + reason: `Allowed by prompt rule: "${raceResult.result.matchedDescription}"` + } + })); + return; + } + } + } + handleInteractivePermission({ + ctx, + description, + result, + awaitAutomatedChecksBeforeDialog: appState.toolPermissionContext.awaitAutomatedChecksBeforeDialog, + bridgeCallbacks: feature("BRIDGE_MODE") ? appState.replBridgePermissionCallbacks : undefined, + channelCallbacks: feature("KAIROS") || feature("KAIROS_CHANNELS") ? appState.channelPermissionCallbacks : undefined + }, resolve); + return; + } + } + }).catch(error => { + if (error instanceof AbortError || error instanceof APIUserAbortError) { + logForDebugging(`Permission check threw ${error.constructor.name} for tool=${tool.name}: ${error.message}`); + ctx.logCancelled(); + resolve(ctx.cancelAndAbort(undefined, true)); + } else { + logError(error); + resolve(ctx.cancelAndAbort(undefined, true)); + } + }).finally(() => { + clearClassifierChecking(toolUseID); + }); + }); + $[0] = setToolPermissionContext; + $[1] = setToolUseConfirmQueue; + $[2] = t0; + } else { + t0 = $[2]; + } + return t0; +} +function _temp2(res) { + return setTimeout(res, 2000, { + type: "timeout" as const + }); +} +function _temp(r) { + return { + type: "result" as const, + result: r + }; +} +export default useCanUseTool; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","APIUserAbortError","React","useCallback","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","sanitizeToolNameForAnalytics","ToolUseConfirm","Text","ToolPermissionContext","Tool","ToolType","ToolUseContext","consumeSpeculativeClassifierCheck","peekSpeculativeClassifierCheck","BASH_TOOL_NAME","AssistantMessage","recordAutoModeDenial","clearClassifierChecking","setClassifierApproval","setYoloClassifierApproval","logForDebugging","AbortError","logError","PermissionDecision","hasPermissionsToUseTool","jsonStringify","handleCoordinatorPermission","handleInteractivePermission","handleSwarmWorkerPermission","createPermissionContext","createPermissionQueueOps","logPermissionDecision","CanUseToolFn","Record","tool","input","Input","toolUseContext","assistantMessage","toolUseID","forceDecision","Promise","useCanUseTool","setToolUseConfirmQueue","setToolPermissionContext","$","_c","t0","resolve","ctx","resolveIfAborted","decisionPromise","undefined","then","result","behavior","decisionReason","type","classifier","reason","logDecision","decision","source","buildAllow","updatedInput","appState","getAppState","description","isNonInteractiveSession","options","toolPermissionContext","tools","messageId","toolName","name","display","timestamp","Date","now","addNotification","key","priority","jsx","userFacingName","toLowerCase","awaitAutomatedChecksBeforeDialog","coordinatorDecision","pendingClassifierCheck","suggestions","permissionMode","mode","swarmDecision","speculativePromise","command","raceResult","race","_temp","_temp2","matches","confidence","matchedRule","matchedDescription","const","bridgeCallbacks","replBridgePermissionCallbacks","channelCallbacks","channelPermissionCallbacks","catch","error","constructor","message","logCancelled","cancelAndAbort","finally","res","setTimeout","r"],"sources":["useCanUseTool.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport { APIUserAbortError } from '@anthropic-ai/sdk'\nimport * as React from 'react'\nimport { useCallback } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { sanitizeToolNameForAnalytics } from 'src/services/analytics/metadata.js'\nimport type { ToolUseConfirm } from '../components/permissions/PermissionRequest.js'\nimport { Text } from '../ink.js'\nimport type {\n  ToolPermissionContext,\n  Tool as ToolType,\n  ToolUseContext,\n} from '../Tool.js'\nimport {\n  consumeSpeculativeClassifierCheck,\n  peekSpeculativeClassifierCheck,\n} from '../tools/BashTool/bashPermissions.js'\nimport { BASH_TOOL_NAME } from '../tools/BashTool/toolName.js'\nimport type { AssistantMessage } from '../types/message.js'\nimport { recordAutoModeDenial } from '../utils/autoModeDenials.js'\nimport {\n  clearClassifierChecking,\n  setClassifierApproval,\n  setYoloClassifierApproval,\n} from '../utils/classifierApprovals.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { AbortError } from '../utils/errors.js'\nimport { logError } from '../utils/log.js'\nimport type { PermissionDecision } from '../utils/permissions/PermissionResult.js'\nimport { hasPermissionsToUseTool } from '../utils/permissions/permissions.js'\nimport { jsonStringify } from '../utils/slowOperations.js'\nimport { handleCoordinatorPermission } from './toolPermission/handlers/coordinatorHandler.js'\nimport { handleInteractivePermission } from './toolPermission/handlers/interactiveHandler.js'\nimport { handleSwarmWorkerPermission } from './toolPermission/handlers/swarmWorkerHandler.js'\nimport {\n  createPermissionContext,\n  createPermissionQueueOps,\n} from './toolPermission/PermissionContext.js'\nimport { logPermissionDecision } from './toolPermission/permissionLogging.js'\n\nexport type CanUseToolFn<\n  Input extends Record<string, unknown> = Record<string, unknown>,\n> = (\n  tool: ToolType,\n  input: Input,\n  toolUseContext: ToolUseContext,\n  assistantMessage: AssistantMessage,\n  toolUseID: string,\n  forceDecision?: PermissionDecision<Input>,\n) => Promise<PermissionDecision<Input>>\n\nfunction useCanUseTool(\n  setToolUseConfirmQueue: React.Dispatch<\n    React.SetStateAction<ToolUseConfirm[]>\n  >,\n  setToolPermissionContext: (context: ToolPermissionContext) => void,\n): CanUseToolFn {\n  return useCallback<CanUseToolFn>(\n    async (\n      tool,\n      input,\n      toolUseContext,\n      assistantMessage,\n      toolUseID,\n      forceDecision,\n    ) => {\n      return new Promise(resolve => {\n        const ctx = createPermissionContext(\n          tool,\n          input,\n          toolUseContext,\n          assistantMessage,\n          toolUseID,\n          setToolPermissionContext,\n          createPermissionQueueOps(setToolUseConfirmQueue),\n        )\n\n        if (ctx.resolveIfAborted(resolve)) return\n\n        const decisionPromise =\n          forceDecision !== undefined\n            ? Promise.resolve(forceDecision)\n            : hasPermissionsToUseTool(\n                tool,\n                input,\n                toolUseContext,\n                assistantMessage,\n                toolUseID,\n              )\n\n        return decisionPromise\n          .then(async result => {\n            // [ANT-ONLY] Log all tool permission decisions with tool name and args\n            if (\"external\" === 'ant') {\n              logEvent('tengu_internal_tool_permission_decision', {\n                toolName: sanitizeToolNameForAnalytics(tool.name),\n                behavior:\n                  result.behavior as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                // Note: input contains code/filepaths, only log for ants\n                input: jsonStringify(\n                  input,\n                ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                messageID:\n                  ctx.messageId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                isMcp: tool.isMcp ?? false,\n              })\n            }\n\n            // Has permissions to use tool, granted in config\n            if (result.behavior === 'allow') {\n              if (ctx.resolveIfAborted(resolve)) return\n              // Track auto mode classifier approvals for UI display\n              if (\n                feature('TRANSCRIPT_CLASSIFIER') &&\n                result.decisionReason?.type === 'classifier' &&\n                result.decisionReason.classifier === 'auto-mode'\n              ) {\n                setYoloClassifierApproval(\n                  toolUseID,\n                  result.decisionReason.reason,\n                )\n              }\n\n              ctx.logDecision({ decision: 'accept', source: 'config' })\n\n              resolve(\n                ctx.buildAllow(result.updatedInput ?? input, {\n                  decisionReason: result.decisionReason,\n                }),\n              )\n              return\n            }\n\n            const appState = toolUseContext.getAppState()\n            const description = await tool.description(input as never, {\n              isNonInteractiveSession:\n                toolUseContext.options.isNonInteractiveSession,\n              toolPermissionContext: appState.toolPermissionContext,\n              tools: toolUseContext.options.tools,\n            })\n\n            if (ctx.resolveIfAborted(resolve)) return\n\n            // Does not have permissions to use tool, check the behavior\n            switch (result.behavior) {\n              case 'deny': {\n                logPermissionDecision(\n                  {\n                    tool,\n                    input,\n                    toolUseContext,\n                    messageId: ctx.messageId,\n                    toolUseID,\n                  },\n                  { decision: 'reject', source: 'config' },\n                )\n                if (\n                  feature('TRANSCRIPT_CLASSIFIER') &&\n                  result.decisionReason?.type === 'classifier' &&\n                  result.decisionReason.classifier === 'auto-mode'\n                ) {\n                  recordAutoModeDenial({\n                    toolName: tool.name,\n                    display: description,\n                    reason: result.decisionReason.reason ?? '',\n                    timestamp: Date.now(),\n                  })\n                  toolUseContext.addNotification?.({\n                    key: 'auto-mode-denied',\n                    priority: 'immediate',\n                    jsx: (\n                      <>\n                        <Text color=\"error\">\n                          {tool.userFacingName(input).toLowerCase()} denied by\n                          auto mode\n                        </Text>\n                        <Text dimColor> · /permissions</Text>\n                      </>\n                    ),\n                  })\n                }\n                resolve(result)\n                return\n              }\n\n              case 'ask': {\n                // For coordinator workers, await automated checks before showing dialog.\n                // Background workers should only interrupt the user when automated checks can't decide.\n                if (\n                  appState.toolPermissionContext\n                    .awaitAutomatedChecksBeforeDialog\n                ) {\n                  const coordinatorDecision = await handleCoordinatorPermission(\n                    {\n                      ctx,\n                      ...(feature('BASH_CLASSIFIER')\n                        ? {\n                            pendingClassifierCheck:\n                              result.pendingClassifierCheck,\n                          }\n                        : {}),\n                      updatedInput: result.updatedInput,\n                      suggestions: result.suggestions,\n                      permissionMode: appState.toolPermissionContext.mode,\n                    },\n                  )\n                  if (coordinatorDecision) {\n                    resolve(coordinatorDecision)\n                    return\n                  }\n                  // null means neither automated check resolved -- fall through to dialog below.\n                  // Hooks already ran, classifier already consumed.\n                }\n\n                // After awaiting automated checks, verify the request wasn't aborted\n                // while we were waiting. Without this check, a stale dialog could appear.\n                if (ctx.resolveIfAborted(resolve)) return\n\n                // For swarm workers, try classifier auto-approval then\n                // forward permission requests to the leader via mailbox.\n                const swarmDecision = await handleSwarmWorkerPermission({\n                  ctx,\n                  description,\n                  ...(feature('BASH_CLASSIFIER')\n                    ? {\n                        pendingClassifierCheck: result.pendingClassifierCheck,\n                      }\n                    : {}),\n                  updatedInput: result.updatedInput,\n                  suggestions: result.suggestions,\n                })\n                if (swarmDecision) {\n                  resolve(swarmDecision)\n                  return\n                }\n\n                // Grace period: wait up to 2s for speculative classifier\n                // to resolve before showing the dialog (main agent only)\n                if (\n                  feature('BASH_CLASSIFIER') &&\n                  result.pendingClassifierCheck &&\n                  tool.name === BASH_TOOL_NAME &&\n                  !appState.toolPermissionContext\n                    .awaitAutomatedChecksBeforeDialog\n                ) {\n                  const speculativePromise = peekSpeculativeClassifierCheck(\n                    (input as { command: string }).command,\n                  )\n                  if (speculativePromise) {\n                    const raceResult = await Promise.race([\n                      speculativePromise.then(r => ({\n                        type: 'result' as const,\n                        result: r,\n                      })),\n                      new Promise<{ type: 'timeout' }>(res =>\n                        // eslint-disable-next-line no-restricted-syntax -- resolves with a value, not void\n                        setTimeout(res, 2000, { type: 'timeout' as const }),\n                      ),\n                    ])\n\n                    if (ctx.resolveIfAborted(resolve)) return\n\n                    if (\n                      raceResult.type === 'result' &&\n                      raceResult.result.matches &&\n                      raceResult.result.confidence === 'high' &&\n                      feature('BASH_CLASSIFIER')\n                    ) {\n                      // Classifier approved within grace period — skip dialog\n                      void consumeSpeculativeClassifierCheck(\n                        (input as { command: string }).command,\n                      )\n\n                      const matchedRule =\n                        raceResult.result.matchedDescription ?? undefined\n                      if (matchedRule) {\n                        setClassifierApproval(toolUseID, matchedRule)\n                      }\n\n                      ctx.logDecision({\n                        decision: 'accept',\n                        source: { type: 'classifier' },\n                      })\n                      resolve(\n                        ctx.buildAllow(\n                          result.updatedInput ??\n                            (input as Record<string, unknown>),\n                          {\n                            decisionReason: {\n                              type: 'classifier' as const,\n                              classifier: 'bash_allow' as const,\n                              reason: `Allowed by prompt rule: \"${raceResult.result.matchedDescription}\"`,\n                            },\n                          },\n                        ),\n                      )\n                      return\n                    }\n                    // Timeout or no match — fall through to show dialog\n                  }\n                }\n\n                // Show dialog and start hooks/classifier in background\n                handleInteractivePermission(\n                  {\n                    ctx,\n                    description,\n                    result,\n                    awaitAutomatedChecksBeforeDialog:\n                      appState.toolPermissionContext\n                        .awaitAutomatedChecksBeforeDialog,\n                    bridgeCallbacks: feature('BRIDGE_MODE')\n                      ? appState.replBridgePermissionCallbacks\n                      : undefined,\n                    channelCallbacks:\n                      feature('KAIROS') || feature('KAIROS_CHANNELS')\n                        ? appState.channelPermissionCallbacks\n                        : undefined,\n                  },\n                  resolve,\n                )\n\n                return\n              }\n            }\n          })\n          .catch(error => {\n            if (\n              error instanceof AbortError ||\n              error instanceof APIUserAbortError\n            ) {\n              logForDebugging(\n                `Permission check threw ${error.constructor.name} for tool=${tool.name}: ${error.message}`,\n              )\n              ctx.logCancelled()\n              resolve(ctx.cancelAndAbort(undefined, true))\n            } else {\n              logError(error)\n              resolve(ctx.cancelAndAbort(undefined, true))\n            }\n          })\n          .finally(() => {\n            clearClassifierChecking(toolUseID)\n          })\n      })\n    },\n    [setToolUseConfirmQueue, setToolPermissionContext],\n  )\n}\n\nexport default useCanUseTool\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/hooks/useChromeExtensionNotification.tsx b/src/hooks/useChromeExtensionNotification.tsx new file mode 100644 index 0000000000000000000000000000000000000000..a7d4416a9dbec3e2762aab31fd676db321657249 --- /dev/null +++ b/src/hooks/useChromeExtensionNotification.tsx @@ -0,0 +1,50 @@ +import * as React from 'react'; +import { Text } from '../ink.js'; +import { isClaudeAISubscriber } from '../utils/auth.js'; +import { isChromeExtensionInstalled, shouldEnableClaudeInChrome } from '../utils/claudeInChrome/setup.js'; +import { isRunningOnHomespace } from '../utils/envUtils.js'; +import { useStartupNotification } from './notifs/useStartupNotification.js'; +function getChromeFlag(): boolean | undefined { + if (process.argv.includes('--chrome')) { + return true; + } + if (process.argv.includes('--no-chrome')) { + return false; + } + return undefined; +} +export function useChromeExtensionNotification() { + useStartupNotification(_temp); +} +async function _temp() { + const chromeFlag = getChromeFlag(); + if (!shouldEnableClaudeInChrome(chromeFlag)) { + return null; + } + if (true && !isClaudeAISubscriber()) { + return { + key: "chrome-requires-subscription", + jsx: Claude in Chrome requires a claude.ai subscription, + priority: "immediate", + timeoutMs: 5000 + }; + } + const installed = await isChromeExtensionInstalled(); + if (!installed && !isRunningOnHomespace()) { + return { + key: "chrome-extension-not-detected", + jsx: Chrome extension not detected · https://claude.ai/chrome to install, + priority: "immediate", + timeoutMs: 3000 + }; + } + if (chromeFlag === undefined) { + return { + key: "claude-in-chrome-default-enabled", + text: "Claude in Chrome enabled \xB7 /chrome", + priority: "low" + }; + } + return null; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/src/hooks/useClipboardImageHint.ts b/src/hooks/useClipboardImageHint.ts new file mode 100644 index 0000000000000000000000000000000000000000..48aa5286594ecb9173cd7aed25cbcae59f4180e6 --- /dev/null +++ b/src/hooks/useClipboardImageHint.ts @@ -0,0 +1,77 @@ +import { useEffect, useRef } from 'react' +import { useNotifications } from '../context/notifications.js' +import { getShortcutDisplay } from '../keybindings/shortcutFormat.js' +import { hasImageInClipboard } from '../utils/imagePaste.js' + +const NOTIFICATION_KEY = 'clipboard-image-hint' +// Small debounce to batch rapid focus changes +const FOCUS_CHECK_DEBOUNCE_MS = 1000 +// Don't show the hint more than once per this interval +const HINT_COOLDOWN_MS = 30000 + +/** + * Hook that shows a notification when the terminal regains focus + * and the clipboard contains an image. + * + * @param isFocused - Whether the terminal is currently focused + * @param enabled - Whether image paste is enabled (onImagePaste is defined) + */ +export function useClipboardImageHint( + isFocused: boolean, + enabled: boolean, +): void { + const { addNotification } = useNotifications() + const lastFocusedRef = useRef(isFocused) + const lastHintTimeRef = useRef(0) + const checkTimeoutRef = useRef(null) + + useEffect(() => { + // Only trigger on focus regain (was unfocused, now focused) + const wasFocused = lastFocusedRef.current + lastFocusedRef.current = isFocused + + if (!enabled || !isFocused || wasFocused) { + return + } + + // Clear any pending check + if (checkTimeoutRef.current) { + clearTimeout(checkTimeoutRef.current) + } + + // Small debounce to batch rapid focus changes + checkTimeoutRef.current = setTimeout( + async (checkTimeoutRef, lastHintTimeRef, addNotification) => { + checkTimeoutRef.current = null + + // Check cooldown to avoid spamming the user + const now = Date.now() + if (now - lastHintTimeRef.current < HINT_COOLDOWN_MS) { + return + } + + // Check if clipboard has an image (async osascript call) + if (await hasImageInClipboard()) { + lastHintTimeRef.current = now + addNotification({ + key: NOTIFICATION_KEY, + text: `Image in clipboard · ${getShortcutDisplay('chat:imagePaste', 'Chat', 'ctrl+v')} to paste`, + priority: 'immediate', + timeoutMs: 8000, + }) + } + }, + FOCUS_CHECK_DEBOUNCE_MS, + checkTimeoutRef, + lastHintTimeRef, + addNotification, + ) + + return () => { + if (checkTimeoutRef.current) { + clearTimeout(checkTimeoutRef.current) + checkTimeoutRef.current = null + } + } + }, [isFocused, enabled, addNotification]) +} diff --git a/src/hooks/useCommandKeybindings.tsx b/src/hooks/useCommandKeybindings.tsx new file mode 100644 index 0000000000000000000000000000000000000000..55810d623579a88e98e9ed80a3b9910b78ef2bf5 --- /dev/null +++ b/src/hooks/useCommandKeybindings.tsx @@ -0,0 +1,108 @@ +import { c as _c } from "react/compiler-runtime"; +/** + * Component that registers keybinding handlers for command bindings. + * + * Must be rendered inside KeybindingSetup to have access to the keybinding context. + * Reads "command:*" actions from the current keybinding configuration and registers + * handlers that invoke the corresponding slash command via onSubmit. + * + * Commands triggered via keybinding are treated as "immediate" - they execute right + * away and preserve the user's existing input text (the prompt is not cleared). + */ +import { useMemo } from 'react'; +import { useIsModalOverlayActive } from '../context/overlayContext.js'; +import { useOptionalKeybindingContext } from '../keybindings/KeybindingContext.js'; +import { useKeybindings } from '../keybindings/useKeybinding.js'; +import type { PromptInputHelpers } from '../utils/handlePromptSubmit.js'; +type Props = { + // onSubmit accepts additional parameters beyond what we pass here, + // so we use a rest parameter to allow any additional args + onSubmit: (input: string, helpers: PromptInputHelpers, ...rest: [speculationAccept?: undefined, options?: { + fromKeybinding?: boolean; + }]) => void; + /** Set to false to disable command keybindings (e.g., when a dialog is open) */ + isActive?: boolean; +}; +const NOOP_HELPERS: PromptInputHelpers = { + setCursorOffset: () => {}, + clearBuffer: () => {}, + resetHistory: () => {} +}; + +/** + * Registers keybinding handlers for all "command:*" actions found in the + * user's keybinding configuration. When triggered, each handler submits + * the corresponding slash command (e.g., "command:commit" submits "/commit"). + */ +export function CommandKeybindingHandlers(t0) { + const $ = _c(8); + const { + onSubmit, + isActive: t1 + } = t0; + const isActive = t1 === undefined ? true : t1; + const keybindingContext = useOptionalKeybindingContext(); + const isModalOverlayActive = useIsModalOverlayActive(); + let t2; + bb0: { + if (!keybindingContext) { + let t3; + if ($[0] === Symbol.for("react.memo_cache_sentinel")) { + t3 = new Set(); + $[0] = t3; + } else { + t3 = $[0]; + } + t2 = t3; + break bb0; + } + let actions; + if ($[1] !== keybindingContext.bindings) { + actions = new Set(); + for (const binding of keybindingContext.bindings) { + if (binding.action?.startsWith("command:")) { + actions.add(binding.action); + } + } + $[1] = keybindingContext.bindings; + $[2] = actions; + } else { + actions = $[2]; + } + t2 = actions; + } + const commandActions = t2; + let map; + if ($[3] !== commandActions || $[4] !== onSubmit) { + map = {}; + for (const action of commandActions) { + const commandName = action.slice(8); + map[action] = () => { + onSubmit(`/${commandName}`, NOOP_HELPERS, undefined, { + fromKeybinding: true + }); + }; + } + $[3] = commandActions; + $[4] = onSubmit; + $[5] = map; + } else { + map = $[5]; + } + const handlers = map; + const t3 = isActive && !isModalOverlayActive; + let t4; + if ($[6] !== t3) { + t4 = { + context: "Chat", + isActive: t3 + }; + $[6] = t3; + $[7] = t4; + } else { + t4 = $[7]; + } + useKeybindings(handlers, t4); + return null; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/src/hooks/useDiffData.ts b/src/hooks/useDiffData.ts new file mode 100644 index 0000000000000000000000000000000000000000..176bcf09b266a9083e10f4ace6a9623bbe4ae3b2 --- /dev/null +++ b/src/hooks/useDiffData.ts @@ -0,0 +1,110 @@ +import type { StructuredPatchHunk } from 'diff' +import { useEffect, useMemo, useState } from 'react' +import { + fetchGitDiff, + fetchGitDiffHunks, + type GitDiffResult, + type GitDiffStats, +} from '../utils/gitDiff.js' + +const MAX_LINES_PER_FILE = 400 + +export type DiffFile = { + path: string + linesAdded: number + linesRemoved: number + isBinary: boolean + isLargeFile: boolean + isTruncated: boolean + isNewFile?: boolean + isUntracked?: boolean +} + +export type DiffData = { + stats: GitDiffStats | null + files: DiffFile[] + hunks: Map + loading: boolean +} + +/** + * Hook to fetch current git diff data on demand. + * Fetches both stats and hunks when component mounts. + */ +export function useDiffData(): DiffData { + const [diffResult, setDiffResult] = useState(null) + const [hunks, setHunks] = useState>( + new Map(), + ) + const [loading, setLoading] = useState(true) + + // Fetch diff data on mount + useEffect(() => { + let cancelled = false + + async function loadDiffData() { + try { + // Fetch both stats and hunks + const [statsResult, hunksResult] = await Promise.all([ + fetchGitDiff(), + fetchGitDiffHunks(), + ]) + + if (!cancelled) { + setDiffResult(statsResult) + setHunks(hunksResult) + setLoading(false) + } + } catch (_error) { + if (!cancelled) { + setDiffResult(null) + setHunks(new Map()) + setLoading(false) + } + } + } + + void loadDiffData() + + return () => { + cancelled = true + } + }, []) + + return useMemo(() => { + if (!diffResult) { + return { stats: null, files: [], hunks: new Map(), loading } + } + + const { stats, perFileStats } = diffResult + const files: DiffFile[] = [] + + // Iterate over perFileStats to get all files including large/skipped ones + for (const [path, fileStats] of perFileStats) { + const fileHunks = hunks.get(path) + const isUntracked = fileStats.isUntracked ?? false + + // Detect large file (in perFileStats but not in hunks, and not binary/untracked) + const isLargeFile = !fileStats.isBinary && !isUntracked && !fileHunks + + // Detect truncated file (total > limit means we truncated) + const totalLines = fileStats.added + fileStats.removed + const isTruncated = + !isLargeFile && !fileStats.isBinary && totalLines > MAX_LINES_PER_FILE + + files.push({ + path, + linesAdded: fileStats.added, + linesRemoved: fileStats.removed, + isBinary: fileStats.isBinary, + isLargeFile, + isTruncated, + isUntracked, + }) + } + + files.sort((a, b) => a.path.localeCompare(b.path)) + + return { stats, files, hunks, loading: false } + }, [diffResult, hunks, loading]) +} diff --git a/src/hooks/useDiffInIDE.ts b/src/hooks/useDiffInIDE.ts new file mode 100644 index 0000000000000000000000000000000000000000..8fb0d106fbae846c7be06b93991563157a67a06a --- /dev/null +++ b/src/hooks/useDiffInIDE.ts @@ -0,0 +1,379 @@ +import { randomUUID } from 'crypto' +import { basename } from 'path' +import { useEffect, useMemo, useRef, useState } from 'react' +import { logEvent } from 'src/services/analytics/index.js' +import { readFileSync } from 'src/utils/fileRead.js' +import { expandPath } from 'src/utils/path.js' +import type { PermissionOption } from '../components/permissions/FilePermissionDialog/permissionOptions.js' +import type { + MCPServerConnection, + McpSSEIDEServerConfig, + McpWebSocketIDEServerConfig, +} from '../services/mcp/types.js' +import type { ToolUseContext } from '../Tool.js' +import type { FileEdit } from '../tools/FileEditTool/types.js' +import { + getEditsForPatch, + getPatchForEdits, +} from '../tools/FileEditTool/utils.js' +import { getGlobalConfig } from '../utils/config.js' +import { getPatchFromContents } from '../utils/diff.js' +import { isENOENT } from '../utils/errors.js' +import { + callIdeRpc, + getConnectedIdeClient, + getConnectedIdeName, + hasAccessToIDEExtensionDiffFeature, +} from '../utils/ide.js' +import { WindowsToWSLConverter } from '../utils/idePathConversion.js' +import { logError } from '../utils/log.js' +import { getPlatform } from '../utils/platform.js' + +type Props = { + onChange( + option: PermissionOption, + input: { + file_path: string + edits: FileEdit[] + }, + ): void + toolUseContext: ToolUseContext + filePath: string + edits: FileEdit[] + editMode: 'single' | 'multiple' +} + +export function useDiffInIDE({ + onChange, + toolUseContext, + filePath, + edits, + editMode, +}: Props): { + closeTabInIDE: () => void + showingDiffInIDE: boolean + ideName: string + hasError: boolean +} { + const isUnmounted = useRef(false) + const [hasError, setHasError] = useState(false) + + const sha = useMemo(() => randomUUID().slice(0, 6), []) + const tabName = useMemo( + () => `✻ [Claude Code] ${basename(filePath)} (${sha}) ⧉`, + [filePath, sha], + ) + + const shouldShowDiffInIDE = + hasAccessToIDEExtensionDiffFeature(toolUseContext.options.mcpClients) && + getGlobalConfig().diffTool === 'auto' && + // Diffs should only be for file edits. + // File writes may come through here but are not supported for diffs. + !filePath.endsWith('.ipynb') + + const ideName = + getConnectedIdeName(toolUseContext.options.mcpClients) ?? 'IDE' + + async function showDiff(): Promise { + if (!shouldShowDiffInIDE) { + return + } + + try { + logEvent('tengu_ext_will_show_diff', {}) + + const { oldContent, newContent } = await showDiffInIDE( + filePath, + edits, + toolUseContext, + tabName, + ) + // Skip if component has been unmounted + if (isUnmounted.current) { + return + } + + logEvent('tengu_ext_diff_accepted', {}) + + const newEdits = computeEditsFromContents( + filePath, + oldContent, + newContent, + editMode, + ) + + if (newEdits.length === 0) { + // No changes -- edit was rejected (eg. reverted) + logEvent('tengu_ext_diff_rejected', {}) + // We close the tab here because 'no' no longer auto-closes + const ideClient = getConnectedIdeClient( + toolUseContext.options.mcpClients, + ) + if (ideClient) { + // Close the tab in the IDE + await closeTabInIDE(tabName, ideClient) + } + onChange( + { type: 'reject' }, + { + file_path: filePath, + edits: edits, + }, + ) + return + } + + // File was modified - edit was accepted + onChange( + { type: 'accept-once' }, + { + file_path: filePath, + edits: newEdits, + }, + ) + } catch (error) { + logError(error as Error) + setHasError(true) + } + } + + useEffect(() => { + void showDiff() + + // Set flag on unmount + return () => { + isUnmounted.current = true + } + // eslint-disable-next-line react-hooks/exhaustive-deps + }, []) + + return { + closeTabInIDE() { + const ideClient = getConnectedIdeClient(toolUseContext.options.mcpClients) + + if (!ideClient) { + return Promise.resolve() + } + + return closeTabInIDE(tabName, ideClient) + }, + showingDiffInIDE: shouldShowDiffInIDE && !hasError, + ideName: ideName, + hasError, + } +} + +/** + * Re-computes the edits from the old and new contents. This is necessary + * to apply any edits the user may have made to the new contents. + */ +export function computeEditsFromContents( + filePath: string, + oldContent: string, + newContent: string, + editMode: 'single' | 'multiple', +): FileEdit[] { + // Use unformatted patches, otherwise the edits will be formatted. + const singleHunk = editMode === 'single' + const patch = getPatchFromContents({ + filePath, + oldContent, + newContent, + singleHunk, + }) + + if (patch.length === 0) { + return [] + } + + // For single edit mode, verify we only got one hunk + if (singleHunk && patch.length > 1) { + logError( + new Error( + `Unexpected number of hunks: ${patch.length}. Expected 1 hunk.`, + ), + ) + } + + // Re-compute the edits to match the patch + return getEditsForPatch(patch) +} + +/** + * Done if: + * + * 1. Tab is closed in IDE + * 2. Tab is saved in IDE (we then close the tab) + * 3. User selected an option in IDE + * 4. User selected an option in terminal (or hit esc) + * + * Resolves with the new file content. + * + * TODO: Time out after 5 mins of inactivity? + * TODO: Update auto-approval UI when IDE exits + * TODO: Close the IDE tab when the approval prompt is unmounted + */ +async function showDiffInIDE( + file_path: string, + edits: FileEdit[], + toolUseContext: ToolUseContext, + tabName: string, +): Promise<{ oldContent: string; newContent: string }> { + let isCleanedUp = false + + const oldFilePath = expandPath(file_path) + let oldContent = '' + try { + oldContent = readFileSync(oldFilePath) + } catch (e: unknown) { + if (!isENOENT(e)) { + throw e + } + } + + async function cleanup() { + // Careful to avoid race conditions, since this + // function can be called from multiple places. + if (isCleanedUp) { + return + } + isCleanedUp = true + + // Don't fail if this fails + try { + await closeTabInIDE(tabName, ideClient) + } catch (e) { + logError(e as Error) + } + + process.off('beforeExit', cleanup) + toolUseContext.abortController.signal.removeEventListener('abort', cleanup) + } + + // Cleanup if the user hits esc to cancel the tool call - or on exit + toolUseContext.abortController.signal.addEventListener('abort', cleanup) + process.on('beforeExit', cleanup) + + // Open the diff in the IDE + const ideClient = getConnectedIdeClient(toolUseContext.options.mcpClients) + try { + const { updatedFile } = getPatchForEdits({ + filePath: oldFilePath, + fileContents: oldContent, + edits, + }) + + if (!ideClient || ideClient.type !== 'connected') { + throw new Error('IDE client not available') + } + let ideOldPath = oldFilePath + + // Only convert paths if we're in WSL and IDE is on Windows + const ideRunningInWindows = + (ideClient.config as McpSSEIDEServerConfig | McpWebSocketIDEServerConfig) + .ideRunningInWindows === true + if ( + getPlatform() === 'wsl' && + ideRunningInWindows && + process.env.WSL_DISTRO_NAME + ) { + const converter = new WindowsToWSLConverter(process.env.WSL_DISTRO_NAME) + ideOldPath = converter.toIDEPath(oldFilePath) + } + + const rpcResult = await callIdeRpc( + 'openDiff', + { + old_file_path: ideOldPath, + new_file_path: ideOldPath, + new_file_contents: updatedFile, + tab_name: tabName, + }, + ideClient, + ) + + // Convert the raw RPC result to a ToolCallResponse format + const data = Array.isArray(rpcResult) ? rpcResult : [rpcResult] + + // If the user saved the file then take the new contents and resolve with that. + if (isSaveMessage(data)) { + void cleanup() + return { + oldContent: oldContent, + newContent: data[1].text, + } + } else if (isClosedMessage(data)) { + void cleanup() + return { + oldContent: oldContent, + newContent: updatedFile, + } + } else if (isRejectedMessage(data)) { + void cleanup() + return { + oldContent: oldContent, + newContent: oldContent, + } + } + + // Indicates that the tool call completed with none of the expected + // results. Did the user close the IDE? + throw new Error('Not accepted') + } catch (error) { + logError(error as Error) + void cleanup() + throw error + } +} + +async function closeTabInIDE( + tabName: string, + ideClient?: MCPServerConnection | undefined, +): Promise { + try { + if (!ideClient || ideClient.type !== 'connected') { + throw new Error('IDE client not available') + } + + // Use direct RPC to close the tab + await callIdeRpc('close_tab', { tab_name: tabName }, ideClient) + } catch (error) { + logError(error as Error) + // Don't throw - this is a cleanup operation + } +} + +function isClosedMessage(data: unknown): data is { text: 'TAB_CLOSED' } { + return ( + Array.isArray(data) && + typeof data[0] === 'object' && + data[0] !== null && + 'type' in data[0] && + data[0].type === 'text' && + 'text' in data[0] && + data[0].text === 'TAB_CLOSED' + ) +} + +function isRejectedMessage(data: unknown): data is { text: 'DIFF_REJECTED' } { + return ( + Array.isArray(data) && + typeof data[0] === 'object' && + data[0] !== null && + 'type' in data[0] && + data[0].type === 'text' && + 'text' in data[0] && + data[0].text === 'DIFF_REJECTED' + ) +} + +function isSaveMessage( + data: unknown, +): data is [{ text: 'FILE_SAVED' }, { text: string }] { + return ( + Array.isArray(data) && + data[0]?.type === 'text' && + data[0].text === 'FILE_SAVED' && + typeof data[1].text === 'string' + ) +} diff --git a/src/hooks/useHistorySearch.ts b/src/hooks/useHistorySearch.ts new file mode 100644 index 0000000000000000000000000000000000000000..b48c880b794ddc6ece8326a56085b599dcda1536 --- /dev/null +++ b/src/hooks/useHistorySearch.ts @@ -0,0 +1,303 @@ +import { feature } from 'bun:bundle' +import { useCallback, useEffect, useMemo, useRef, useState } from 'react' +import { + getModeFromInput, + getValueFromInput, +} from '../components/PromptInput/inputModes.js' +import { makeHistoryReader } from '../history.js' +import { KeyboardEvent } from '../ink/events/keyboard-event.js' +// eslint-disable-next-line custom-rules/prefer-use-keybindings -- backward-compat bridge until consumers wire handleKeyDown to +import { useInput } from '../ink.js' +import { useKeybinding, useKeybindings } from '../keybindings/useKeybinding.js' +import type { PromptInputMode } from '../types/textInputTypes.js' +import type { HistoryEntry } from '../utils/config.js' + +export function useHistorySearch( + onAcceptHistory: (entry: HistoryEntry) => void, + currentInput: string, + onInputChange: (input: string) => void, + onCursorChange: (cursorOffset: number) => void, + currentCursorOffset: number, + onModeChange: (mode: PromptInputMode) => void, + currentMode: PromptInputMode, + isSearching: boolean, + setIsSearching: (isSearching: boolean) => void, + setPastedContents: (pastedContents: HistoryEntry['pastedContents']) => void, + currentPastedContents: HistoryEntry['pastedContents'], +): { + historyQuery: string + setHistoryQuery: (query: string) => void + historyMatch: HistoryEntry | undefined + historyFailedMatch: boolean + handleKeyDown: (e: KeyboardEvent) => void +} { + const [historyQuery, setHistoryQuery] = useState('') + const [historyFailedMatch, setHistoryFailedMatch] = useState(false) + const [originalInput, setOriginalInput] = useState('') + const [originalCursorOffset, setOriginalCursorOffset] = useState(0) + const [originalMode, setOriginalMode] = useState('prompt') + const [originalPastedContents, setOriginalPastedContents] = useState< + HistoryEntry['pastedContents'] + >({}) + const [historyMatch, setHistoryMatch] = useState( + undefined, + ) + const historyReader = useRef | undefined>( + undefined, + ) + const seenPrompts = useRef>(new Set()) + const searchAbortController = useRef(null) + + const closeHistoryReader = useCallback((): void => { + if (historyReader.current) { + // Must explicitly call .return() to trigger the finally block in readLinesReverse, + // which closes the file handle. Without this, file descriptors leak. + void historyReader.current.return(undefined) + historyReader.current = undefined + } + }, []) + + const reset = useCallback((): void => { + setIsSearching(false) + setHistoryQuery('') + setHistoryFailedMatch(false) + setOriginalInput('') + setOriginalCursorOffset(0) + setOriginalMode('prompt') + setOriginalPastedContents({}) + setHistoryMatch(undefined) + closeHistoryReader() + seenPrompts.current.clear() + }, [setIsSearching, closeHistoryReader]) + + const searchHistory = useCallback( + async (resume: boolean, signal?: AbortSignal): Promise => { + if (!isSearching) { + return + } + + if (historyQuery.length === 0) { + closeHistoryReader() + seenPrompts.current.clear() + setHistoryMatch(undefined) + setHistoryFailedMatch(false) + onInputChange(originalInput) + onCursorChange(originalCursorOffset) + onModeChange(originalMode) + setPastedContents(originalPastedContents) + return + } + + if (!resume) { + closeHistoryReader() + historyReader.current = makeHistoryReader() + seenPrompts.current.clear() + } + + if (!historyReader.current) { + return + } + + while (true) { + if (signal?.aborted) { + return + } + + const item = await historyReader.current.next() + if (item.done) { + // No match found - keep last match but mark as failed + setHistoryFailedMatch(true) + return + } + + const display = item.value.display + + const matchPosition = display.lastIndexOf(historyQuery) + if (matchPosition !== -1 && !seenPrompts.current.has(display)) { + seenPrompts.current.add(display) + setHistoryMatch(item.value) + setHistoryFailedMatch(false) + const mode = getModeFromInput(display) + onModeChange(mode) + onInputChange(display) + setPastedContents(item.value.pastedContents) + + // Position cursor relative to the clean value, not the display + const value = getValueFromInput(display) + const cleanMatchPosition = value.lastIndexOf(historyQuery) + onCursorChange( + cleanMatchPosition !== -1 ? cleanMatchPosition : matchPosition, + ) + return + } + } + }, + [ + isSearching, + historyQuery, + closeHistoryReader, + onInputChange, + onCursorChange, + onModeChange, + setPastedContents, + originalInput, + originalCursorOffset, + originalMode, + originalPastedContents, + ], + ) + + // Handler: Start history search (when not searching) + const handleStartSearch = useCallback(() => { + setIsSearching(true) + setOriginalInput(currentInput) + setOriginalCursorOffset(currentCursorOffset) + setOriginalMode(currentMode) + setOriginalPastedContents(currentPastedContents) + historyReader.current = makeHistoryReader() + seenPrompts.current.clear() + }, [ + setIsSearching, + currentInput, + currentCursorOffset, + currentMode, + currentPastedContents, + ]) + + // Handler: Find next match (when searching) + const handleNextMatch = useCallback(() => { + void searchHistory(true) + }, [searchHistory]) + + // Handler: Accept current match and exit search + const handleAccept = useCallback(() => { + if (historyMatch) { + const mode = getModeFromInput(historyMatch.display) + const value = getValueFromInput(historyMatch.display) + onInputChange(value) + onModeChange(mode) + setPastedContents(historyMatch.pastedContents) + } else { + // No match - restore original pasted contents + setPastedContents(originalPastedContents) + } + reset() + }, [ + historyMatch, + onInputChange, + onModeChange, + setPastedContents, + originalPastedContents, + reset, + ]) + + // Handler: Cancel search and restore original input + const handleCancel = useCallback(() => { + onInputChange(originalInput) + onCursorChange(originalCursorOffset) + setPastedContents(originalPastedContents) + reset() + }, [ + onInputChange, + onCursorChange, + setPastedContents, + originalInput, + originalCursorOffset, + originalPastedContents, + reset, + ]) + + // Handler: Execute (accept and submit) + const handleExecute = useCallback(() => { + if (historyQuery.length === 0) { + onAcceptHistory({ + display: originalInput, + pastedContents: originalPastedContents, + }) + } else if (historyMatch) { + const mode = getModeFromInput(historyMatch.display) + const value = getValueFromInput(historyMatch.display) + onModeChange(mode) + onAcceptHistory({ + display: value, + pastedContents: historyMatch.pastedContents, + }) + } + reset() + }, [ + historyQuery, + historyMatch, + onAcceptHistory, + onModeChange, + originalInput, + originalPastedContents, + reset, + ]) + + // Gated off under HISTORY_PICKER — the modal dialog owns ctrl+r there. + useKeybinding('history:search', handleStartSearch, { + context: 'Global', + isActive: feature('HISTORY_PICKER') ? false : !isSearching, + }) + + // History search context keybindings (only active when searching) + const historySearchHandlers = useMemo( + () => ({ + 'historySearch:next': handleNextMatch, + 'historySearch:accept': handleAccept, + 'historySearch:cancel': handleCancel, + 'historySearch:execute': handleExecute, + }), + [handleNextMatch, handleAccept, handleCancel, handleExecute], + ) + + useKeybindings(historySearchHandlers, { + context: 'HistorySearch', + isActive: isSearching, + }) + + // Handle backspace when query is empty (cancels search) + // This is a conditional behavior that doesn't fit the keybinding model + // well (backspace only cancels when query is empty) + const handleKeyDown = (e: KeyboardEvent): void => { + if (!isSearching) return + if (e.key === 'backspace' && historyQuery === '') { + e.preventDefault() + handleCancel() + } + } + + // Backward-compat bridge: PromptInput doesn't yet wire handleKeyDown to + // . Subscribe via useInput and adapt InputEvent → + // KeyboardEvent until the consumer is migrated (separate PR). + // TODO(onKeyDown-migration): remove once PromptInput passes handleKeyDown. + useInput( + (_input, _key, event) => { + handleKeyDown(new KeyboardEvent(event.keypress)) + }, + { isActive: isSearching }, + ) + + // Keep a ref to searchHistory to avoid it being a dependency of useEffect + const searchHistoryRef = useRef(searchHistory) + searchHistoryRef.current = searchHistory + + // Reset history search when query changes + useEffect(() => { + searchAbortController.current?.abort() + const controller = new AbortController() + searchAbortController.current = controller + void searchHistoryRef.current(false, controller.signal) + return () => { + controller.abort() + } + }, [historyQuery]) + + return { + historyQuery, + setHistoryQuery, + historyMatch, + historyFailedMatch, + handleKeyDown, + } +} diff --git a/src/hooks/useInboxPoller.ts b/src/hooks/useInboxPoller.ts new file mode 100644 index 0000000000000000000000000000000000000000..361ba636df4a83309e87bfa26476e2ed2432b306 --- /dev/null +++ b/src/hooks/useInboxPoller.ts @@ -0,0 +1,969 @@ +import { randomUUID } from 'crypto' +import { useCallback, useEffect, useRef } from 'react' +import { useInterval } from 'usehooks-ts' +import type { ToolUseConfirm } from '../components/permissions/PermissionRequest.js' +import { TEAMMATE_MESSAGE_TAG } from '../constants/xml.js' +import { useTerminalNotification } from '../ink/useTerminalNotification.js' +import { sendNotification } from '../services/notifier.js' +import { + type AppState, + useAppState, + useAppStateStore, + useSetAppState, +} from '../state/AppState.js' +import { findToolByName } from '../Tool.js' +import { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js' +import { getAllBaseTools } from '../tools.js' +import type { PermissionUpdate } from '../types/permissions.js' +import { logForDebugging } from '../utils/debug.js' +import { + findInProcessTeammateTaskId, + handlePlanApprovalResponse, +} from '../utils/inProcessTeammateHelpers.js' +import { createAssistantMessage } from '../utils/messages.js' +import { + permissionModeFromString, + toExternalPermissionMode, +} from '../utils/permissions/PermissionMode.js' +import { applyPermissionUpdate } from '../utils/permissions/PermissionUpdate.js' +import { jsonStringify } from '../utils/slowOperations.js' +import { isInsideTmux } from '../utils/swarm/backends/detection.js' +import { + ensureBackendsRegistered, + getBackendByType, +} from '../utils/swarm/backends/registry.js' +import type { PaneBackendType } from '../utils/swarm/backends/types.js' +import { TEAM_LEAD_NAME } from '../utils/swarm/constants.js' +import { getLeaderToolUseConfirmQueue } from '../utils/swarm/leaderPermissionBridge.js' +import { sendPermissionResponseViaMailbox } from '../utils/swarm/permissionSync.js' +import { + removeTeammateFromTeamFile, + setMemberMode, +} from '../utils/swarm/teamHelpers.js' +import { unassignTeammateTasks } from '../utils/tasks.js' +import { + getAgentName, + isPlanModeRequired, + isTeamLead, + isTeammate, +} from '../utils/teammate.js' +import { isInProcessTeammate } from '../utils/teammateContext.js' +import { + isModeSetRequest, + isPermissionRequest, + isPermissionResponse, + isPlanApprovalRequest, + isPlanApprovalResponse, + isSandboxPermissionRequest, + isSandboxPermissionResponse, + isShutdownApproved, + isShutdownRequest, + isTeamPermissionUpdate, + markMessagesAsRead, + readUnreadMessages, + type TeammateMessage, + writeToMailbox, +} from '../utils/teammateMailbox.js' +import { + hasPermissionCallback, + hasSandboxPermissionCallback, + processMailboxPermissionResponse, + processSandboxPermissionResponse, +} from './useSwarmPermissionPoller.js' + +/** + * Get the agent name to poll for messages. + * - In-process teammates return undefined (they use waitForNextPromptOrShutdown instead) + * - Process-based teammates use their CLAUDE_CODE_AGENT_NAME + * - Team leads use their name from teamContext.teammates + * - Standalone sessions return undefined + */ +function getAgentNameToPoll(appState: AppState): string | undefined { + // In-process teammates should NOT use useInboxPoller - they have their own + // polling mechanism via waitForNextPromptOrShutdown() in inProcessRunner.ts. + // Using useInboxPoller would cause message routing issues since in-process + // teammates share the same React context and AppState with the leader. + // + // Note: This can be called when the leader's REPL re-renders while an + // in-process teammate's AsyncLocalStorage context is active (due to shared + // setAppState). We return undefined to gracefully skip polling rather than + // throwing, since this is a normal occurrence during concurrent execution. + if (isInProcessTeammate()) { + return undefined + } + if (isTeammate()) { + return getAgentName() + } + // Team lead polls using their agent name (not ID) + if (isTeamLead(appState.teamContext)) { + const leadAgentId = appState.teamContext!.leadAgentId + // Look up the lead's name from teammates map + const leadName = appState.teamContext!.teammates[leadAgentId]?.name + return leadName || 'team-lead' + } + return undefined +} + +const INBOX_POLL_INTERVAL_MS = 1000 + +type Props = { + enabled: boolean + isLoading: boolean + focusedInputDialog: string | undefined + // Returns true if submission succeeded, false if rejected (e.g., query already running) + // Dead code elimination: parameter named onSubmitMessage to avoid "teammate" string in external builds + onSubmitMessage: (formatted: string) => boolean +} + +/** + * Polls the teammate inbox for new messages and submits them as turns. + * + * This hook: + * 1. Polls every 1s for unread messages (teammates or team leads) + * 2. When idle: submits messages immediately as a new turn + * 3. When busy: queues messages in AppState.inbox for UI display, delivers when turn ends + */ +export function useInboxPoller({ + enabled, + isLoading, + focusedInputDialog, + onSubmitMessage, +}: Props): void { + // Assign to original name for clarity within the function + const onSubmitTeammateMessage = onSubmitMessage + const store = useAppStateStore() + const setAppState = useSetAppState() + const inboxMessageCount = useAppState(s => s.inbox.messages.length) + const terminal = useTerminalNotification() + + const poll = useCallback(async () => { + if (!enabled) return + + // Use ref to avoid dependency on appState object (prevents infinite loop) + const currentAppState = store.getState() + const agentName = getAgentNameToPoll(currentAppState) + if (!agentName) return + + const unread = await readUnreadMessages( + agentName, + currentAppState.teamContext?.teamName, + ) + + if (unread.length === 0) return + + logForDebugging(`[InboxPoller] Found ${unread.length} unread message(s)`) + + // Check for plan approval responses and transition out of plan mode if approved + // Security: Only accept approval responses from the team lead + if (isTeammate() && isPlanModeRequired()) { + for (const msg of unread) { + const approvalResponse = isPlanApprovalResponse(msg.text) + // Verify the message is from the team lead to prevent teammates from forging approvals + if (approvalResponse && msg.from === 'team-lead') { + logForDebugging( + `[InboxPoller] Received plan approval response from team-lead: approved=${approvalResponse.approved}`, + ) + if (approvalResponse.approved) { + // Use leader's permission mode if provided, otherwise default + const targetMode = approvalResponse.permissionMode ?? 'default' + + // Transition out of plan mode + setAppState(prev => ({ + ...prev, + toolPermissionContext: applyPermissionUpdate( + prev.toolPermissionContext, + { + type: 'setMode', + mode: toExternalPermissionMode(targetMode), + destination: 'session', + }, + ), + })) + logForDebugging( + `[InboxPoller] Plan approved by team lead, exited plan mode to ${targetMode}`, + ) + } else { + logForDebugging( + `[InboxPoller] Plan rejected by team lead: ${approvalResponse.feedback || 'No feedback provided'}`, + ) + } + } else if (approvalResponse) { + logForDebugging( + `[InboxPoller] Ignoring plan approval response from non-team-lead: ${msg.from}`, + ) + } + } + } + + // Helper to mark messages as read in the inbox file. + // Called after messages are successfully delivered or reliably queued. + const markRead = () => { + void markMessagesAsRead(agentName, currentAppState.teamContext?.teamName) + } + + // Separate permission messages from regular teammate messages + const permissionRequests: TeammateMessage[] = [] + const permissionResponses: TeammateMessage[] = [] + const sandboxPermissionRequests: TeammateMessage[] = [] + const sandboxPermissionResponses: TeammateMessage[] = [] + const shutdownRequests: TeammateMessage[] = [] + const shutdownApprovals: TeammateMessage[] = [] + const teamPermissionUpdates: TeammateMessage[] = [] + const modeSetRequests: TeammateMessage[] = [] + const planApprovalRequests: TeammateMessage[] = [] + const regularMessages: TeammateMessage[] = [] + + for (const m of unread) { + const permReq = isPermissionRequest(m.text) + const permResp = isPermissionResponse(m.text) + const sandboxReq = isSandboxPermissionRequest(m.text) + const sandboxResp = isSandboxPermissionResponse(m.text) + const shutdownReq = isShutdownRequest(m.text) + const shutdownApproval = isShutdownApproved(m.text) + const teamPermUpdate = isTeamPermissionUpdate(m.text) + const modeSetReq = isModeSetRequest(m.text) + const planApprovalReq = isPlanApprovalRequest(m.text) + + if (permReq) { + permissionRequests.push(m) + } else if (permResp) { + permissionResponses.push(m) + } else if (sandboxReq) { + sandboxPermissionRequests.push(m) + } else if (sandboxResp) { + sandboxPermissionResponses.push(m) + } else if (shutdownReq) { + shutdownRequests.push(m) + } else if (shutdownApproval) { + shutdownApprovals.push(m) + } else if (teamPermUpdate) { + teamPermissionUpdates.push(m) + } else if (modeSetReq) { + modeSetRequests.push(m) + } else if (planApprovalReq) { + planApprovalRequests.push(m) + } else { + regularMessages.push(m) + } + } + + // Handle permission requests (leader side) - route to ToolUseConfirmQueue + if ( + permissionRequests.length > 0 && + isTeamLead(currentAppState.teamContext) + ) { + logForDebugging( + `[InboxPoller] Found ${permissionRequests.length} permission request(s)`, + ) + + const setToolUseConfirmQueue = getLeaderToolUseConfirmQueue() + const teamName = currentAppState.teamContext?.teamName + + for (const m of permissionRequests) { + const parsed = isPermissionRequest(m.text) + if (!parsed) continue + + if (setToolUseConfirmQueue) { + // Route through the standard ToolUseConfirmQueue so tmux workers + // get the same tool-specific UI (BashPermissionRequest, FileEditToolDiff, etc.) + // as in-process teammates. + const tool = findToolByName(getAllBaseTools(), parsed.tool_name) + if (!tool) { + logForDebugging( + `[InboxPoller] Unknown tool ${parsed.tool_name}, skipping permission request`, + ) + continue + } + + const entry: ToolUseConfirm = { + assistantMessage: createAssistantMessage({ content: '' }), + tool, + description: parsed.description, + input: parsed.input, + toolUseContext: {} as ToolUseConfirm['toolUseContext'], + toolUseID: parsed.tool_use_id, + permissionResult: { + behavior: 'ask', + message: parsed.description, + }, + permissionPromptStartTimeMs: Date.now(), + workerBadge: { + name: parsed.agent_id, + color: 'cyan', + }, + onUserInteraction() { + // No-op for tmux workers (no classifier auto-approval) + }, + onAbort() { + void sendPermissionResponseViaMailbox( + parsed.agent_id, + { decision: 'rejected', resolvedBy: 'leader' }, + parsed.request_id, + teamName, + ) + }, + onAllow( + updatedInput: Record, + permissionUpdates: PermissionUpdate[], + ) { + void sendPermissionResponseViaMailbox( + parsed.agent_id, + { + decision: 'approved', + resolvedBy: 'leader', + updatedInput, + permissionUpdates, + }, + parsed.request_id, + teamName, + ) + }, + onReject(feedback?: string) { + void sendPermissionResponseViaMailbox( + parsed.agent_id, + { + decision: 'rejected', + resolvedBy: 'leader', + feedback, + }, + parsed.request_id, + teamName, + ) + }, + async recheckPermission() { + // No-op for tmux workers — permission state is on the worker side + }, + } + + // Deduplicate: if markMessagesAsRead failed on a prior poll, + // the same message will be re-read — skip if already queued. + setToolUseConfirmQueue(queue => { + if (queue.some(q => q.toolUseID === parsed.tool_use_id)) { + return queue + } + return [...queue, entry] + }) + } else { + logForDebugging( + `[InboxPoller] ToolUseConfirmQueue unavailable, dropping permission request from ${parsed.agent_id}`, + ) + } + } + + // Send desktop notification for the first request + const firstParsed = isPermissionRequest(permissionRequests[0]?.text ?? '') + if (firstParsed && !isLoading && !focusedInputDialog) { + void sendNotification( + { + message: `${firstParsed.agent_id} needs permission for ${firstParsed.tool_name}`, + notificationType: 'worker_permission_prompt', + }, + terminal, + ) + } + } + + // Handle permission responses (worker side) - invoke registered callbacks + if (permissionResponses.length > 0 && isTeammate()) { + logForDebugging( + `[InboxPoller] Found ${permissionResponses.length} permission response(s)`, + ) + + for (const m of permissionResponses) { + const parsed = isPermissionResponse(m.text) + if (!parsed) continue + + if (hasPermissionCallback(parsed.request_id)) { + logForDebugging( + `[InboxPoller] Processing permission response for ${parsed.request_id}: ${parsed.subtype}`, + ) + + 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, + }) + } + } + } + } + + // Handle sandbox permission requests (leader side) - add to workerSandboxPermissions queue + if ( + sandboxPermissionRequests.length > 0 && + isTeamLead(currentAppState.teamContext) + ) { + logForDebugging( + `[InboxPoller] Found ${sandboxPermissionRequests.length} sandbox permission request(s)`, + ) + + const newSandboxRequests: Array<{ + requestId: string + workerId: string + workerName: string + workerColor?: string + host: string + createdAt: number + }> = [] + + for (const m of sandboxPermissionRequests) { + const parsed = isSandboxPermissionRequest(m.text) + if (!parsed) continue + + // Validate required nested fields to prevent crashes from malformed messages + if (!parsed.hostPattern?.host) { + logForDebugging( + `[InboxPoller] Invalid sandbox permission request: missing hostPattern.host`, + ) + continue + } + + newSandboxRequests.push({ + requestId: parsed.requestId, + workerId: parsed.workerId, + workerName: parsed.workerName, + workerColor: parsed.workerColor, + host: parsed.hostPattern.host, + createdAt: parsed.createdAt, + }) + } + + if (newSandboxRequests.length > 0) { + setAppState(prev => ({ + ...prev, + workerSandboxPermissions: { + ...prev.workerSandboxPermissions, + queue: [ + ...prev.workerSandboxPermissions.queue, + ...newSandboxRequests, + ], + }, + })) + + // Send desktop notification for the first new request + const firstRequest = newSandboxRequests[0] + if (firstRequest && !isLoading && !focusedInputDialog) { + void sendNotification( + { + message: `${firstRequest.workerName} needs network access to ${firstRequest.host}`, + notificationType: 'worker_permission_prompt', + }, + terminal, + ) + } + } + } + + // Handle sandbox permission responses (worker side) - invoke registered callbacks + if (sandboxPermissionResponses.length > 0 && isTeammate()) { + logForDebugging( + `[InboxPoller] Found ${sandboxPermissionResponses.length} sandbox permission response(s)`, + ) + + for (const m of sandboxPermissionResponses) { + const parsed = isSandboxPermissionResponse(m.text) + if (!parsed) continue + + // Check if we have a registered callback for this request + if (hasSandboxPermissionCallback(parsed.requestId)) { + logForDebugging( + `[InboxPoller] Processing sandbox permission response for ${parsed.requestId}: allow=${parsed.allow}`, + ) + + // Process the response using the exported function + processSandboxPermissionResponse({ + requestId: parsed.requestId, + host: parsed.host, + allow: parsed.allow, + }) + + // Clear the pending sandbox request indicator + setAppState(prev => ({ + ...prev, + pendingSandboxRequest: null, + })) + } + } + } + + // Handle team permission updates (teammate side) - apply permission to context + if (teamPermissionUpdates.length > 0 && isTeammate()) { + logForDebugging( + `[InboxPoller] Found ${teamPermissionUpdates.length} team permission update(s)`, + ) + + for (const m of teamPermissionUpdates) { + const parsed = isTeamPermissionUpdate(m.text) + if (!parsed) { + logForDebugging( + `[InboxPoller] Failed to parse team permission update: ${m.text.substring(0, 100)}`, + ) + continue + } + + // Validate required nested fields to prevent crashes from malformed messages + if ( + !parsed.permissionUpdate?.rules || + !parsed.permissionUpdate?.behavior + ) { + logForDebugging( + `[InboxPoller] Invalid team permission update: missing permissionUpdate.rules or permissionUpdate.behavior`, + ) + continue + } + + // Apply the permission update to the teammate's context + logForDebugging( + `[InboxPoller] Applying team permission update: ${parsed.toolName} allowed in ${parsed.directoryPath}`, + ) + logForDebugging( + `[InboxPoller] Permission update rules: ${jsonStringify(parsed.permissionUpdate.rules)}`, + ) + + setAppState(prev => { + const updated = applyPermissionUpdate(prev.toolPermissionContext, { + type: 'addRules', + rules: parsed.permissionUpdate.rules, + behavior: parsed.permissionUpdate.behavior, + destination: 'session', + }) + logForDebugging( + `[InboxPoller] Updated session allow rules: ${jsonStringify(updated.alwaysAllowRules.session)}`, + ) + return { + ...prev, + toolPermissionContext: updated, + } + }) + } + } + + // Handle mode set requests (teammate side) - team lead changing teammate's mode + if (modeSetRequests.length > 0 && isTeammate()) { + logForDebugging( + `[InboxPoller] Found ${modeSetRequests.length} mode set request(s)`, + ) + + for (const m of modeSetRequests) { + // Only accept mode changes from team-lead + if (m.from !== 'team-lead') { + logForDebugging( + `[InboxPoller] Ignoring mode set request from non-team-lead: ${m.from}`, + ) + continue + } + + const parsed = isModeSetRequest(m.text) + if (!parsed) { + logForDebugging( + `[InboxPoller] Failed to parse mode set request: ${m.text.substring(0, 100)}`, + ) + continue + } + + const targetMode = permissionModeFromString(parsed.mode) + logForDebugging( + `[InboxPoller] Applying mode change from team-lead: ${targetMode}`, + ) + + // Update local permission context + setAppState(prev => ({ + ...prev, + toolPermissionContext: applyPermissionUpdate( + prev.toolPermissionContext, + { + type: 'setMode', + mode: toExternalPermissionMode(targetMode), + destination: 'session', + }, + ), + })) + + // Update config.json so team lead can see the new mode + const teamName = currentAppState.teamContext?.teamName + const agentName = getAgentName() + if (teamName && agentName) { + setMemberMode(teamName, agentName, targetMode) + } + } + } + + // Handle plan approval requests (leader side) - auto-approve and write response to teammate inbox + if ( + planApprovalRequests.length > 0 && + isTeamLead(currentAppState.teamContext) + ) { + logForDebugging( + `[InboxPoller] Found ${planApprovalRequests.length} plan approval request(s), auto-approving`, + ) + + const teamName = currentAppState.teamContext?.teamName + const leaderExternalMode = toExternalPermissionMode( + currentAppState.toolPermissionContext.mode, + ) + const modeToInherit = + leaderExternalMode === 'plan' ? 'default' : leaderExternalMode + + for (const m of planApprovalRequests) { + const parsed = isPlanApprovalRequest(m.text) + if (!parsed) continue + + // Write approval response to teammate's inbox + const approvalResponse = { + type: 'plan_approval_response', + requestId: parsed.requestId, + approved: true, + timestamp: new Date().toISOString(), + permissionMode: modeToInherit, + } + + void writeToMailbox( + m.from, + { + from: TEAM_LEAD_NAME, + text: jsonStringify(approvalResponse), + timestamp: new Date().toISOString(), + }, + teamName, + ) + + // Update in-process teammate task state if applicable + const taskId = findInProcessTeammateTaskId(m.from, currentAppState) + if (taskId) { + handlePlanApprovalResponse( + taskId, + { + type: 'plan_approval_response', + requestId: parsed.requestId, + approved: true, + timestamp: new Date().toISOString(), + permissionMode: modeToInherit, + }, + setAppState, + ) + } + + logForDebugging( + `[InboxPoller] Auto-approved plan from ${m.from} (request ${parsed.requestId})`, + ) + + // Still pass through as a regular message so the model has context + // about what the teammate is doing, but the approval is already sent + regularMessages.push(m) + } + } + + // Handle shutdown requests (teammate side) - preserve JSON for UI rendering + if (shutdownRequests.length > 0 && isTeammate()) { + logForDebugging( + `[InboxPoller] Found ${shutdownRequests.length} shutdown request(s)`, + ) + + // Pass through shutdown requests - the UI component will render them nicely + // and the model will receive instructions via the tool prompt documentation + for (const m of shutdownRequests) { + regularMessages.push(m) + } + } + + // Handle shutdown approvals (leader side) - kill the teammate's pane + if ( + shutdownApprovals.length > 0 && + isTeamLead(currentAppState.teamContext) + ) { + logForDebugging( + `[InboxPoller] Found ${shutdownApprovals.length} shutdown approval(s)`, + ) + + for (const m of shutdownApprovals) { + const parsed = isShutdownApproved(m.text) + if (!parsed) continue + + // Kill the pane if we have the info (pane-based teammates) + if (parsed.paneId && parsed.backendType) { + void (async () => { + try { + // Ensure backend classes are imported (no subprocess probes) + await ensureBackendsRegistered() + const insideTmux = await isInsideTmux() + const backend = getBackendByType( + parsed.backendType as PaneBackendType, + ) + const success = await backend?.killPane( + parsed.paneId!, + !insideTmux, + ) + logForDebugging( + `[InboxPoller] Killed pane ${parsed.paneId} for ${parsed.from}: ${success}`, + ) + } catch (error) { + logForDebugging( + `[InboxPoller] Failed to kill pane for ${parsed.from}: ${error}`, + ) + } + })() + } + + // Remove the teammate from teamContext.teammates so the count is accurate + const teammateToRemove = parsed.from + if (teammateToRemove && currentAppState.teamContext?.teammates) { + // Find the teammate ID by name + const teammateId = Object.entries( + currentAppState.teamContext.teammates, + ).find(([, t]) => t.name === teammateToRemove)?.[0] + + if (teammateId) { + // Remove from team file (leader owns team file mutations) + const teamName = currentAppState.teamContext?.teamName + if (teamName) { + removeTeammateFromTeamFile(teamName, { + agentId: teammateId, + name: teammateToRemove, + }) + } + + // Unassign tasks and build notification message + const { notificationMessage } = teamName + ? await unassignTeammateTasks( + teamName, + teammateId, + teammateToRemove, + 'shutdown', + ) + : { notificationMessage: `${teammateToRemove} has shut down.` } + + setAppState(prev => { + if (!prev.teamContext?.teammates) return prev + if (!(teammateId in prev.teamContext.teammates)) return prev + const { [teammateId]: _, ...remainingTeammates } = + prev.teamContext.teammates + + // Mark the teammate's task as completed so hasRunningTeammates + // becomes false and the spinner stops. Without this, out-of-process + // (tmux) teammate tasks stay status:'running' forever because + // only in-process teammates have a runner that sets 'completed'. + const updatedTasks = { ...prev.tasks } + for (const [tid, task] of Object.entries(updatedTasks)) { + if ( + isInProcessTeammateTask(task) && + task.identity.agentId === teammateId + ) { + updatedTasks[tid] = { + ...task, + status: 'completed' as const, + endTime: Date.now(), + } + } + } + + return { + ...prev, + tasks: updatedTasks, + teamContext: { + ...prev.teamContext, + teammates: remainingTeammates, + }, + inbox: { + messages: [ + ...prev.inbox.messages, + { + id: randomUUID(), + from: 'system', + text: jsonStringify({ + type: 'teammate_terminated', + message: notificationMessage, + }), + timestamp: new Date().toISOString(), + status: 'pending' as const, + }, + ], + }, + } + }) + logForDebugging( + `[InboxPoller] Removed ${teammateToRemove} (${teammateId}) from teamContext`, + ) + } + } + + // Pass through for UI rendering - the component will render it nicely + regularMessages.push(m) + } + } + + // Process regular teammate messages (existing logic) + if (regularMessages.length === 0) { + // No regular messages, but we may have processed non-regular messages + // (permissions, shutdown requests, etc.) above — mark those as read. + markRead() + return + } + + // Format messages with XML wrapper for Claude (include color if available) + // Transform plan approval requests to include instructions for Claude + const formatted = regularMessages + .map(m => { + const colorAttr = m.color ? ` color="${m.color}"` : '' + const summaryAttr = m.summary ? ` summary="${m.summary}"` : '' + const messageContent = m.text + + return `<${TEAMMATE_MESSAGE_TAG} teammate_id="${m.from}"${colorAttr}${summaryAttr}>\n${messageContent}\n` + }) + .join('\n\n') + + // Helper to queue messages in AppState for later delivery + const queueMessages = () => { + setAppState(prev => ({ + ...prev, + inbox: { + messages: [ + ...prev.inbox.messages, + ...regularMessages.map(m => ({ + id: randomUUID(), + from: m.from, + text: m.text, + timestamp: m.timestamp, + status: 'pending' as const, + color: m.color, + summary: m.summary, + })), + ], + }, + })) + } + + if (!isLoading && !focusedInputDialog) { + // IDLE: Submit as new turn immediately + logForDebugging(`[InboxPoller] Session idle, submitting immediately`) + const submitted = onSubmitTeammateMessage(formatted) + if (!submitted) { + // Submission rejected (query already running), queue for later + logForDebugging( + `[InboxPoller] Submission rejected, queuing for later delivery`, + ) + queueMessages() + } + } else { + // BUSY: Add to inbox queue for UI display + later delivery + logForDebugging(`[InboxPoller] Session busy, queuing for later delivery`) + queueMessages() + } + + // Mark messages as read only after they have been successfully delivered + // or reliably queued in AppState. This prevents permanent message loss + // when the session is busy — if we crash before this point, the messages + // will be re-read on the next poll cycle instead of being silently dropped. + markRead() + }, [ + enabled, + isLoading, + focusedInputDialog, + onSubmitTeammateMessage, + setAppState, + terminal, + store, + ]) + + // When session becomes idle, deliver any pending messages and clean up processed ones + useEffect(() => { + if (!enabled) return + + // Skip if busy or in a dialog + if (isLoading || focusedInputDialog) { + return + } + + // Use ref to avoid dependency on appState object (prevents infinite loop) + const currentAppState = store.getState() + const agentName = getAgentNameToPoll(currentAppState) + if (!agentName) return + + const pendingMessages = currentAppState.inbox.messages.filter( + m => m.status === 'pending', + ) + const processedMessages = currentAppState.inbox.messages.filter( + m => m.status === 'processed', + ) + + // Clean up processed messages (they were already delivered mid-turn as attachments) + if (processedMessages.length > 0) { + logForDebugging( + `[InboxPoller] Cleaning up ${processedMessages.length} processed message(s) that were delivered mid-turn`, + ) + const processedIds = new Set(processedMessages.map(m => m.id)) + setAppState(prev => ({ + ...prev, + inbox: { + messages: prev.inbox.messages.filter(m => !processedIds.has(m.id)), + }, + })) + } + + // No pending messages to deliver + if (pendingMessages.length === 0) return + + logForDebugging( + `[InboxPoller] Session idle, delivering ${pendingMessages.length} pending message(s)`, + ) + + // Format messages with XML wrapper for Claude (include color if available) + const formatted = pendingMessages + .map(m => { + const colorAttr = m.color ? ` color="${m.color}"` : '' + const summaryAttr = m.summary ? ` summary="${m.summary}"` : '' + return `<${TEAMMATE_MESSAGE_TAG} teammate_id="${m.from}"${colorAttr}${summaryAttr}>\n${m.text}\n` + }) + .join('\n\n') + + // Try to submit - only clear messages if successful + const submitted = onSubmitTeammateMessage(formatted) + if (submitted) { + // Clear the specific messages we just submitted by their IDs + const submittedIds = new Set(pendingMessages.map(m => m.id)) + setAppState(prev => ({ + ...prev, + inbox: { + messages: prev.inbox.messages.filter(m => !submittedIds.has(m.id)), + }, + })) + } else { + logForDebugging( + `[InboxPoller] Submission rejected, keeping messages queued`, + ) + } + }, [ + enabled, + isLoading, + focusedInputDialog, + onSubmitTeammateMessage, + setAppState, + inboxMessageCount, + store, + ]) + + // Poll if running as a teammate or as a team lead + const shouldPoll = enabled && !!getAgentNameToPoll(store.getState()) + useInterval(() => void poll(), shouldPoll ? INBOX_POLL_INTERVAL_MS : null) + + // Initial poll on mount (only once) + const hasDoneInitialPollRef = useRef(false) + useEffect(() => { + if (!enabled) return + if (hasDoneInitialPollRef.current) return + // Use store.getState() to avoid dependency on appState object + if (getAgentNameToPoll(store.getState())) { + hasDoneInitialPollRef.current = true + void poll() + } + // Note: poll uses store.getState() (not appState) so it won't re-run on appState changes + // The ref guard is a safety measure to ensure initial poll only happens once + }, [enabled, poll, store]) +} diff --git a/src/hooks/useLogMessages.ts b/src/hooks/useLogMessages.ts new file mode 100644 index 0000000000000000000000000000000000000000..c244c29dd6b707bac18ed748de18f5105d3a94a0 --- /dev/null +++ b/src/hooks/useLogMessages.ts @@ -0,0 +1,119 @@ +import type { UUID } from 'crypto' +import { useEffect, useRef } from 'react' +import { useAppState } from '../state/AppState.js' +import type { Message } from '../types/message.js' +import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js' +import { + cleanMessagesForLogging, + isChainParticipant, + recordTranscript, +} from '../utils/sessionStorage.js' + +/** + * Hook that logs messages to the transcript + * conversation ID that only changes when a new conversation is started. + * + * @param messages The current conversation messages + * @param ignore When true, messages will not be recorded to the transcript + */ +export function useLogMessages(messages: Message[], ignore: boolean = false) { + const teamContext = useAppState(s => s.teamContext) + + // messages is append-only between compactions, so track where we left off + // and only pass the new tail to recordTranscript. Avoids O(n) filter+scan + // on every setMessages (~20x/turn, so n=3000 was ~120k wasted iterations). + const lastRecordedLengthRef = useRef(0) + const lastParentUuidRef = useRef(undefined) + // First-uuid change = compaction or /clear rebuilt the array; length alone + // can't detect this since post-compact [CB,summary,...keep,new] may be longer. + const firstMessageUuidRef = useRef(undefined) + // Guard against stale async .then() overwriting a fresher sync update when + // an incremental render fires before the compaction .then() resolves. + const callSeqRef = useRef(0) + + useEffect(() => { + if (ignore) return + + const currentFirstUuid = messages[0]?.uuid as UUID | undefined + const prevLength = lastRecordedLengthRef.current + + // First-render: firstMessageUuidRef is undefined. Compaction: first uuid changes. + // Both are !isIncremental, but first-render sync-walk is safe (no messagesToKeep). + const wasFirstRender = firstMessageUuidRef.current === undefined + const isIncremental = + currentFirstUuid !== undefined && + !wasFirstRender && + currentFirstUuid === firstMessageUuidRef.current && + prevLength <= messages.length + // Same-head shrink: tombstone filter, rewind, snip, partial-compact. + // Distinguished from compaction (first uuid changes) because the tail + // is either an existing on-disk message or a fresh message that this + // same effect's recordTranscript(fullArray) will write — see sync-walk + // guard below. + const isSameHeadShrink = + currentFirstUuid !== undefined && + !wasFirstRender && + currentFirstUuid === firstMessageUuidRef.current && + prevLength > messages.length + + const startIndex = isIncremental ? prevLength : 0 + if (startIndex === messages.length) return + + // Full array on first call + after compaction: recordTranscript's own + // O(n) dedup loop handles messagesToKeep interleaving correctly there. + const slice = startIndex === 0 ? messages : messages.slice(startIndex) + const parentHint = isIncremental ? lastParentUuidRef.current : undefined + + // Fire and forget - we don't want to block the UI. + const seq = ++callSeqRef.current + void recordTranscript( + slice, + isAgentSwarmsEnabled() + ? { + teamName: teamContext?.teamName, + agentName: teamContext?.selfAgentName, + } + : {}, + parentHint, + messages, + ).then(lastRecordedUuid => { + // For compaction/full array case (!isIncremental): use the async return + // value. After compaction, messagesToKeep in the array are skipped + // (already in transcript), so the sync loop would find a wrong UUID. + // Skip if a newer effect already ran (stale closure would overwrite the + // fresher sync update from the subsequent incremental render). + if (seq !== callSeqRef.current) return + if (lastRecordedUuid && !isIncremental) { + lastParentUuidRef.current = lastRecordedUuid + } + }) + + // Sync-walk safe for: incremental (pure new-tail slice), first-render + // (no messagesToKeep interleaving), and same-head shrink. Shrink is the + // subtle one: the picked uuid is either already on disk (tombstone/rewind + // — survivors were written before) or is being written by THIS effect's + // recordTranscript(fullArray) call (snip boundary / partial-compact tail + // — enqueueWrite ordering guarantees it lands before any later write that + // chains to it). Without this, the ref stays stale at a tombstoned uuid: + // the async .then() correction is raced out by the next effect's seq bump + // on large sessions where recordTranscript(fullArray) is slow. Only the + // compaction case (first uuid changed) remains unsafe — tail may be + // messagesToKeep whose last-actually-recorded uuid differs. + if (isIncremental || wasFirstRender || isSameHeadShrink) { + // Match EXACTLY what recordTranscript persists: cleanMessagesForLogging + // applies both the isLoggableMessage filter and (for external users) the + // REPL-strip + isVirtual-promote transform. Using the raw predicate here + // would pick a UUID that the transform drops, leaving the parent hint + // pointing at a message that never reached disk. Pass full messages as + // replId context — REPL tool_use and its tool_result land in separate + // render cycles, so the slice alone can't pair them. + const last = cleanMessagesForLogging(slice, messages).findLast( + isChainParticipant, + ) + if (last) lastParentUuidRef.current = last.uuid as UUID + } + + lastRecordedLengthRef.current = messages.length + firstMessageUuidRef.current = currentFirstUuid + }, [messages, ignore, teamContext?.teamName, teamContext?.selfAgentName]) +} diff --git a/src/hooks/usePromptsFromClaudeInChrome.tsx b/src/hooks/usePromptsFromClaudeInChrome.tsx new file mode 100644 index 0000000000000000000000000000000000000000..bc4673a75392cda0034c5b5483dddfd1a224181e --- /dev/null +++ b/src/hooks/usePromptsFromClaudeInChrome.tsx @@ -0,0 +1,71 @@ +import { c as _c } from "react/compiler-runtime"; +import type { ContentBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs'; +import { useEffect, useRef } from 'react'; +import { logError } from 'src/utils/log.js'; +import { z } from 'zod/v4'; +import { callIdeRpc } from '../services/mcp/client.js'; +import type { ConnectedMCPServer, MCPServerConnection } from '../services/mcp/types.js'; +import type { PermissionMode } from '../types/permissions.js'; +import { CLAUDE_IN_CHROME_MCP_SERVER_NAME, isTrackedClaudeInChromeTabId } from '../utils/claudeInChrome/common.js'; +import { lazySchema } from '../utils/lazySchema.js'; +import { enqueuePendingNotification } from '../utils/messageQueueManager.js'; + +// Schema for the prompt notification from Chrome extension (JSON-RPC 2.0 format) +const ClaudeInChromePromptNotificationSchema = lazySchema(() => z.object({ + method: z.literal('notifications/message'), + params: z.object({ + prompt: z.string(), + image: z.object({ + type: z.literal('base64'), + media_type: z.enum(['image/jpeg', 'image/png', 'image/gif', 'image/webp']), + data: z.string() + }).optional(), + tabId: z.number().optional() + }) +})); + +/** + * A hook that listens for prompt notifications from the Claude for Chrome extension, + * enqueues them as user prompts, and syncs permission mode changes to the extension. + */ +export function usePromptsFromClaudeInChrome(mcpClients, toolPermissionMode) { + const $ = _c(6); + useRef(undefined); + let t0; + if ($[0] !== mcpClients) { + t0 = [mcpClients]; + $[0] = mcpClients; + $[1] = t0; + } else { + t0 = $[1]; + } + useEffect(_temp, t0); + let t1; + let t2; + if ($[2] !== mcpClients || $[3] !== toolPermissionMode) { + t1 = () => { + const chromeClient = findChromeClient(mcpClients); + if (!chromeClient) { + return; + } + const chromeMode = toolPermissionMode === "bypassPermissions" ? "skip_all_permission_checks" : "ask"; + callIdeRpc("set_permission_mode", { + mode: chromeMode + }, chromeClient); + }; + t2 = [mcpClients, toolPermissionMode]; + $[2] = mcpClients; + $[3] = toolPermissionMode; + $[4] = t1; + $[5] = t2; + } else { + t1 = $[4]; + t2 = $[5]; + } + useEffect(t1, t2); +} +function _temp() {} +function findChromeClient(clients: MCPServerConnection[]): ConnectedMCPServer | undefined { + return clients.find((client): client is ConnectedMCPServer => client.type === 'connected' && client.name === CLAUDE_IN_CHROME_MCP_SERVER_NAME); +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ContentBlockParam","useEffect","useRef","logError","z","callIdeRpc","ConnectedMCPServer","MCPServerConnection","PermissionMode","CLAUDE_IN_CHROME_MCP_SERVER_NAME","isTrackedClaudeInChromeTabId","lazySchema","enqueuePendingNotification","ClaudeInChromePromptNotificationSchema","object","method","literal","params","prompt","string","image","type","media_type","enum","data","optional","tabId","number","usePromptsFromClaudeInChrome","mcpClients","toolPermissionMode","$","_c","undefined","t0","_temp","t1","t2","chromeClient","findChromeClient","chromeMode","mode","clients","find","client","name"],"sources":["usePromptsFromClaudeInChrome.tsx"],"sourcesContent":["import type { ContentBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs'\nimport { useEffect, useRef } from 'react'\nimport { logError } from 'src/utils/log.js'\nimport { z } from 'zod/v4'\nimport { callIdeRpc } from '../services/mcp/client.js'\nimport type {\n  ConnectedMCPServer,\n  MCPServerConnection,\n} from '../services/mcp/types.js'\nimport type { PermissionMode } from '../types/permissions.js'\nimport {\n  CLAUDE_IN_CHROME_MCP_SERVER_NAME,\n  isTrackedClaudeInChromeTabId,\n} from '../utils/claudeInChrome/common.js'\nimport { lazySchema } from '../utils/lazySchema.js'\nimport { enqueuePendingNotification } from '../utils/messageQueueManager.js'\n\n// Schema for the prompt notification from Chrome extension (JSON-RPC 2.0 format)\nconst ClaudeInChromePromptNotificationSchema = lazySchema(() =>\n  z.object({\n    method: z.literal('notifications/message'),\n    params: z.object({\n      prompt: z.string(),\n      image: z\n        .object({\n          type: z.literal('base64'),\n          media_type: z.enum([\n            'image/jpeg',\n            'image/png',\n            'image/gif',\n            'image/webp',\n          ]),\n          data: z.string(),\n        })\n        .optional(),\n      tabId: z.number().optional(),\n    }),\n  }),\n)\n\n/**\n * A hook that listens for prompt notifications from the Claude for Chrome extension,\n * enqueues them as user prompts, and syncs permission mode changes to the extension.\n */\nexport function usePromptsFromClaudeInChrome(\n  mcpClients: MCPServerConnection[],\n  toolPermissionMode: PermissionMode,\n): void {\n  const mcpClientRef = useRef<ConnectedMCPServer | undefined>(undefined)\n\n  useEffect(() => {\n    if (\"external\" !== 'ant') {\n      return\n    }\n\n    const mcpClient = findChromeClient(mcpClients)\n    if (mcpClientRef.current !== mcpClient) {\n      mcpClientRef.current = mcpClient\n    }\n\n    if (mcpClient) {\n      mcpClient.client.setNotificationHandler(\n        ClaudeInChromePromptNotificationSchema(),\n        notification => {\n          if (mcpClientRef.current !== mcpClient) {\n            return\n          }\n          const { tabId, prompt, image } = notification.params\n\n          // Process notifications from tabs we're tracking since notifications are broadcasted\n          if (\n            typeof tabId !== 'number' ||\n            !isTrackedClaudeInChromeTabId(tabId)\n          ) {\n            return\n          }\n\n          try {\n            // Build content blocks if there's an image, otherwise just use the prompt string\n            if (image) {\n              const contentBlocks: ContentBlockParam[] = [\n                { type: 'text', text: prompt },\n                {\n                  type: 'image',\n                  source: {\n                    type: image.type,\n                    media_type: image.media_type,\n                    data: image.data,\n                  },\n                },\n              ]\n              enqueuePendingNotification({\n                value: contentBlocks,\n                mode: 'prompt',\n              })\n            } else {\n              enqueuePendingNotification({ value: prompt, mode: 'prompt' })\n            }\n          } catch (error) {\n            logError(error as Error)\n          }\n        },\n      )\n    }\n  }, [mcpClients])\n\n  // Sync permission mode with Chrome extension whenever it changes\n  useEffect(() => {\n    const chromeClient = findChromeClient(mcpClients)\n    if (!chromeClient) return\n\n    const chromeMode =\n      toolPermissionMode === 'bypassPermissions'\n        ? 'skip_all_permission_checks'\n        : 'ask'\n\n    void callIdeRpc('set_permission_mode', { mode: chromeMode }, chromeClient)\n  }, [mcpClients, toolPermissionMode])\n}\n\nfunction findChromeClient(\n  clients: MCPServerConnection[],\n): ConnectedMCPServer | undefined {\n  return clients.find(\n    (client): client is ConnectedMCPServer =>\n      client.type === 'connected' &&\n      client.name === CLAUDE_IN_CHROME_MCP_SERVER_NAME,\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/src/hooks/useSwarmInitialization.ts b/src/hooks/useSwarmInitialization.ts new file mode 100644 index 0000000000000000000000000000000000000000..9b9cd6105e7429e86f4dfb483ab4f1e35102a891 --- /dev/null +++ b/src/hooks/useSwarmInitialization.ts @@ -0,0 +1,81 @@ +/** + * Swarm Initialization Hook + * + * Initializes swarm features: teammate hooks and context. + * Handles both fresh spawns and resumed teammate sessions. + * + * This hook is conditionally loaded to allow dead code elimination when swarms are disabled. + */ + +import { useEffect } from 'react' +import { getSessionId } from '../bootstrap/state.js' +import type { AppState } from '../state/AppState.js' +import type { Message } from '../types/message.js' +import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js' +import { initializeTeammateContextFromSession } from '../utils/swarm/reconnection.js' +import { readTeamFile } from '../utils/swarm/teamHelpers.js' +import { initializeTeammateHooks } from '../utils/swarm/teammateInit.js' +import { getDynamicTeamContext } from '../utils/teammate.js' + +type SetAppState = (f: (prevState: AppState) => AppState) => void + +/** + * Hook that initializes swarm features when ENABLE_AGENT_SWARMS is true. + * + * Handles both: + * - Resumed teammate sessions (from --resume or /resume) where teamName/agentName + * are stored in transcript messages + * - Fresh spawns where context is read from environment variables + */ +export function useSwarmInitialization( + setAppState: SetAppState, + initialMessages: Message[] | undefined, + { enabled = true }: { enabled?: boolean } = {}, +): void { + useEffect(() => { + if (!enabled) return + if (isAgentSwarmsEnabled()) { + // Check if this is a resumed agent session (from --resume or /resume) + // Resumed sessions have teamName/agentName stored in transcript messages + const firstMessage = initialMessages?.[0] + const teamName = + firstMessage && 'teamName' in firstMessage + ? (firstMessage.teamName as string | undefined) + : undefined + const agentName = + firstMessage && 'agentName' in firstMessage + ? (firstMessage.agentName as string | undefined) + : undefined + + if (teamName && agentName) { + // Resumed agent session - set up team context from stored info + initializeTeammateContextFromSession(setAppState, teamName, agentName) + + // Get agentId from team file for hook initialization + const teamFile = readTeamFile(teamName) + const member = teamFile?.members.find( + (m: { name: string }) => m.name === agentName, + ) + if (member) { + initializeTeammateHooks(setAppState, getSessionId(), { + teamName, + agentId: member.agentId, + agentName, + }) + } + } else { + // Fresh spawn or standalone session + // teamContext is already computed in main.tsx via computeInitialTeamContext() + // and included in initialState, so we only need to initialize hooks here + const context = getDynamicTeamContext?.() + if (context?.teamName && context?.agentId && context?.agentName) { + initializeTeammateHooks(setAppState, getSessionId(), { + teamName: context.teamName, + agentId: context.agentId, + agentName: context.agentName, + }) + } + } + } + }, [setAppState, initialMessages, enabled]) +} diff --git a/src/tools/utils.ts b/src/tools/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..c55ea2ef9474c7c8eddfcf6c92cd2c65d5343dfa --- /dev/null +++ b/src/tools/utils.ts @@ -0,0 +1,40 @@ +import type { + AssistantMessage, + AttachmentMessage, + SystemMessage, + UserMessage, +} from 'src/types/message.js' + +/** + * Tags user messages with a sourceToolUseID so they stay transient until the tool resolves. + * This prevents the "is running" message from being duplicated in the UI. + */ +export function tagMessagesWithToolUseID( + messages: (UserMessage | AttachmentMessage | SystemMessage)[], + toolUseID: string | undefined, +): (UserMessage | AttachmentMessage | SystemMessage)[] { + if (!toolUseID) { + return messages + } + return messages.map(m => { + if (m.type === 'user') { + return { ...m, sourceToolUseID: toolUseID } + } + return m + }) +} + +/** + * Extracts the tool use ID from a parent message for a given tool name. + */ +export function getToolUseIDFromParentMessage( + parentMessage: AssistantMessage, + toolName: string, +): string | undefined { + const toolUseBlock = parentMessage.message.content.find( + block => block.type === 'tool_use' && block.name === toolName, + ) + return toolUseBlock && toolUseBlock.type === 'tool_use' + ? toolUseBlock.id + : undefined +}