lcclaude 1.0.0

package/dist/src/utils/gracefulShutdown.js

@@ -0,0 +1,274 @@
+import chalk from "chalk";
+import { writeSync } from "fs";
+import memoize from "lodash-es/memoize.js";
+import { onExit } from "signal-exit";
+import {
+  getIsInteractive,
+  getIsScrollDraining,
+  getLastMainRequestId,
+  getSessionId,
+  isSessionPersistenceDisabled
+} from "../bootstrap/state.js";
+import instances from "../ink/instances.js";
+import {
+  DISABLE_KITTY_KEYBOARD,
+  DISABLE_MODIFY_OTHER_KEYS
+} from "../ink/termio/csi.js";
+import {
+  DBP,
+  DFE,
+  DISABLE_MOUSE_TRACKING,
+  EXIT_ALT_SCREEN,
+  SHOW_CURSOR
+} from "../ink/termio/dec.js";
+import {
+  CLEAR_ITERM2_PROGRESS,
+  CLEAR_TAB_STATUS,
+  CLEAR_TERMINAL_TITLE,
+  supportsTabStatus,
+  wrapForMultiplexer
+} from "../ink/termio/osc.js";
+import { shutdownDatadog } from "../services/analytics/datadog.js";
+import { shutdown1PEventLogging } from "../services/analytics/firstPartyEventLogger.js";
+import {
+  logEvent
+} from "../services/analytics/index.js";
+import { runCleanupFunctions } from "./cleanupRegistry.js";
+import { logForDebugging } from "./debug.js";
+import { logForDiagnosticsNoPII } from "./diagLogs.js";
+import { isEnvTruthy } from "./envUtils.js";
+import { getCurrentSessionTitle, sessionIdExists } from "./sessionStorage.js";
+import { sleep } from "./sleep.js";
+import { profileReport } from "./startupProfiler.js";
+function cleanupTerminalModes() {
+  if (!process.stdout.isTTY) {
+    return;
+  }
+  try {
+    writeSync(1, DISABLE_MOUSE_TRACKING);
+    const inst = instances.get(process.stdout);
+    if (inst?.isAltScreenActive) {
+      try {
+        inst.unmount();
+      } catch {
+        writeSync(1, EXIT_ALT_SCREEN);
+      }
+    }
+    inst?.drainStdin();
+    inst?.detachForShutdown();
+    writeSync(1, DISABLE_MODIFY_OTHER_KEYS);
+    writeSync(1, DISABLE_KITTY_KEYBOARD);
+    writeSync(1, DFE);
+    writeSync(1, DBP);
+    writeSync(1, SHOW_CURSOR);
+    writeSync(1, CLEAR_ITERM2_PROGRESS);
+    if (supportsTabStatus())
+      writeSync(1, wrapForMultiplexer(CLEAR_TAB_STATUS));
+    if (!isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE)) {
+      if (process.platform === "win32") {
+        process.title = "";
+      } else {
+        writeSync(1, CLEAR_TERMINAL_TITLE);
+      }
+    }
+  } catch {}
+}
+let resumeHintPrinted = false;
+function printResumeHint() {
+  if (resumeHintPrinted) {
+    return;
+  }
+  if (process.stdout.isTTY && getIsInteractive() && !isSessionPersistenceDisabled()) {
+    try {
+      const sessionId = getSessionId();
+      if (!sessionIdExists(sessionId)) {
+        return;
+      }
+      const customTitle = getCurrentSessionTitle(sessionId);
+      let resumeArg;
+      if (customTitle) {
+        const escaped = customTitle.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+        resumeArg = `"${escaped}"`;
+      } else {
+        resumeArg = sessionId;
+      }
+      writeSync(1, chalk.dim(`
+Resume this session with:
+claude --resume ${resumeArg}
+`));
+      resumeHintPrinted = true;
+    } catch {}
+  }
+}
+function forceExit(exitCode) {
+  if (failsafeTimer !== undefined) {
+    clearTimeout(failsafeTimer);
+    failsafeTimer = undefined;
+  }
+  try {
+    instances.get(process.stdout)?.drainStdin();
+  } catch {}
+  try {
+    process.exit(exitCode);
+  } catch (e) {
+    if (false) {}
+    process.kill(process.pid, "SIGKILL");
+  }
+  if (true) {
+    throw new Error("unreachable");
+  }
+  return;
+}
+export const setupGracefulShutdown = memoize(() => {
+  onExit(() => {});
+  process.on("SIGINT", () => {
+    if (process.argv.includes("-p") || process.argv.includes("--print")) {
+      return;
+    }
+    logForDiagnosticsNoPII("info", "shutdown_signal", { signal: "SIGINT" });
+    gracefulShutdown(0);
+  });
+  process.on("SIGTERM", () => {
+    logForDiagnosticsNoPII("info", "shutdown_signal", { signal: "SIGTERM" });
+    gracefulShutdown(143);
+  });
+  if (process.platform !== "win32") {
+    process.on("SIGHUP", () => {
+      logForDiagnosticsNoPII("info", "shutdown_signal", { signal: "SIGHUP" });
+      gracefulShutdown(129);
+    });
+    if (process.stdin.isTTY) {
+      orphanCheckInterval = setInterval(() => {
+        if (getIsScrollDraining())
+          return;
+        if (!process.stdout.writable || !process.stdin.readable) {
+          clearInterval(orphanCheckInterval);
+          logForDiagnosticsNoPII("info", "shutdown_signal", {
+            signal: "orphan_detected"
+          });
+          gracefulShutdown(129);
+        }
+      }, 30000);
+      orphanCheckInterval.unref();
+    }
+  }
+  process.on("uncaughtException", (error) => {
+    logForDiagnosticsNoPII("error", "uncaught_exception", {
+      error_name: error.name,
+      error_message: error.message.slice(0, 2000)
+    });
+    logEvent("tengu_uncaught_exception", {
+      error_name: error.name
+    });
+  });
+  process.on("unhandledRejection", (reason) => {
+    const errorName = reason instanceof Error ? reason.name : typeof reason === "string" ? "string" : "unknown";
+    const errorInfo = reason instanceof Error ? {
+      error_name: reason.name,
+      error_message: reason.message.slice(0, 2000),
+      error_stack: reason.stack?.slice(0, 4000)
+    } : { error_message: String(reason).slice(0, 2000) };
+    logForDiagnosticsNoPII("error", "unhandled_rejection", errorInfo);
+    logEvent("tengu_unhandled_rejection", {
+      error_name: errorName
+    });
+  });
+});
+export function gracefulShutdownSync(exitCode = 0, reason = "other", options) {
+  process.exitCode = exitCode;
+  pendingShutdown = gracefulShutdown(exitCode, reason, options).catch((error) => {
+    logForDebugging(`Graceful shutdown failed: ${error}`, { level: "error" });
+    cleanupTerminalModes();
+    printResumeHint();
+    forceExit(exitCode);
+  }).catch(() => {});
+}
+let shutdownInProgress = false;
+let failsafeTimer;
+let orphanCheckInterval;
+let pendingShutdown;
+export function isShuttingDown() {
+  return shutdownInProgress;
+}
+export function resetShutdownState() {
+  shutdownInProgress = false;
+  resumeHintPrinted = false;
+  if (failsafeTimer !== undefined) {
+    clearTimeout(failsafeTimer);
+    failsafeTimer = undefined;
+  }
+  pendingShutdown = undefined;
+}
+export function getPendingShutdownForTesting() {
+  return pendingShutdown;
+}
+export async function gracefulShutdown(exitCode = 0, reason = "other", options) {
+  if (shutdownInProgress) {
+    return;
+  }
+  shutdownInProgress = true;
+  const { executeSessionEndHooks, getSessionEndHookTimeoutMs } = await import("./hooks.js");
+  const sessionEndTimeoutMs = getSessionEndHookTimeoutMs();
+  failsafeTimer = setTimeout((code) => {
+    cleanupTerminalModes();
+    printResumeHint();
+    forceExit(code);
+  }, Math.max(5000, sessionEndTimeoutMs + 3500), exitCode);
+  failsafeTimer.unref();
+  process.exitCode = exitCode;
+  cleanupTerminalModes();
+  printResumeHint();
+  let cleanupTimeoutId;
+  try {
+    const cleanupPromise = (async () => {
+      try {
+        await runCleanupFunctions();
+      } catch {}
+    })();
+    await Promise.race([
+      cleanupPromise,
+      new Promise((_, reject) => {
+        cleanupTimeoutId = setTimeout((rej) => rej(new CleanupTimeoutError), 2000, reject);
+      })
+    ]);
+    clearTimeout(cleanupTimeoutId);
+  } catch {
+    clearTimeout(cleanupTimeoutId);
+  }
+  try {
+    await executeSessionEndHooks(reason, {
+      ...options,
+      signal: AbortSignal.timeout(sessionEndTimeoutMs),
+      timeoutMs: sessionEndTimeoutMs
+    });
+  } catch {}
+  try {
+    profileReport();
+  } catch {}
+  const lastRequestId = getLastMainRequestId();
+  if (lastRequestId) {
+    logEvent("tengu_cache_eviction_hint", {
+      scope: "session_end",
+      last_request_id: lastRequestId
+    });
+  }
+  try {
+    await Promise.race([
+      Promise.all([shutdown1PEventLogging(), shutdownDatadog()]),
+      sleep(500)
+    ]);
+  } catch {}
+  if (options?.finalMessage) {
+    try {
+      writeSync(2, options.finalMessage + `
+`);
+    } catch {}
+  }
+  forceExit(exitCode);
+}
+
+class CleanupTimeoutError extends Error {
+  constructor() {
+    super("Cleanup timeout");
+  }
+}

package/dist/src/utils/groupToolUses.js

@@ -0,0 +1,107 @@
+const GROUPING_CACHE = new WeakMap;
+function getToolsWithGrouping(tools) {
+  let cached = GROUPING_CACHE.get(tools);
+  if (!cached) {
+    cached = new Set(tools.filter((t) => t.renderGroupedToolUse).map((t) => t.name));
+    GROUPING_CACHE.set(tools, cached);
+  }
+  return cached;
+}
+function getToolUseInfo(msg) {
+  if (msg.type === "assistant" && msg.message.content[0]?.type === "tool_use") {
+    const content = msg.message.content[0];
+    return {
+      messageId: msg.message.id,
+      toolUseId: content.id,
+      toolName: content.name
+    };
+  }
+  return null;
+}
+export function applyGrouping(messages, tools, verbose = false) {
+  if (verbose) {
+    return {
+      messages
+    };
+  }
+  const toolsWithGrouping = getToolsWithGrouping(tools);
+  const groups = new Map;
+  for (const msg of messages) {
+    const info = getToolUseInfo(msg);
+    if (info && toolsWithGrouping.has(info.toolName)) {
+      const key = `${info.messageId}:${info.toolName}`;
+      const group = groups.get(key) ?? [];
+      group.push(msg);
+      groups.set(key, group);
+    }
+  }
+  const validGroups = new Map;
+  const groupedToolUseIds = new Set;
+  for (const [key, group] of groups) {
+    if (group.length >= 2) {
+      validGroups.set(key, group);
+      for (const msg of group) {
+        const info = getToolUseInfo(msg);
+        if (info) {
+          groupedToolUseIds.add(info.toolUseId);
+        }
+      }
+    }
+  }
+  const resultsByToolUseId = new Map;
+  for (const msg of messages) {
+    if (msg.type === "user") {
+      for (const content of msg.message.content) {
+        if (content.type === "tool_result" && groupedToolUseIds.has(content.tool_use_id)) {
+          resultsByToolUseId.set(content.tool_use_id, msg);
+        }
+      }
+    }
+  }
+  const result = [];
+  const emittedGroups = new Set;
+  for (const msg of messages) {
+    const info = getToolUseInfo(msg);
+    if (info) {
+      const key = `${info.messageId}:${info.toolName}`;
+      const group = validGroups.get(key);
+      if (group) {
+        if (!emittedGroups.has(key)) {
+          emittedGroups.add(key);
+          const firstMsg = group[0];
+          const results = [];
+          for (const assistantMsg of group) {
+            const toolUseId = assistantMsg.message.content[0].id;
+            const resultMsg = resultsByToolUseId.get(toolUseId);
+            if (resultMsg) {
+              results.push(resultMsg);
+            }
+          }
+          const groupedMessage = {
+            type: "grouped_tool_use",
+            toolName: info.toolName,
+            messages: group,
+            results,
+            displayMessage: firstMsg,
+            uuid: `grouped-${firstMsg.uuid}`,
+            timestamp: firstMsg.timestamp,
+            messageId: info.messageId
+          };
+          result.push(groupedMessage);
+        }
+        continue;
+      }
+    }
+    if (msg.type === "user") {
+      const toolResults = msg.message.content.filter((c) => c.type === "tool_result");
+      if (toolResults.length > 0) {
+        const allGrouped = toolResults.every((tr) => groupedToolUseIds.has(tr.tool_use_id));
+        if (allGrouped) {
+          continue;
+        }
+      }
+    }
+    result.push(msg);
+  }
+  return { messages: result };
+}

package/dist/src/utils/handlePromptSubmit.js

@@ -0,0 +1,323 @@
+import { logEvent } from "../services/analytics/index.js";
+import { getCommandName, isCommandEnabled } from "../commands.js";
+import { selectableUserMessagesFilter } from "../components/MessageSelector.js";
+import { expandPastedTextRefs, parseReferences } from "../history.js";
+import {
+  isValidImagePaste
+} from "../types/textInputTypes.js";
+import { createAbortController } from "./abortController.js";
+import { logForDebugging } from "./debug.js";
+import { fileHistoryEnabled, fileHistoryMakeSnapshot } from "./fileHistory.js";
+import { gracefulShutdownSync } from "./gracefulShutdown.js";
+import { enqueue } from "./messageQueueManager.js";
+import { resolveSkillModelOverride } from "./model/model.js";
+import { processUserInput } from "./processUserInput/processUserInput.js";
+import { queryCheckpoint, startQueryProfile } from "./queryProfiler.js";
+import { runWithWorkload } from "./workloadContext.js";
+function exit() {
+  gracefulShutdownSync(0);
+}
+export async function handlePromptSubmit(params) {
+  const {
+    helpers,
+    queryGuard,
+    isExternalLoading = false,
+    commands,
+    onInputChange,
+    setPastedContents,
+    setToolJSX,
+    getToolUseContext,
+    messages,
+    mainLoopModel,
+    ideSelection,
+    setUserInputOnProcessing,
+    setAbortController,
+    onQuery,
+    setAppState,
+    onBeforeQuery,
+    canUseTool,
+    queuedCommands,
+    uuid,
+    skipSlashCommands
+  } = params;
+  const { setCursorOffset, clearBuffer, resetHistory } = helpers;
+  if (queuedCommands?.length) {
+    startQueryProfile();
+    await executeUserInput({
+      queuedCommands,
+      messages,
+      mainLoopModel,
+      ideSelection,
+      querySource: params.querySource,
+      commands,
+      queryGuard,
+      setToolJSX,
+      getToolUseContext,
+      setUserInputOnProcessing,
+      setAbortController,
+      onQuery,
+      setAppState,
+      onBeforeQuery,
+      resetHistory,
+      canUseTool,
+      onInputChange
+    });
+    return;
+  }
+  const input = params.input ?? "";
+  const mode = params.mode ?? "prompt";
+  const rawPastedContents = params.pastedContents ?? {};
+  const referencedIds = new Set(parseReferences(input).map((r) => r.id));
+  const pastedContents = Object.fromEntries(Object.entries(rawPastedContents).filter(([, c]) => c.type !== "image" || referencedIds.has(c.id)));
+  const hasImages = Object.values(pastedContents).some(isValidImagePaste);
+  if (input.trim() === "") {
+    return;
+  }
+  if (!skipSlashCommands && ["exit", "quit", ":q", ":q!", ":wq", ":wq!"].includes(input.trim())) {
+    const exitCommand = commands.find((cmd) => cmd.name === "exit");
+    if (exitCommand) {
+      handlePromptSubmit({
+        ...params,
+        input: "/exit"
+      });
+    } else {
+      exit();
+    }
+    return;
+  }
+  const finalInput = expandPastedTextRefs(input, pastedContents);
+  const pastedTextRefs = parseReferences(input).filter((r) => pastedContents[r.id]?.type === "text");
+  const pastedTextCount = pastedTextRefs.length;
+  const pastedTextBytes = pastedTextRefs.reduce((sum, r) => sum + (pastedContents[r.id]?.content.length ?? 0), 0);
+  logEvent("tengu_paste_text", { pastedTextCount, pastedTextBytes });
+  if (!skipSlashCommands && finalInput.trim().startsWith("/")) {
+    const trimmedInput = finalInput.trim();
+    const spaceIndex = trimmedInput.indexOf(" ");
+    const commandName = spaceIndex === -1 ? trimmedInput.slice(1) : trimmedInput.slice(1, spaceIndex);
+    const commandArgs = spaceIndex === -1 ? "" : trimmedInput.slice(spaceIndex + 1).trim();
+    const immediateCommand = commands.find((cmd) => cmd.immediate && isCommandEnabled(cmd) && (cmd.name === commandName || cmd.aliases?.includes(commandName) || getCommandName(cmd) === commandName));
+    if (immediateCommand && immediateCommand.type === "local-jsx" && (queryGuard.isActive || isExternalLoading)) {
+      logEvent("tengu_immediate_command_executed", {
+        commandName: immediateCommand.name
+      });
+      onInputChange("");
+      setCursorOffset(0);
+      setPastedContents({});
+      clearBuffer();
+      const context = getToolUseContext(messages, [], createAbortController(), mainLoopModel);
+      let doneWasCalled = false;
+      const onDone = (result, options) => {
+        doneWasCalled = true;
+        setToolJSX({
+          jsx: null,
+          shouldHidePromptInput: false,
+          clearLocalJSX: true
+        });
+        if (result && options?.display !== "skip" && params.addNotification) {
+          params.addNotification({
+            key: `immediate-${immediateCommand.name}`,
+            text: result,
+            priority: "immediate"
+          });
+        }
+        if (options?.nextInput) {
+          if (options.submitNextInput) {
+            enqueue({ value: options.nextInput, mode: "prompt" });
+          } else {
+            onInputChange(options.nextInput);
+          }
+        }
+      };
+      const impl = await immediateCommand.load();
+      const jsx = await impl.call(onDone, context, commandArgs);
+      if (jsx && !doneWasCalled) {
+        setToolJSX({
+          jsx,
+          shouldHidePromptInput: false,
+          isLocalJSXCommand: true,
+          isImmediate: true
+        });
+      }
+      return;
+    }
+  }
+  if (queryGuard.isActive || isExternalLoading) {
+    if (mode !== "prompt" && mode !== "bash") {
+      return;
+    }
+    if (params.hasInterruptibleToolInProgress) {
+      logForDebugging(`[interrupt] Aborting current turn: streamMode=${params.streamMode}`);
+      logEvent("tengu_cancel", {
+        source: "interrupt_on_submit",
+        streamMode: params.streamMode
+      });
+      params.abortController?.abort("interrupt");
+    }
+    enqueue({
+      value: finalInput.trim(),
+      preExpansionValue: input.trim(),
+      mode,
+      pastedContents: hasImages ? pastedContents : undefined,
+      skipSlashCommands,
+      uuid
+    });
+    onInputChange("");
+    setCursorOffset(0);
+    setPastedContents({});
+    resetHistory();
+    clearBuffer();
+    return;
+  }
+  startQueryProfile();
+  const cmd = {
+    value: finalInput,
+    preExpansionValue: input,
+    mode,
+    pastedContents: hasImages ? pastedContents : undefined,
+    skipSlashCommands,
+    uuid
+  };
+  await executeUserInput({
+    queuedCommands: [cmd],
+    messages,
+    mainLoopModel,
+    ideSelection,
+    querySource: params.querySource,
+    commands,
+    queryGuard,
+    setToolJSX,
+    getToolUseContext,
+    setUserInputOnProcessing,
+    setAbortController,
+    onQuery,
+    setAppState,
+    onBeforeQuery,
+    resetHistory,
+    canUseTool,
+    onInputChange
+  });
+}
+async function executeUserInput(params) {
+  const {
+    messages,
+    mainLoopModel,
+    ideSelection,
+    querySource,
+    queryGuard,
+    setToolJSX,
+    getToolUseContext,
+    setUserInputOnProcessing,
+    setAbortController,
+    onQuery,
+    setAppState,
+    onBeforeQuery,
+    resetHistory,
+    canUseTool,
+    queuedCommands
+  } = params;
+  const abortController = createAbortController();
+  setAbortController(abortController);
+  function makeContext() {
+    return getToolUseContext(messages, [], abortController, mainLoopModel);
+  }
+  try {
+    queryGuard.reserve();
+    queryCheckpoint("query_process_user_input_start");
+    const newMessages = [];
+    let shouldQuery = false;
+    let allowedTools;
+    let model;
+    let effort;
+    let nextInput;
+    let submitNextInput;
+    const commands = queuedCommands ?? [];
+    const firstWorkload = commands[0]?.workload;
+    const turnWorkload = firstWorkload !== undefined && commands.every((c) => c.workload === firstWorkload) ? firstWorkload : undefined;
+    await runWithWorkload(turnWorkload, async () => {
+      for (let i = 0;i < commands.length; i++) {
+        const cmd = commands[i];
+        const isFirst = i === 0;
+        const result = await processUserInput({
+          input: cmd.value,
+          preExpansionInput: cmd.preExpansionValue,
+          mode: cmd.mode,
+          setToolJSX,
+          context: makeContext(),
+          pastedContents: isFirst ? cmd.pastedContents : undefined,
+          messages,
+          setUserInputOnProcessing: isFirst ? setUserInputOnProcessing : undefined,
+          isAlreadyProcessing: !isFirst,
+          querySource,
+          canUseTool,
+          uuid: cmd.uuid,
+          ideSelection: isFirst ? ideSelection : undefined,
+          skipSlashCommands: cmd.skipSlashCommands,
+          bridgeOrigin: cmd.bridgeOrigin,
+          isMeta: cmd.isMeta,
+          skipAttachments: !isFirst
+        });
+        const origin = cmd.origin ?? (cmd.mode === "task-notification" ? { kind: "task-notification" } : undefined);
+        if (origin) {
+          for (const m of result.messages) {
+            if (m.type === "user")
+              m.origin = origin;
+          }
+        }
+        newMessages.push(...result.messages);
+        if (isFirst) {
+          shouldQuery = result.shouldQuery;
+          allowedTools = result.allowedTools;
+          model = result.model;
+          effort = result.effort;
+          nextInput = result.nextInput;
+          submitNextInput = result.submitNextInput;
+        }
+      }
+      queryCheckpoint("query_process_user_input_end");
+      if (fileHistoryEnabled()) {
+        queryCheckpoint("query_file_history_snapshot_start");
+        newMessages.filter(selectableUserMessagesFilter).forEach((message) => {
+          fileHistoryMakeSnapshot((updater) => {
+            setAppState((prev) => ({
+              ...prev,
+              fileHistory: updater(prev.fileHistory)
+            }));
+          }, message.uuid);
+        });
+        queryCheckpoint("query_file_history_snapshot_end");
+      }
+      if (newMessages.length) {
+        resetHistory();
+        setToolJSX({
+          jsx: null,
+          shouldHidePromptInput: false,
+          clearLocalJSX: true
+        });
+        const primaryCmd = commands[0];
+        const primaryMode = primaryCmd?.mode ?? "prompt";
+        const primaryInput = primaryCmd && typeof primaryCmd.value === "string" ? primaryCmd.value : undefined;
+        const shouldCallBeforeQuery = primaryMode === "prompt";
+        await onQuery(newMessages, abortController, shouldQuery, allowedTools ?? [], model ? resolveSkillModelOverride(model, mainLoopModel) : mainLoopModel, shouldCallBeforeQuery ? onBeforeQuery : undefined, primaryInput, effort);
+      } else {
+        queryGuard.cancelReservation();
+        setToolJSX({
+          jsx: null,
+          shouldHidePromptInput: false,
+          clearLocalJSX: true
+        });
+        resetHistory();
+        setAbortController(null);
+      }
+      if (nextInput) {
+        if (submitNextInput) {
+          enqueue({ value: nextInput, mode: "prompt" });
+        } else {
+          params.onInputChange(nextInput);
+        }
+      }
+    });
+  } finally {
+    queryGuard.cancelReservation();
+    setUserInputOnProcessing(undefined);
+  }
+}