yzcode-cli 1.0.2 → 1.0.4

package/screens/ResumeConversation.tsx

@@ -0,0 +1,399 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import { dirname } from 'path';
+import React from 'react';
+import { useTerminalSize } from '../hooks/useTerminalSize.ts';
+import { getOriginalCwd, switchSession } from '../bootstrap/state.ts';
+import type { Command } from '../commands.ts';
+import { LogSelector } from '../components/LogSelector.ts';
+import { Spinner } from '../components/Spinner.ts';
+import { restoreCostStateForSession } from '../cost-tracker.ts';
+import { setClipboard } from '../ink/termio/osc.ts';
+import { Box, Text } from '../ink.ts';
+import { useKeybinding } from '../keybindings/useKeybinding.ts';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../services/analytics/index.ts';
+import type { MCPServerConnection, ScopedMcpServerConfig } from '../services/mcp/types.ts';
+import { useAppState, useSetAppState } from '../state/AppState.ts';
+import type { Tool } from '../Tool.ts';
+import type { AgentColorName } from '../tools/AgentTool/agentColorManager.ts';
+import type { AgentDefinition } from '../tools/AgentTool/loadAgentsDir.ts';
+import { asSessionId } from '../types/ids.ts';
+import type { LogOption } from '../types/logs.ts';
+import type { Message } from '../types/message.ts';
+import { agenticSessionSearch } from '../utils/agenticSessionSearch.ts';
+import { renameRecordingForSession } from '../utils/asciicast.ts';
+import { updateSessionName } from '../utils/concurrentSessions.ts';
+import { loadConversationForResume } from '../utils/conversationRecovery.ts';
+import { checkCrossProjectResume } from '../utils/crossProjectResume.ts';
+import type { FileHistorySnapshot } from '../utils/fileHistory.ts';
+import { logError } from '../utils/log.ts';
+import { createSystemMessage } from '../utils/messages.ts';
+import { computeStandaloneAgentContext, restoreAgentFromSession, restoreWorktreeForResume } from '../utils/sessionRestore.ts';
+import { adoptResumedSessionFile, enrichLogs, isCustomTitleEnabled, loadAllProjectsMessageLogsProgressive, loadSameRepoMessageLogsProgressive, recordContentReplacement, resetSessionFilePointer, restoreSessionMetadata, type SessionLogResult } from '../utils/sessionStorage.ts';
+import type { ThinkingConfig } from '../utils/thinking.ts';
+import type { ContentReplacementRecord } from '../utils/toolResultStorage.ts';
+import { REPL } from './REPL.ts';
+function parsePrIdentifier(value: string): number | null {
+  const directNumber = parseInt(value, 10);
+  if (!isNaN(directNumber) && directNumber > 0) {
+    return directNumber;
+  }
+  const urlMatch = value.match(/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/);
+  if (urlMatch?.[1]) {
+    return parseInt(urlMatch[1], 10);
+  }
+  return null;
+}
+type Props = {
+  commands: Command[];
+  worktreePaths: string[];
+  initialTools: Tool[];
+  mcpClients?: MCPServerConnection[];
+  dynamicMcpConfig?: Record<string, ScopedMcpServerConfig>;
+  debug: boolean;
+  mainThreadAgentDefinition?: AgentDefinition;
+  autoConnectIdeFlag?: boolean;
+  strictMcpConfig?: boolean;
+  systemPrompt?: string;
+  appendSystemPrompt?: string;
+  initialSearchQuery?: string;
+  disableSlashCommands?: boolean;
+  forkSession?: boolean;
+  taskListId?: string;
+  filterByPr?: boolean | number | string;
+  thinkingConfig: ThinkingConfig;
+  onTurnComplete?: (messages: Message[]) => void | Promise<void>;
+};
+export function ResumeConversation({
+  commands,
+  worktreePaths,
+  initialTools,
+  mcpClients,
+  dynamicMcpConfig,
+  debug,
+  mainThreadAgentDefinition,
+  autoConnectIdeFlag,
+  strictMcpConfig = false,
+  systemPrompt,
+  appendSystemPrompt,
+  initialSearchQuery,
+  disableSlashCommands = false,
+  forkSession,
+  taskListId,
+  filterByPr,
+  thinkingConfig,
+  onTurnComplete
+}: Props): React.ReactNode {
+  const {
+    rows
+  } = useTerminalSize();
+  const agentDefinitions = useAppState(s => s.agentDefinitions);
+  const setAppState = useSetAppState();
+  const [logs, setLogs] = React.useState<LogOption[]>([]);
+  const [loading, setLoading] = React.useState(true);
+  const [resuming, setResuming] = React.useState(false);
+  const [showAllProjects, setShowAllProjects] = React.useState(false);
+  const [resumeData, setResumeData] = React.useState<{
+    messages: Message[];
+    fileHistorySnapshots?: FileHistorySnapshot[];
+    contentReplacements?: ContentReplacementRecord[];
+    agentName?: string;
+    agentColor?: AgentColorName;
+    mainThreadAgentDefinition?: AgentDefinition;
+  } | null>(null);
+  const [crossProjectCommand, setCrossProjectCommand] = React.useState<string | null>(null);
+  const sessionLogResultRef = React.useRef<SessionLogResult | null>(null);
+  // Mirror of logs.length so loadMoreLogs can compute value indices outside
+  // the setLogs updater (keeping it pure per React's contract).
+  const logCountRef = React.useRef(0);
+  const filteredLogs = React.useMemo(() => {
+    let result = logs.filter(l => !l.isSidechain);
+    if (filterByPr !== undefined) {
+      if (filterByPr === true) {
+        result = result.filter(l_0 => l_0.prNumber !== undefined);
+      } else if (typeof filterByPr === 'number') {
+        result = result.filter(l_1 => l_1.prNumber === filterByPr);
+      } else if (typeof filterByPr === 'string') {
+        const prNumber = parsePrIdentifier(filterByPr);
+        if (prNumber !== null) {
+          result = result.filter(l_2 => l_2.prNumber === prNumber);
+        }
+      }
+    }
+    return result;
+  }, [logs, filterByPr]);
+  const isResumeWithRenameEnabled = isCustomTitleEnabled();
+  React.useEffect(() => {
+    loadSameRepoMessageLogsProgressive(worktreePaths).then(result_0 => {
+      sessionLogResultRef.current = result_0;
+      logCountRef.current = result_0.logs.length;
+      setLogs(result_0.logs);
+      setLoading(false);
+    }).catch(error => {
+      logError(error);
+      setLoading(false);
+    });
+  }, [worktreePaths]);
+  const loadMoreLogs = React.useCallback((count: number) => {
+    const ref = sessionLogResultRef.current;
+    if (!ref || ref.nextIndex >= ref.allStatLogs.length) return;
+    void enrichLogs(ref.allStatLogs, ref.nextIndex, count).then(result_1 => {
+      ref.nextIndex = result_1.nextIndex;
+      if (result_1.logs.length > 0) {
+        // enrichLogs returns fresh unshared objects — safe to mutate in place.
+        // Offset comes from logCountRef so the setLogs updater stays pure.
+        const offset = logCountRef.current;
+        result_1.logs.forEach((log, i) => {
+          log.value = offset + i;
+        });
+        setLogs(prev => prev.concat(result_1.logs));
+        logCountRef.current += result_1.logs.length;
+      } else if (ref.nextIndex < ref.allStatLogs.length) {
+        loadMoreLogs(count);
+      }
+    });
+  }, []);
+  const loadLogs = React.useCallback((allProjects: boolean) => {
+    setLoading(true);
+    const promise = allProjects ? loadAllProjectsMessageLogsProgressive() : loadSameRepoMessageLogsProgressive(worktreePaths);
+    promise.then(result_2 => {
+      sessionLogResultRef.current = result_2;
+      logCountRef.current = result_2.logs.length;
+      setLogs(result_2.logs);
+    }).catch(error_0 => {
+      logError(error_0);
+    }).finally(() => {
+      setLoading(false);
+    });
+  }, [worktreePaths]);
+  const handleToggleAllProjects = React.useCallback(() => {
+    const newValue = !showAllProjects;
+    setShowAllProjects(newValue);
+    loadLogs(newValue);
+  }, [showAllProjects, loadLogs]);
+  function onCancel() {
+    // eslint-disable-next-line custom-rules/no-process-exit
+    process.exit(1);
+  }
+  async function onSelect(log_0: LogOption) {
+    setResuming(true);
+    const resumeStart = performance.now();
+    const crossProjectCheck = checkCrossProjectResume(log_0, showAllProjects, worktreePaths);
+    if (crossProjectCheck.isCrossProject) {
+      if (!crossProjectCheck.isSameRepoWorktree) {
+        const raw = await setClipboard(crossProjectCheck.command);
+        if (raw) process.stdout.write(raw);
+        setCrossProjectCommand(crossProjectCheck.command);
+        return;
+      }
+    }
+    try {
+      const result_3 = await loadConversationForResume(log_0, undefined);
+      if (!result_3) {
+        throw new Error('Failed to load conversation');
+      }
+      if (feature('COORDINATOR_MODE')) {
+        /* eslint-disable @typescript-eslint/no-require-imports */
+        const coordinatorModule = require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js');
+        /* eslint-enable @typescript-eslint/no-require-imports */
+        const warning = coordinatorModule.matchSessionMode(result_3.mode);
+        if (warning) {
+          /* eslint-disable @typescript-eslint/no-require-imports */
+          const {
+            getAgentDefinitionsWithOverrides,
+            getActiveAgentsFromList
+          } = require('../tools/AgentTool/loadAgentsDir.js') as typeof import('../tools/AgentTool/loadAgentsDir.js');
+          /* eslint-enable @typescript-eslint/no-require-imports */
+          getAgentDefinitionsWithOverrides.cache.clear?.();
+          const freshAgentDefs = await getAgentDefinitionsWithOverrides(getOriginalCwd());
+          setAppState(prev_0 => ({
+            ...prev_0,
+            agentDefinitions: {
+              ...freshAgentDefs,
+              allAgents: freshAgentDefs.allAgents,
+              activeAgents: getActiveAgentsFromList(freshAgentDefs.allAgents)
+            }
+          }));
+          result_3.messages.push(createSystemMessage(warning, 'warning'));
+        }
+      }
+      if (result_3.sessionId && !forkSession) {
+        switchSession(asSessionId(result_3.sessionId), log_0.fullPath ? dirname(log_0.fullPath) : null);
+        await renameRecordingForSession();
+        await resetSessionFilePointer();
+        restoreCostStateForSession(result_3.sessionId);
+      } else if (forkSession && result_3.contentReplacements?.length) {
+        await recordContentReplacement(result_3.contentReplacements);
+      }
+      const {
+        agentDefinition: resolvedAgentDef
+      } = restoreAgentFromSession(result_3.agentSetting, mainThreadAgentDefinition, agentDefinitions);
+      setAppState(prev_1 => ({
+        ...prev_1,
+        agent: resolvedAgentDef?.agentType
+      }));
+      if (feature('COORDINATOR_MODE')) {
+        /* eslint-disable @typescript-eslint/no-require-imports */
+        const {
+          saveMode
+        } = require('../utils/sessionStorage.js');
+        const {
+          isCoordinatorMode
+        } = require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js');
+        /* eslint-enable @typescript-eslint/no-require-imports */
+        saveMode(isCoordinatorMode() ? 'coordinator' : 'normal');
+      }
+      const standaloneAgentContext = computeStandaloneAgentContext(result_3.agentName, result_3.agentColor);
+      if (standaloneAgentContext) {
+        setAppState(prev_2 => ({
+          ...prev_2,
+          standaloneAgentContext
+        }));
+      }
+      void updateSessionName(result_3.agentName);
+      restoreSessionMetadata(forkSession ? {
+        ...result_3,
+        worktreeSession: undefined
+      } : result_3);
+      if (!forkSession) {
+        restoreWorktreeForResume(result_3.worktreeSession);
+        if (result_3.sessionId) {
+          adoptResumedSessionFile();
+        }
+      }
+      if (feature('CONTEXT_COLLAPSE')) {
+        /* eslint-disable @typescript-eslint/no-require-imports */
+        ;
+        (require('../services/contextCollapse/persist.js') as typeof import('../services/contextCollapse/persist.js')).restoreFromEntries(result_3.contextCollapseCommits ?? [], result_3.contextCollapseSnapshot);
+        /* eslint-enable @typescript-eslint/no-require-imports */
+      }
+      logEvent('tengu_session_resumed', {
+        entrypoint: 'picker' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        success: true,
+        resume_duration_ms: Math.round(performance.now() - resumeStart)
+      });
+      setLogs([]);
+      setResumeData({
+        messages: result_3.messages,
+        fileHistorySnapshots: result_3.fileHistorySnapshots,
+        contentReplacements: result_3.contentReplacements,
+        agentName: result_3.agentName,
+        agentColor: (result_3.agentColor === 'default' ? undefined : result_3.agentColor) as AgentColorName | undefined,
+        mainThreadAgentDefinition: resolvedAgentDef
+      });
+    } catch (e) {
+      logEvent('tengu_session_resumed', {
+        entrypoint: 'picker' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        success: false
+      });
+      logError(e as Error);
+      throw e;
+    }
+  }
+  if (crossProjectCommand) {
+    return <CrossProjectMessage command={crossProjectCommand} />;
+  }
+  if (resumeData) {
+    return <REPL debug={debug} commands={commands} initialTools={initialTools} initialMessages={resumeData.messages} initialFileHistorySnapshots={resumeData.fileHistorySnapshots} initialContentReplacements={resumeData.contentReplacements} initialAgentName={resumeData.agentName} initialAgentColor={resumeData.agentColor} mcpClients={mcpClients} dynamicMcpConfig={dynamicMcpConfig} strictMcpConfig={strictMcpConfig} systemPrompt={systemPrompt} appendSystemPrompt={appendSystemPrompt} mainThreadAgentDefinition={resumeData.mainThreadAgentDefinition} autoConnectIdeFlag={autoConnectIdeFlag} disableSlashCommands={disableSlashCommands} taskListId={taskListId} thinkingConfig={thinkingConfig} onTurnComplete={onTurnComplete} />;
+  }
+  if (loading) {
+    return <Box>
+        <Spinner />
+        <Text> Loading conversations…</Text>
+      </Box>;
+  }
+  if (resuming) {
+    return <Box>
+        <Spinner />
+        <Text> Resuming conversation…</Text>
+      </Box>;
+  }
+  if (filteredLogs.length === 0) {
+    return <NoConversationsMessage />;
+  }
+  return <LogSelector logs={filteredLogs} maxHeight={rows} onCancel={onCancel} onSelect={onSelect} onLogsChanged={isResumeWithRenameEnabled ? () => loadLogs(showAllProjects) : undefined} onLoadMore={loadMoreLogs} initialSearchQuery={initialSearchQuery} showAllProjects={showAllProjects} onToggleAllProjects={handleToggleAllProjects} onAgenticSearch={agenticSessionSearch} />;
+}
+function NoConversationsMessage() {
+  const $ = _c(2);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      context: "Global"
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  useKeybinding("app:interrupt", _temp, t0);
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <Box flexDirection="column"><Text>No conversations found to resume.</Text><Text dimColor={true}>Press Ctrl+C to exit and start a new conversation.</Text></Box>;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+function _temp() {
+  process.exit(1);
+}
+function CrossProjectMessage(t0) {
+  const $ = _c(8);
+  const {
+    command
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = [];
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  React.useEffect(_temp3, t1);
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Text>This conversation is from a different directory.</Text>;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  let t3;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = <Text>To resume, run:</Text>;
+    $[2] = t3;
+  } else {
+    t3 = $[2];
+  }
+  let t4;
+  if ($[3] !== command) {
+    t4 = <Box flexDirection="column">{t3}<Text> {command}</Text></Box>;
+    $[3] = command;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = <Text dimColor={true}>(Command copied to clipboard)</Text>;
+    $[5] = t5;
+  } else {
+    t5 = $[5];
+  }
+  let t6;
+  if ($[6] !== t4) {
+    t6 = <Box flexDirection="column" gap={1}>{t2}{t4}{t5}</Box>;
+    $[6] = t4;
+    $[7] = t6;
+  } else {
+    t6 = $[7];
+  }
+  return t6;
+}
+function _temp3() {
+  const timeout = setTimeout(_temp2, 100);
+  return () => clearTimeout(timeout);
+}
+function _temp2() {
+  process.exit(0);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","dirname","React","useTerminalSize","getOriginalCwd","switchSession","Command","LogSelector","Spinner","restoreCostStateForSession","setClipboard","Box","Text","useKeybinding","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","MCPServerConnection","ScopedMcpServerConfig","useAppState","useSetAppState","Tool","AgentColorName","AgentDefinition","asSessionId","LogOption","Message","agenticSessionSearch","renameRecordingForSession","updateSessionName","loadConversationForResume","checkCrossProjectResume","FileHistorySnapshot","logError","createSystemMessage","computeStandaloneAgentContext","restoreAgentFromSession","restoreWorktreeForResume","adoptResumedSessionFile","enrichLogs","isCustomTitleEnabled","loadAllProjectsMessageLogsProgressive","loadSameRepoMessageLogsProgressive","recordContentReplacement","resetSessionFilePointer","restoreSessionMetadata","SessionLogResult","ThinkingConfig","ContentReplacementRecord","REPL","parsePrIdentifier","value","directNumber","parseInt","isNaN","urlMatch","match","Props","commands","worktreePaths","initialTools","mcpClients","dynamicMcpConfig","Record","debug","mainThreadAgentDefinition","autoConnectIdeFlag","strictMcpConfig","systemPrompt","appendSystemPrompt","initialSearchQuery","disableSlashCommands","forkSession","taskListId","filterByPr","thinkingConfig","onTurnComplete","messages","Promise","ResumeConversation","ReactNode","rows","agentDefinitions","s","setAppState","logs","setLogs","useState","loading","setLoading","resuming","setResuming","showAllProjects","setShowAllProjects","resumeData","setResumeData","fileHistorySnapshots","contentReplacements","agentName","agentColor","crossProjectCommand","setCrossProjectCommand","sessionLogResultRef","useRef","logCountRef","filteredLogs","useMemo","result","filter","l","isSidechain","undefined","prNumber","isResumeWithRenameEnabled","useEffect","then","current","length","catch","error","loadMoreLogs","useCallback","count","ref","nextIndex","allStatLogs","offset","forEach","log","i","prev","concat","loadLogs","allProjects","promise","finally","handleToggleAllProjects","newValue","onCancel","process","exit","onSelect","resumeStart","performance","now","crossProjectCheck","isCrossProject","isSameRepoWorktree","raw","command","stdout","write","Error","coordinatorModule","require","warning","matchSessionMode","mode","getAgentDefinitionsWithOverrides","getActiveAgentsFromList","cache","clear","freshAgentDefs","allAgents","activeAgents","push","sessionId","fullPath","agentDefinition","resolvedAgentDef","agentSetting","agent","agentType","saveMode","isCoordinatorMode","standaloneAgentContext","worktreeSession","restoreFromEntries","contextCollapseCommits","contextCollapseSnapshot","entrypoint","success","resume_duration_ms","Math","round","e","NoConversationsMessage","$","_c","t0","Symbol","for","context","_temp","t1","CrossProjectMessage","_temp3","t2","t3","t4","t5","t6","timeout","setTimeout","_temp2","clearTimeout"],"sources":["ResumeConversation.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport { dirname } from 'path'\nimport React from 'react'\nimport { useTerminalSize } from 'src/hooks/useTerminalSize.js'\nimport { getOriginalCwd, switchSession } from '../bootstrap/state.js'\nimport type { Command } from '../commands.js'\nimport { LogSelector } from '../components/LogSelector.js'\nimport { Spinner } from '../components/Spinner.js'\nimport { restoreCostStateForSession } from '../cost-tracker.js'\nimport { setClipboard } from '../ink/termio/osc.js'\nimport { Box, Text } from '../ink.js'\nimport { useKeybinding } from '../keybindings/useKeybinding.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../services/analytics/index.js'\nimport type {\n  MCPServerConnection,\n  ScopedMcpServerConfig,\n} from '../services/mcp/types.js'\nimport { useAppState, useSetAppState } from '../state/AppState.js'\nimport type { Tool } from '../Tool.js'\nimport type { AgentColorName } from '../tools/AgentTool/agentColorManager.js'\nimport type { AgentDefinition } from '../tools/AgentTool/loadAgentsDir.js'\nimport { asSessionId } from '../types/ids.js'\nimport type { LogOption } from '../types/logs.js'\nimport type { Message } from '../types/message.js'\nimport { agenticSessionSearch } from '../utils/agenticSessionSearch.js'\nimport { renameRecordingForSession } from '../utils/asciicast.js'\nimport { updateSessionName } from '../utils/concurrentSessions.js'\nimport { loadConversationForResume } from '../utils/conversationRecovery.js'\nimport { checkCrossProjectResume } from '../utils/crossProjectResume.js'\nimport type { FileHistorySnapshot } from '../utils/fileHistory.js'\nimport { logError } from '../utils/log.js'\nimport { createSystemMessage } from '../utils/messages.js'\nimport {\n  computeStandaloneAgentContext,\n  restoreAgentFromSession,\n  restoreWorktreeForResume,\n} from '../utils/sessionRestore.js'\nimport {\n  adoptResumedSessionFile,\n  enrichLogs,\n  isCustomTitleEnabled,\n  loadAllProjectsMessageLogsProgressive,\n  loadSameRepoMessageLogsProgressive,\n  recordContentReplacement,\n  resetSessionFilePointer,\n  restoreSessionMetadata,\n  type SessionLogResult,\n} from '../utils/sessionStorage.js'\nimport type { ThinkingConfig } from '../utils/thinking.js'\nimport type { ContentReplacementRecord } from '../utils/toolResultStorage.js'\nimport { REPL } from './REPL.js'\n\nfunction parsePrIdentifier(value: string): number | null {\n  const directNumber = parseInt(value, 10)\n  if (!isNaN(directNumber) && directNumber > 0) {\n    return directNumber\n  }\n  const urlMatch = value.match(/github\\.com\\/[^/]+\\/[^/]+\\/pull\\/(\\d+)/)\n  if (urlMatch?.[1]) {\n    return parseInt(urlMatch[1], 10)\n  }\n  return null\n}\n\ntype Props = {\n  commands: Command[]\n  worktreePaths: string[]\n  initialTools: Tool[]\n  mcpClients?: MCPServerConnection[]\n  dynamicMcpConfig?: Record<string, ScopedMcpServerConfig>\n  debug: boolean\n  mainThreadAgentDefinition?: AgentDefinition\n  autoConnectIdeFlag?: boolean\n  strictMcpConfig?: boolean\n  systemPrompt?: string\n  appendSystemPrompt?: string\n  initialSearchQuery?: string\n  disableSlashCommands?: boolean\n  forkSession?: boolean\n  taskListId?: string\n  filterByPr?: boolean | number | string\n  thinkingConfig: ThinkingConfig\n  onTurnComplete?: (messages: Message[]) => void | Promise<void>\n}\n\nexport function ResumeConversation({\n  commands,\n  worktreePaths,\n  initialTools,\n  mcpClients,\n  dynamicMcpConfig,\n  debug,\n  mainThreadAgentDefinition,\n  autoConnectIdeFlag,\n  strictMcpConfig = false,\n  systemPrompt,\n  appendSystemPrompt,\n  initialSearchQuery,\n  disableSlashCommands = false,\n  forkSession,\n  taskListId,\n  filterByPr,\n  thinkingConfig,\n  onTurnComplete,\n}: Props): React.ReactNode {\n  const { rows } = useTerminalSize()\n  const agentDefinitions = useAppState(s => s.agentDefinitions)\n  const setAppState = useSetAppState()\n  const [logs, setLogs] = React.useState<LogOption[]>([])\n  const [loading, setLoading] = React.useState(true)\n  const [resuming, setResuming] = React.useState(false)\n  const [showAllProjects, setShowAllProjects] = React.useState(false)\n  const [resumeData, setResumeData] = React.useState<{\n    messages: Message[]\n    fileHistorySnapshots?: FileHistorySnapshot[]\n    contentReplacements?: ContentReplacementRecord[]\n    agentName?: string\n    agentColor?: AgentColorName\n    mainThreadAgentDefinition?: AgentDefinition\n  } | null>(null)\n  const [crossProjectCommand, setCrossProjectCommand] = React.useState<\n    string | null\n  >(null)\n  const sessionLogResultRef = React.useRef<SessionLogResult | null>(null)\n  // Mirror of logs.length so loadMoreLogs can compute value indices outside\n  // the setLogs updater (keeping it pure per React's contract).\n  const logCountRef = React.useRef(0)\n\n  const filteredLogs = React.useMemo(() => {\n    let result = logs.filter(l => !l.isSidechain)\n    if (filterByPr !== undefined) {\n      if (filterByPr === true) {\n        result = result.filter(l => l.prNumber !== undefined)\n      } else if (typeof filterByPr === 'number') {\n        result = result.filter(l => l.prNumber === filterByPr)\n      } else if (typeof filterByPr === 'string') {\n        const prNumber = parsePrIdentifier(filterByPr)\n        if (prNumber !== null) {\n          result = result.filter(l => l.prNumber === prNumber)\n        }\n      }\n    }\n    return result\n  }, [logs, filterByPr])\n  const isResumeWithRenameEnabled = isCustomTitleEnabled()\n\n  React.useEffect(() => {\n    loadSameRepoMessageLogsProgressive(worktreePaths)\n      .then(result => {\n        sessionLogResultRef.current = result\n        logCountRef.current = result.logs.length\n        setLogs(result.logs)\n        setLoading(false)\n      })\n      .catch(error => {\n        logError(error)\n        setLoading(false)\n      })\n  }, [worktreePaths])\n\n  const loadMoreLogs = React.useCallback((count: number) => {\n    const ref = sessionLogResultRef.current\n    if (!ref || ref.nextIndex >= ref.allStatLogs.length) return\n\n    void enrichLogs(ref.allStatLogs, ref.nextIndex, count).then(result => {\n      ref.nextIndex = result.nextIndex\n      if (result.logs.length > 0) {\n        // enrichLogs returns fresh unshared objects — safe to mutate in place.\n        // Offset comes from logCountRef so the setLogs updater stays pure.\n        const offset = logCountRef.current\n        result.logs.forEach((log, i) => {\n          log.value = offset + i\n        })\n        setLogs(prev => prev.concat(result.logs))\n        logCountRef.current += result.logs.length\n      } else if (ref.nextIndex < ref.allStatLogs.length) {\n        loadMoreLogs(count)\n      }\n    })\n  }, [])\n\n  const loadLogs = React.useCallback(\n    (allProjects: boolean) => {\n      setLoading(true)\n      const promise = allProjects\n        ? loadAllProjectsMessageLogsProgressive()\n        : loadSameRepoMessageLogsProgressive(worktreePaths)\n      promise\n        .then(result => {\n          sessionLogResultRef.current = result\n          logCountRef.current = result.logs.length\n          setLogs(result.logs)\n        })\n        .catch(error => {\n          logError(error)\n        })\n        .finally(() => {\n          setLoading(false)\n        })\n    },\n    [worktreePaths],\n  )\n\n  const handleToggleAllProjects = React.useCallback(() => {\n    const newValue = !showAllProjects\n    setShowAllProjects(newValue)\n    loadLogs(newValue)\n  }, [showAllProjects, loadLogs])\n\n  function onCancel() {\n    // eslint-disable-next-line custom-rules/no-process-exit\n    process.exit(1)\n  }\n\n  async function onSelect(log: LogOption) {\n    setResuming(true)\n    const resumeStart = performance.now()\n\n    const crossProjectCheck = checkCrossProjectResume(\n      log,\n      showAllProjects,\n      worktreePaths,\n    )\n    if (crossProjectCheck.isCrossProject) {\n      if (!crossProjectCheck.isSameRepoWorktree) {\n        const raw = await setClipboard(crossProjectCheck.command)\n        if (raw) process.stdout.write(raw)\n        setCrossProjectCommand(crossProjectCheck.command)\n        return\n      }\n    }\n\n    try {\n      const result = await loadConversationForResume(log, undefined)\n      if (!result) {\n        throw new Error('Failed to load conversation')\n      }\n\n      if (feature('COORDINATOR_MODE')) {\n        /* eslint-disable @typescript-eslint/no-require-imports */\n        const coordinatorModule =\n          require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js')\n        /* eslint-enable @typescript-eslint/no-require-imports */\n        const warning = coordinatorModule.matchSessionMode(result.mode)\n        if (warning) {\n          /* eslint-disable @typescript-eslint/no-require-imports */\n          const { getAgentDefinitionsWithOverrides, getActiveAgentsFromList } =\n            require('../tools/AgentTool/loadAgentsDir.js') as typeof import('../tools/AgentTool/loadAgentsDir.js')\n          /* eslint-enable @typescript-eslint/no-require-imports */\n          getAgentDefinitionsWithOverrides.cache.clear?.()\n          const freshAgentDefs = await getAgentDefinitionsWithOverrides(\n            getOriginalCwd(),\n          )\n          setAppState(prev => ({\n            ...prev,\n            agentDefinitions: {\n              ...freshAgentDefs,\n              allAgents: freshAgentDefs.allAgents,\n              activeAgents: getActiveAgentsFromList(freshAgentDefs.allAgents),\n            },\n          }))\n          result.messages.push(createSystemMessage(warning, 'warning'))\n        }\n      }\n\n      if (result.sessionId && !forkSession) {\n        switchSession(\n          asSessionId(result.sessionId),\n          log.fullPath ? dirname(log.fullPath) : null,\n        )\n        await renameRecordingForSession()\n        await resetSessionFilePointer()\n        restoreCostStateForSession(result.sessionId)\n      } else if (forkSession && result.contentReplacements?.length) {\n        await recordContentReplacement(result.contentReplacements)\n      }\n\n      const { agentDefinition: resolvedAgentDef } = restoreAgentFromSession(\n        result.agentSetting,\n        mainThreadAgentDefinition,\n        agentDefinitions,\n      )\n      setAppState(prev => ({ ...prev, agent: resolvedAgentDef?.agentType }))\n\n      if (feature('COORDINATOR_MODE')) {\n        /* eslint-disable @typescript-eslint/no-require-imports */\n        const { saveMode } = require('../utils/sessionStorage.js')\n        const { isCoordinatorMode } =\n          require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js')\n        /* eslint-enable @typescript-eslint/no-require-imports */\n        saveMode(isCoordinatorMode() ? 'coordinator' : 'normal')\n      }\n\n      const standaloneAgentContext = computeStandaloneAgentContext(\n        result.agentName,\n        result.agentColor,\n      )\n      if (standaloneAgentContext) {\n        setAppState(prev => ({ ...prev, standaloneAgentContext }))\n      }\n      void updateSessionName(result.agentName)\n\n      restoreSessionMetadata(\n        forkSession ? { ...result, worktreeSession: undefined } : result,\n      )\n\n      if (!forkSession) {\n        restoreWorktreeForResume(result.worktreeSession)\n        if (result.sessionId) {\n          adoptResumedSessionFile()\n        }\n      }\n\n      if (feature('CONTEXT_COLLAPSE')) {\n        /* eslint-disable @typescript-eslint/no-require-imports */\n        ;(\n          require('../services/contextCollapse/persist.js') as typeof import('../services/contextCollapse/persist.js')\n        ).restoreFromEntries(\n          result.contextCollapseCommits ?? [],\n          result.contextCollapseSnapshot,\n        )\n        /* eslint-enable @typescript-eslint/no-require-imports */\n      }\n\n      logEvent('tengu_session_resumed', {\n        entrypoint:\n          'picker' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        success: true,\n        resume_duration_ms: Math.round(performance.now() - resumeStart),\n      })\n\n      setLogs([])\n      setResumeData({\n        messages: result.messages,\n        fileHistorySnapshots: result.fileHistorySnapshots,\n        contentReplacements: result.contentReplacements,\n        agentName: result.agentName,\n        agentColor: (result.agentColor === 'default'\n          ? undefined\n          : result.agentColor) as AgentColorName | undefined,\n        mainThreadAgentDefinition: resolvedAgentDef,\n      })\n    } catch (e) {\n      logEvent('tengu_session_resumed', {\n        entrypoint:\n          'picker' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        success: false,\n      })\n      logError(e as Error)\n      throw e\n    }\n  }\n\n  if (crossProjectCommand) {\n    return <CrossProjectMessage command={crossProjectCommand} />\n  }\n\n  if (resumeData) {\n    return (\n      <REPL\n        debug={debug}\n        commands={commands}\n        initialTools={initialTools}\n        initialMessages={resumeData.messages}\n        initialFileHistorySnapshots={resumeData.fileHistorySnapshots}\n        initialContentReplacements={resumeData.contentReplacements}\n        initialAgentName={resumeData.agentName}\n        initialAgentColor={resumeData.agentColor}\n        mcpClients={mcpClients}\n        dynamicMcpConfig={dynamicMcpConfig}\n        strictMcpConfig={strictMcpConfig}\n        systemPrompt={systemPrompt}\n        appendSystemPrompt={appendSystemPrompt}\n        mainThreadAgentDefinition={resumeData.mainThreadAgentDefinition}\n        autoConnectIdeFlag={autoConnectIdeFlag}\n        disableSlashCommands={disableSlashCommands}\n        taskListId={taskListId}\n        thinkingConfig={thinkingConfig}\n        onTurnComplete={onTurnComplete}\n      />\n    )\n  }\n\n  if (loading) {\n    return (\n      <Box>\n        <Spinner />\n        <Text> Loading conversations…</Text>\n      </Box>\n    )\n  }\n\n  if (resuming) {\n    return (\n      <Box>\n        <Spinner />\n        <Text> Resuming conversation…</Text>\n      </Box>\n    )\n  }\n\n  if (filteredLogs.length === 0) {\n    return <NoConversationsMessage />\n  }\n\n  return (\n    <LogSelector\n      logs={filteredLogs}\n      maxHeight={rows}\n      onCancel={onCancel}\n      onSelect={onSelect}\n      onLogsChanged={\n        isResumeWithRenameEnabled ? () => loadLogs(showAllProjects) : undefined\n      }\n      onLoadMore={loadMoreLogs}\n      initialSearchQuery={initialSearchQuery}\n      showAllProjects={showAllProjects}\n      onToggleAllProjects={handleToggleAllProjects}\n      onAgenticSearch={agenticSessionSearch}\n    />\n  )\n}\n\nfunction NoConversationsMessage(): React.ReactNode {\n  useKeybinding(\n    'app:interrupt',\n    () => {\n      // eslint-disable-next-line custom-rules/no-process-exit\n      process.exit(1)\n    },\n    { context: 'Global' },\n  )\n\n  return (\n    <Box flexDirection=\"column\">\n      <Text>No conversations found to resume.</Text>\n      <Text dimColor>Press Ctrl+C to exit and start a new conversation.</Text>\n    </Box>\n  )\n}\n\nfunction CrossProjectMessage({\n  command,\n}: {\n  command: string\n}): React.ReactNode {\n  React.useEffect(() => {\n    const timeout = setTimeout(() => {\n      // eslint-disable-next-line custom-rules/no-process-exit\n      process.exit(0)\n    }, 100)\n    return () => clearTimeout(timeout)\n  }, [])\n\n  return (\n    <Box flexDirection=\"column\" gap={1}>\n      <Text>This conversation is from a different directory.</Text>\n      <Box flexDirection=\"column\">\n        <Text>To resume, run:</Text>\n        <Text> {command}</Text>\n      </Box>\n      <Text dimColor>(Command copied to clipboard)</Text>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/server/createDirectConnectSession.ts

@@ -0,0 +1,88 @@
+/* eslint-disable eslint-plugin-n/no-unsupported-features/node-builtins */
+
+import { errorMessage } from '../utils/errors.ts'
+import { jsonStringify } from '../utils/slowOperations.ts'
+import type { DirectConnectConfig } from './directConnectManager.ts'
+import { connectResponseSchema } from './types.ts'
+
+/**
+ * Errors thrown by createDirectConnectSession when the connection fails.
+ */
+export class DirectConnectError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'DirectConnectError'
+  }
+}
+
+/**
+ * Create a session on a direct-connect server.
+ *
+ * Posts to `${serverUrl}/sessions`, validates the response, and returns
+ * a DirectConnectConfig ready for use by the REPL or headless runner.
+ *
+ * Throws DirectConnectError on network, HTTP, or response-parsing failures.
+ */
+export async function createDirectConnectSession({
+  serverUrl,
+  authToken,
+  cwd,
+  dangerouslySkipPermissions,
+}: {
+  serverUrl: string
+  authToken?: string
+  cwd: string
+  dangerouslySkipPermissions?: boolean
+}): Promise<{
+  config: DirectConnectConfig
+  workDir?: string
+}> {
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+  }
+  if (authToken) {
+    headers['authorization'] = `Bearer ${authToken}`
+  }
+
+  let resp: Response
+  try {
+    resp = await fetch(`${serverUrl}/sessions`, {
+      method: 'POST',
+      headers,
+      body: jsonStringify({
+        cwd,
+        ...(dangerouslySkipPermissions && {
+          dangerously_skip_permissions: true,
+        }),
+      }),
+    })
+  } catch (err) {
+    throw new DirectConnectError(
+      `Failed to connect to server at ${serverUrl}: ${errorMessage(err)}`,
+    )
+  }
+
+  if (!resp.ok) {
+    throw new DirectConnectError(
+      `Failed to create session: ${resp.status} ${resp.statusText}`,
+    )
+  }
+
+  const result = connectResponseSchema().safeParse(await resp.json())
+  if (!result.success) {
+    throw new DirectConnectError(
+      `Invalid session response: ${result.error.message}`,
+    )
+  }
+
+  const data = result.data
+  return {
+    config: {
+      serverUrl,
+      sessionId: data.session_id,
+      wsUrl: data.ws_url,
+      authToken,
+    },
+    workDir: data.work_dir,
+  }
+}