@letta-ai/letta-code 0.10.1 → 0.10.2

package/letta.js

@@ -3233,7 +3233,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.10.1",
+    version: "0.10.2",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -3285,7 +3285,7 @@ var init_package = __esm(() => {
       typecheck: "tsc --noEmit",
       check: "bun run scripts/check.js",
       dev: "bun --loader:.md=text --loader:.mdx=text --loader:.txt=text run src/index.ts",
-      build: "bun run build.js",
+      build: "node scripts/postinstall-patches.js && bun run build.js",
       prepare: "bun run build",
       postinstall: "node scripts/postinstall-patches.js"
     },
@@ -51370,6 +51370,104 @@ var init_headless = __esm(() => {
   init_manager3();
 });
 
+// src/cli/utils/kittyProtocolDetector.ts
+var exports_kittyProtocolDetector = {};
+__export(exports_kittyProtocolDetector, {
+  isKittyProtocolEnabled: () => isKittyProtocolEnabled,
+  detectAndEnableKittyProtocol: () => detectAndEnableKittyProtocol
+});
+import * as fs14 from "node:fs";
+async function detectAndEnableKittyProtocol() {
+  if (detectionComplete) {
+    return;
+  }
+  return new Promise((resolve16) => {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      detectionComplete = true;
+      resolve16();
+      return;
+    }
+    const originalRawMode = process.stdin.isRaw;
+    if (!originalRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    let responseBuffer = "";
+    let progressiveEnhancementReceived = false;
+    let timeoutId;
+    const finish = () => {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+      }
+      process.stdin.removeListener("data", handleData);
+      if (!originalRawMode) {
+        process.stdin.setRawMode(false);
+      }
+      if (progressiveEnhancementReceived)
+        kittySupported = true;
+      if (process.stdout.isTTY) {
+        if (DEBUG2) {
+          console.error("[kitty] enabling protocol");
+        }
+        enableKittyKeyboardProtocol();
+        process.on("exit", disableKittyKeyboardProtocol);
+        process.on("SIGTERM", disableKittyKeyboardProtocol);
+        process.on("SIGINT", disableKittyKeyboardProtocol);
+      } else if (DEBUG2 && !kittySupported) {
+        console.error("[kitty] protocol query unsupported; enabled anyway (best-effort)");
+      }
+      detectionComplete = true;
+      resolve16();
+    };
+    const handleData = (data) => {
+      if (timeoutId === undefined) {
+        return;
+      }
+      responseBuffer += data.toString();
+      if (DEBUG2) {
+        console.error("[kitty] rx:", JSON.stringify(data.toString()));
+      }
+      if (responseBuffer.includes("\x1B[?") && responseBuffer.includes("u")) {
+        progressiveEnhancementReceived = true;
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(finish, 1000);
+      }
+      if (responseBuffer.includes("\x1B[?") && responseBuffer.includes("c")) {
+        if (progressiveEnhancementReceived)
+          kittySupported = true;
+        finish();
+      }
+    };
+    process.stdin.on("data", handleData);
+    if (DEBUG2) {
+      console.error("[kitty] querying support");
+    }
+    fs14.writeSync(process.stdout.fd, "\x1B[?u\x1B[c");
+    timeoutId = setTimeout(finish, 200);
+  });
+}
+function isKittyProtocolEnabled() {
+  return kittyEnabled;
+}
+function enableKittyKeyboardProtocol() {
+  try {
+    fs14.writeSync(process.stdout.fd, "\x1B[>7u");
+    kittyEnabled = true;
+  } catch {}
+}
+function disableKittyKeyboardProtocol() {
+  try {
+    if (kittyEnabled) {
+      fs14.writeSync(process.stdout.fd, "\x1B[<u");
+      kittyEnabled = false;
+    }
+  } catch {}
+}
+var detectionComplete = false, kittySupported = false, kittyEnabled = false, DEBUG2;
+var init_kittyProtocolDetector = __esm(() => {
+  DEBUG2 = process.env.LETTA_DEBUG_KITTY === "1";
+});
+
 // node_modules/react/index.js
 var require_react2 = __commonJS((exports, module) => {
   var react_development = __toESM(require_react_development(), 1);
@@ -51498,7 +51596,55 @@ var init_available_models = __esm(() => {
 });
 
 // src/settings.ts
+var exports_settings = {};
+__export(exports_settings, {
+  updateSettings: () => updateSettings,
+  updateProjectSettings: () => updateProjectSettings,
+  saveSettings: () => saveSettings,
+  saveProjectSettings: () => saveProjectSettings,
+  loadSettings: () => loadSettings,
+  loadProjectSettings: () => loadProjectSettings,
+  getSetting: () => getSetting
+});
+import { homedir as homedir6 } from "node:os";
 import { join as join13 } from "node:path";
+function getSettingsPath() {
+  return join13(homedir6(), ".letta", "settings.json");
+}
+async function loadSettings() {
+  const settingsPath = getSettingsPath();
+  try {
+    if (!exists(settingsPath)) {
+      await saveSettings(DEFAULT_SETTINGS3);
+      return DEFAULT_SETTINGS3;
+    }
+    const content = await readFile(settingsPath);
+    const settings = JSON.parse(content);
+    return { ...DEFAULT_SETTINGS3, ...settings };
+  } catch (error) {
+    console.error("Error loading settings, using defaults:", error);
+    return DEFAULT_SETTINGS3;
+  }
+}
+async function saveSettings(settings) {
+  const settingsPath = getSettingsPath();
+  try {
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  } catch (error) {
+    console.error("Error saving settings:", error);
+    throw error;
+  }
+}
+async function updateSettings(updates) {
+  const currentSettings = await loadSettings();
+  const newSettings = { ...currentSettings, ...updates };
+  await saveSettings(newSettings);
+  return newSettings;
+}
+async function getSetting(key) {
+  const settings = await loadSettings();
+  return settings[key];
+}
 function getProjectSettingsPath() {
   return join13(process.cwd(), ".letta", "settings.local.json");
 }
@@ -51535,8 +51681,14 @@ async function updateProjectSettings(updates) {
   await saveProjectSettings(newSettings);
   return newSettings;
 }
+var DEFAULT_SETTINGS3;
 var init_settings = __esm(() => {
   init_fs();
+  DEFAULT_SETTINGS3 = {
+    lastAgent: null,
+    tokenStreaming: false,
+    globalSharedBlockIds: {}
+  };
 });
 
 // src/cli/commands/mcp.ts
@@ -54379,6 +54531,8 @@ function isControlSequence(input, key) {
     return true;
   if (key.shift && key.tab)
     return true;
+  if (key.return && (key.shift || key.meta || key.ctrl))
+    return true;
   if (key.ctrl && (input === "w" || input === "W"))
     return true;
   if (key.ctrl && input && /^[a-z]$/i.test(input) && !["a", "e", "k", "u", "y"].includes(input.toLowerCase()))
@@ -54387,6 +54541,9 @@ function isControlSequence(input, key) {
     return true;
   if (input && typeof input === "string" && input.startsWith("\x1B") && input.length > 1)
     return true;
+  if (key.delete && globalThis.__lettaForwardDeleteTimestamp && Date.now() - globalThis.__lettaForwardDeleteTimestamp < 100) {
+    return true;
+  }
   return false;
 }
 function TextInput({ value: originalValue, placeholder = "", focus = true, mask, highlightPastedText = false, showCursor = true, onChange, onSubmit, externalCursorOffset, onCursorOffsetChange }) {
@@ -54736,6 +54893,33 @@ function PasteAwareTextInput({
     }
   }, [value]);
   use_input_default((input, key) => {
+    if (key.return && (key.shift || key.meta || key.ctrl)) {
+      const at = Math.max(0, Math.min(caretOffsetRef.current, displayValueRef.current.length));
+      const newValue = displayValueRef.current.slice(0, at) + `
+` + displayValueRef.current.slice(at);
+      setDisplayValue(newValue);
+      setActualValue(newValue);
+      onChangeRef.current(newValue);
+      const nextCaret = at + 1;
+      setNudgeCursorOffset(nextCaret);
+      caretOffsetRef.current = nextCaret;
+      return;
+    }
+    if (key.ctrl && input === "v") {
+      const clip = tryImportClipboardImageMac();
+      if (clip) {
+        const at = Math.max(0, Math.min(caretOffsetRef.current, displayValueRef.current.length));
+        const newDisplay = displayValueRef.current.slice(0, at) + clip + displayValueRef.current.slice(at);
+        displayValueRef.current = newDisplay;
+        setDisplayValue(newDisplay);
+        setActualValue(newDisplay);
+        onChangeRef.current(newDisplay);
+        const nextCaret = at + clip.length;
+        setNudgeCursorOffset(nextCaret);
+        caretOffsetRef.current = nextCaret;
+      }
+      return;
+    }
     const isPasted = key?.isPasted;
     if (isPasted) {
       lastPasteDetectedAtRef.current = Date.now();
@@ -54827,6 +55011,29 @@ function PasteAwareTextInput({
       setNudgeCursorOffset(wordStart);
       caretOffsetRef.current = wordStart;
     };
+    const forwardDeleteAtCursor = (cursorPos) => {
+      if (cursorPos >= displayValueRef.current.length)
+        return;
+      const newDisplay = displayValueRef.current.slice(0, cursorPos) + displayValueRef.current.slice(cursorPos + 1);
+      const resolvedActual = resolvePlaceholders(newDisplay);
+      displayValueRef.current = newDisplay;
+      caretOffsetRef.current = cursorPos;
+      setDisplayValue(newDisplay);
+      setActualValue(resolvedActual);
+      onChangeRef.current(newDisplay);
+      setNudgeCursorOffset(cursorPos);
+    };
+    const insertNewlineAtCursor = () => {
+      const at = Math.max(0, Math.min(caretOffsetRef.current, displayValueRef.current.length));
+      const newValue = displayValueRef.current.slice(0, at) + `
+` + displayValueRef.current.slice(at);
+      setDisplayValue(newValue);
+      setActualValue(newValue);
+      onChangeRef.current(newValue);
+      const nextCaret = at + 1;
+      setNudgeCursorOffset(nextCaret);
+      caretOffsetRef.current = nextCaret;
+    };
     const handleRawInput = (payload) => {
       if (!focusRef.current)
         return;
@@ -54838,6 +55045,72 @@ function PasteAwareTextInput({
       }
       if (!sequence)
         return;
+      if (process.env.LETTA_DEBUG_INPUT === "1") {
+        const debugHex = [...sequence].map((c) => `0x${c.charCodeAt(0).toString(16).padStart(2, "0")}`).join(" ");
+        console.error(`[debug:raw-input] len=${sequence.length} hex: ${debugHex}`);
+      }
+      if (sequence === "\x1B\r" || sequence === `\x1B
+`) {
+        insertNewlineAtCursor();
+        return;
+      }
+      if (sequence === "\\r") {
+        insertNewlineAtCursor();
+        return;
+      }
+      {
+        const prefix = "\x1B[13;";
+        if (sequence.startsWith(prefix) && sequence.endsWith("u")) {
+          const mod = sequence.slice(prefix.length, -1);
+          if (mod.length === 1 && mod >= "2" && mod <= "8") {
+            insertNewlineAtCursor();
+            return;
+          }
+        }
+      }
+      if (sequence === "\x1B[99;5u") {
+        internal_eventEmitter.emit("input", "\x03");
+        return;
+      }
+      if (sequence.startsWith("\x1B[99;5:")) {
+        return;
+      }
+      if (sequence === "\x1B[118;5u") {
+        const clip = tryImportClipboardImageMac();
+        if (clip) {
+          const at = Math.max(0, Math.min(caretOffsetRef.current, displayValueRef.current.length));
+          const newDisplay = displayValueRef.current.slice(0, at) + clip + displayValueRef.current.slice(at);
+          displayValueRef.current = newDisplay;
+          setDisplayValue(newDisplay);
+          setActualValue(newDisplay);
+          onChangeRef.current(newDisplay);
+          const nextCaret = at + clip.length;
+          setNudgeCursorOffset(nextCaret);
+          caretOffsetRef.current = nextCaret;
+        }
+        return;
+      }
+      if (sequence.startsWith("\x1B[118;5:")) {
+        return;
+      }
+      {
+        const arrowMatch = sequence.match(/^\x1b\[1;\d+:[12]([ABCD])$/);
+        if (arrowMatch) {
+          internal_eventEmitter.emit("input", `\x1B[${arrowMatch[1]}`);
+          return;
+        }
+        if (/^\x1b\[1;\d+:3[ABCD]$/.test(sequence)) {
+          return;
+        }
+      }
+      if (sequence === "\x1B[3~" || /^\x1b\[3;\d+:[12]~$/.test(sequence)) {
+        globalThis.__lettaForwardDeleteTimestamp = Date.now();
+        forwardDeleteAtCursor(caretOffsetRef.current);
+        return;
+      }
+      if (/^\x1b\[3;\d+:3~$/.test(sequence)) {
+        return;
+      }
       if (sequence === "\x1B" || sequence === "\x1B\b" || sequence === "\x1B\b" || sequence === "\x17") {
         deletePreviousWord();
         return;
@@ -54919,11 +55192,11 @@ function PasteAwareTextInput({
       caretOffsetRef.current = nextCaret;
       return;
     }
+    displayValueRef.current = newValue;
     setDisplayValue(newValue);
     const resolved = resolvePlaceholders(newValue);
     setActualValue(resolved);
     onChange(newValue);
-    caretOffsetRef.current = newValue.length;
   };
   const handleSubmit = () => {
     if (onSubmit) {
@@ -56712,6 +56985,318 @@ var init_FeedbackDialog = __esm(async () => {
   jsx_dev_runtime17 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
+// src/cli/utils/terminalKeybindingInstaller.ts
+var exports_terminalKeybindingInstaller = {};
+__export(exports_terminalKeybindingInstaller, {
+  wezTermDeleteFixExists: () => wezTermDeleteFixExists,
+  removeKeybindingForCurrentTerminal: () => removeKeybindingForCurrentTerminal,
+  removeKeybinding: () => removeKeybinding,
+  keybindingExists: () => keybindingExists,
+  isWezTerm: () => isWezTerm,
+  isVSCodeLikeTerminal: () => isVSCodeLikeTerminal,
+  installWezTermDeleteFix: () => installWezTermDeleteFix,
+  installKeybindingForCurrentTerminal: () => installKeybindingForCurrentTerminal,
+  installKeybinding: () => installKeybinding,
+  getWezTermConfigPath: () => getWezTermConfigPath,
+  getKeybindingsPath: () => getKeybindingsPath,
+  detectTerminalType: () => detectTerminalType
+});
+import {
+  copyFileSync,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir7, platform as platform3 } from "node:os";
+import { dirname as dirname9, join as join14 } from "node:path";
+function detectTerminalType() {
+  if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
+    return "cursor";
+  }
+  if (process.env.WINDSURF_TRACE_ID || process.env.WINDSURF_CHANNEL) {
+    return "windsurf";
+  }
+  const termProgram = process.env.TERM_PROGRAM?.toLowerCase();
+  if (termProgram === "vscode")
+    return "vscode";
+  if (termProgram === "cursor")
+    return "cursor";
+  if (termProgram === "windsurf")
+    return "windsurf";
+  if (process.env.VSCODE_INJECTION === "1")
+    return "vscode";
+  return null;
+}
+function isVSCodeLikeTerminal() {
+  return detectTerminalType() !== null;
+}
+function getKeybindingsPath(terminal) {
+  if (!terminal)
+    return null;
+  const appName = {
+    vscode: "Code",
+    cursor: "Cursor",
+    windsurf: "Windsurf"
+  }[terminal];
+  const os3 = platform3();
+  if (os3 === "darwin") {
+    return join14(homedir7(), "Library", "Application Support", appName, "User", "keybindings.json");
+  }
+  if (os3 === "win32") {
+    const appData = process.env.APPDATA;
+    if (!appData)
+      return null;
+    return join14(appData, appName, "User", "keybindings.json");
+  }
+  if (os3 === "linux") {
+    return join14(homedir7(), ".config", appName, "User", "keybindings.json");
+  }
+  return null;
+}
+function stripJsonComments(jsonc) {
+  let result = jsonc.replace(/\/\/.*$/gm, "");
+  result = result.replace(/\/\*[\s\S]*?\*\//g, "");
+  result = result.replace(/,(\s*[}\]])/g, "$1");
+  return result;
+}
+function parseKeybindings(content) {
+  try {
+    const stripped = stripJsonComments(content);
+    const parsed = JSON.parse(stripped);
+    if (!Array.isArray(parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function keybindingExists(keybindingsPath) {
+  if (!existsSync10(keybindingsPath))
+    return false;
+  try {
+    const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
+    const keybindings = parseKeybindings(content);
+    if (!keybindings)
+      return false;
+    return keybindings.some((kb) => kb.key?.toLowerCase() === "shift+enter" && kb.command === "workbench.action.terminal.sendSequence" && kb.when?.includes("terminalFocus"));
+  } catch {
+    return false;
+  }
+}
+function createBackup(keybindingsPath) {
+  if (!existsSync10(keybindingsPath))
+    return null;
+  const backupPath = `${keybindingsPath}.letta-backup`;
+  try {
+    copyFileSync(keybindingsPath, backupPath);
+    return backupPath;
+  } catch {
+    return null;
+  }
+}
+function installKeybinding(keybindingsPath) {
+  try {
+    if (keybindingExists(keybindingsPath)) {
+      return { success: true, alreadyExists: true };
+    }
+    const parentDir = dirname9(keybindingsPath);
+    if (!existsSync10(parentDir)) {
+      mkdirSync3(parentDir, { recursive: true });
+    }
+    let keybindings = [];
+    let backupPath = null;
+    if (existsSync10(keybindingsPath)) {
+      backupPath = createBackup(keybindingsPath);
+      const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
+      const parsed = parseKeybindings(content);
+      if (parsed === null) {
+        return {
+          success: false,
+          error: `Could not parse ${keybindingsPath}. Please fix syntax errors and try again.`
+        };
+      }
+      keybindings = parsed;
+    }
+    keybindings.push(SHIFT_ENTER_KEYBINDING);
+    const newContent = `${JSON.stringify(keybindings, null, 2)}
+`;
+    writeFileSync(keybindingsPath, newContent, { encoding: "utf-8" });
+    return {
+      success: true,
+      backupPath: backupPath ?? undefined
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to install keybinding: ${message}`
+    };
+  }
+}
+function removeKeybinding(keybindingsPath) {
+  try {
+    if (!existsSync10(keybindingsPath)) {
+      return { success: true };
+    }
+    const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
+    const keybindings = parseKeybindings(content);
+    if (!keybindings) {
+      return {
+        success: false,
+        error: `Could not parse ${keybindingsPath}`
+      };
+    }
+    const filtered = keybindings.filter((kb) => !(kb.key?.toLowerCase() === "shift+enter" && kb.command === "workbench.action.terminal.sendSequence" && kb.when?.includes("terminalFocus")));
+    const newContent = `${JSON.stringify(filtered, null, 2)}
+`;
+    writeFileSync(keybindingsPath, newContent, { encoding: "utf-8" });
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to remove keybinding: ${message}`
+    };
+  }
+}
+function installKeybindingForCurrentTerminal() {
+  const terminal = detectTerminalType();
+  if (!terminal) {
+    return {
+      success: false,
+      error: "Not running in a VS Code-like terminal"
+    };
+  }
+  const path17 = getKeybindingsPath(terminal);
+  if (!path17) {
+    return {
+      success: false,
+      error: `Could not determine keybindings.json path for ${terminal}`
+    };
+  }
+  return installKeybinding(path17);
+}
+function removeKeybindingForCurrentTerminal() {
+  const terminal = detectTerminalType();
+  if (!terminal) {
+    return {
+      success: false,
+      error: "Not running in a VS Code-like terminal"
+    };
+  }
+  const path17 = getKeybindingsPath(terminal);
+  if (!path17) {
+    return {
+      success: false,
+      error: `Could not determine keybindings.json path for ${terminal}`
+    };
+  }
+  return removeKeybinding(path17);
+}
+function isWezTerm() {
+  return process.env.TERM_PROGRAM === "WezTerm";
+}
+function getWezTermConfigPath() {
+  if (process.env.WEZTERM_CONFIG_FILE) {
+    return process.env.WEZTERM_CONFIG_FILE;
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  if (xdgConfig) {
+    const xdgPath = join14(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync10(xdgPath))
+      return xdgPath;
+  }
+  const configPath = join14(homedir7(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync10(configPath))
+    return configPath;
+  return join14(homedir7(), ".wezterm.lua");
+}
+function wezTermDeleteFixExists(configPath) {
+  if (!existsSync10(configPath))
+    return false;
+  try {
+    const content = readFileSync3(configPath, { encoding: "utf-8" });
+    return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
+  } catch {
+    return false;
+  }
+}
+function installWezTermDeleteFix() {
+  const configPath = getWezTermConfigPath();
+  try {
+    if (wezTermDeleteFixExists(configPath)) {
+      return { success: true, alreadyExists: true };
+    }
+    let content = "";
+    let backupPath = null;
+    if (existsSync10(configPath)) {
+      backupPath = `${configPath}.letta-backup`;
+      copyFileSync(configPath, backupPath);
+      content = readFileSync3(configPath, { encoding: "utf-8" });
+    }
+    if (content.includes("return {") && !content.includes("local config")) {
+      content = content.replace(/return\s*\{/, "local config = {");
+      if (!content.includes("return config")) {
+        content = `${content.trimEnd()}
+
+return config
+`;
+      }
+    }
+    if (!content.trim()) {
+      content = `-- WezTerm configuration
+local config = {}
+
+return config
+`;
+    }
+    if (content.includes("return config")) {
+      content = content.replace("return config", `${WEZTERM_DELETE_FIX}
+return config`);
+    } else {
+      content = `${content.trimEnd()}
+${WEZTERM_DELETE_FIX}
+`;
+    }
+    const parentDir = dirname9(configPath);
+    if (!existsSync10(parentDir)) {
+      mkdirSync3(parentDir, { recursive: true });
+    }
+    writeFileSync(configPath, content, { encoding: "utf-8" });
+    return {
+      success: true,
+      backupPath: backupPath ?? undefined
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to install WezTerm Delete key fix: ${message}`
+    };
+  }
+}
+var SHIFT_ENTER_KEYBINDING, WEZTERM_DELETE_FIX = `
+-- Letta Code: Fix Delete key sending wrong sequence with kitty keyboard protocol
+-- See: https://github.com/wez/wezterm/issues/3758
+local wezterm = require 'wezterm'
+local keys = config.keys or {}
+table.insert(keys, {
+  key = 'Delete',
+  mods = 'NONE',
+  action = wezterm.action.SendString '\\x1b[3~',
+})
+config.keys = keys
+`;
+var init_terminalKeybindingInstaller = __esm(() => {
+  SHIFT_ENTER_KEYBINDING = {
+    key: "shift+enter",
+    command: "workbench.action.terminal.sendSequence",
+    args: { text: "\x1B\r" },
+    when: "terminalFocus"
+  };
+});
+
 // src/cli/commands/registry.ts
 var exports_registry = {};
 __export(exports_registry, {
@@ -56901,6 +57486,51 @@ var init_registry = __esm(() => {
         return "Opening help...";
       }
     },
+    "/terminal": {
+      desc: "Setup terminal shortcuts [--revert]",
+      order: 36,
+      handler: async (args) => {
+        const {
+          detectTerminalType: detectTerminalType2,
+          getKeybindingsPath: getKeybindingsPath2,
+          installKeybinding: installKeybinding2,
+          removeKeybinding: removeKeybinding2
+        } = await Promise.resolve().then(() => (init_terminalKeybindingInstaller(), exports_terminalKeybindingInstaller));
+        const { updateSettings: updateSettings2 } = await Promise.resolve().then(() => (init_settings(), exports_settings));
+        const isRevert = args.includes("--revert") || args.includes("--remove");
+        const terminal = detectTerminalType2();
+        if (!terminal) {
+          return "Not running in a VS Code-like terminal. Shift+Enter keybinding is not needed.";
+        }
+        const terminalName = {
+          vscode: "VS Code",
+          cursor: "Cursor",
+          windsurf: "Windsurf"
+        }[terminal];
+        const keybindingsPath = getKeybindingsPath2(terminal);
+        if (!keybindingsPath) {
+          return `Could not determine keybindings.json path for ${terminalName}`;
+        }
+        if (isRevert) {
+          const result2 = removeKeybinding2(keybindingsPath);
+          if (!result2.success) {
+            return `Failed to remove keybinding: ${result2.error}`;
+          }
+          await updateSettings2({ shiftEnterKeybindingInstalled: false });
+          return `Removed Shift+Enter keybinding from ${terminalName}`;
+        }
+        const result = installKeybinding2(keybindingsPath);
+        if (!result.success) {
+          return `Failed to install keybinding: ${result.error}`;
+        }
+        if (result.alreadyExists) {
+          return `Shift+Enter keybinding already exists in ${terminalName}`;
+        }
+        await updateSettings2({ shiftEnterKeybindingInstalled: true });
+        return `Installed Shift+Enter keybinding for ${terminalName}
+Location: ${keybindingsPath}`;
+      }
+    },
     "/connect": {
       desc: "Connect an existing Claude account (/connect claude)",
       order: 40,
@@ -56986,9 +57616,9 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 import { readdir as readdir7, readFile as readFile8 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname9, join as join14 } from "node:path";
+import { basename as basename3, dirname as dirname10, join as join15 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -56999,7 +57629,7 @@ async function getCustomCommands() {
 function refreshCustomCommands() {
   cachedCommands = null;
 }
-async function discoverCustomCommands(projectPath = join14(process.cwd(), COMMANDS_DIR)) {
+async function discoverCustomCommands(projectPath = join15(process.cwd(), COMMANDS_DIR)) {
   const commandsById = new Map;
   const userCommands = await discoverFromDirectory(GLOBAL_COMMANDS_DIR, "user");
   for (const cmd of userCommands) {
@@ -57020,7 +57650,7 @@ async function discoverCustomCommands(projectPath = join14(process.cwd(), COMMAN
   return result;
 }
 async function discoverFromDirectory(dirPath, source) {
-  if (!existsSync10(dirPath)) {
+  if (!existsSync11(dirPath)) {
     return [];
   }
   const commands2 = [];
@@ -57031,7 +57661,7 @@ async function findCommandFiles(currentPath, rootPath, commands2, source) {
   try {
     const entries = await readdir7(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join14(currentPath, entry.name);
+      const fullPath = join15(currentPath, entry.name);
       if (entry.isDirectory()) {
         await findCommandFiles(fullPath, rootPath, commands2, source);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -57049,7 +57679,7 @@ async function parseCommandFile(filePath, rootPath, source) {
   const content = await readFile8(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const id = basename3(filePath, ".md");
-  const relativePath = dirname9(filePath).slice(rootPath.length);
+  const relativePath = dirname10(filePath).slice(rootPath.length);
   const namespace = relativePath.replace(/^[/\\]/, "") || undefined;
   let description = getStringField(frontmatter, "description");
   if (!description) {
@@ -57116,7 +57746,7 @@ async function findCustomCommand(commandName) {
 }
 var COMMANDS_DIR = ".commands", GLOBAL_COMMANDS_DIR, cachedCommands = null;
 var init_custom = __esm(() => {
-  GLOBAL_COMMANDS_DIR = join14(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
+  GLOBAL_COMMANDS_DIR = join15(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
 });
 
 // src/cli/components/HelpDialog.tsx
@@ -57155,6 +57785,8 @@ function HelpDialog({ onClose }) {
       { keys: "Tab", description: "Autocomplete command or file path" },
       { keys: "↓", description: "Navigate down / next command in history" },
       { keys: "↑", description: "Navigate up / previous command in history" },
+      { keys: "Shift+Enter", description: "Insert newline (multi-line input)" },
+      { keys: "Opt+Enter", description: "Insert newline (alternative)" },
       {
         keys: "Ctrl+C",
         description: "Interrupt operation / exit (double press)"
@@ -60354,7 +60986,7 @@ var init_AgentInfoBar = __esm(async () => {
 
 // src/cli/helpers/fileSearch.ts
 import { readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import { join as join15, resolve as resolve17 } from "node:path";
+import { join as join16, resolve as resolve17 } from "node:path";
 function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = []) {
   if (results.length >= maxResults) {
     return results;
@@ -60366,7 +60998,7 @@ function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = [])
         continue;
       }
       try {
-        const fullPath = join15(dir, entry);
+        const fullPath = join16(dir, entry);
         const stats = statSync2(fullPath);
         const relativePath = fullPath.startsWith(process.cwd()) ? fullPath.slice(process.cwd().length + 1) : fullPath;
         const matches = pattern.length === 0 || relativePath.toLowerCase().includes(pattern.toLowerCase());
@@ -60418,7 +61050,7 @@ async function searchFiles(query, deep = false) {
       const matchingEntries = searchPattern.length === 0 ? entries : entries.filter((entry) => entry.toLowerCase().includes(searchPattern.toLowerCase()));
       for (const entry of matchingEntries.slice(0, 50)) {
         try {
-          const fullPath = join15(searchDir, entry);
+          const fullPath = join16(searchDir, entry);
           const stats = statSync2(fullPath);
           const relativePath = fullPath.startsWith(process.cwd()) ? fullPath.slice(process.cwd().length + 1) : fullPath;
           results.push({
@@ -68297,7 +68929,7 @@ __export(exports_sessionContext, {
   buildSessionContext: () => buildSessionContext
 });
 import { execSync } from "node:child_process";
-import { platform as platform3 } from "node:os";
+import { platform as platform4 } from "node:os";
 function getLocalTime() {
   const now = new Date;
   return now.toLocaleString(undefined, {
@@ -68311,7 +68943,7 @@ function getLocalTime() {
   });
 }
 function getDeviceType() {
-  const p = platform3();
+  const p = platform4();
   switch (p) {
     case "darwin":
       return "macOS";
@@ -68434,7 +69066,7 @@ ${gitInfo.status}
       context3 += `- **Git repository**: No
 `;
     }
-    if (platform3() === "win32") {
+    if (platform4() === "win32") {
       context3 += `
 ## Windows Shell Notes
 - The Bash tool uses PowerShell or cmd.exe on Windows
@@ -68466,7 +69098,7 @@ var exports_App = {};
 __export(exports_App, {
   default: () => App2
 });
-import { existsSync as existsSync11, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
 function uid4(prefix) {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -68547,18 +69179,18 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 }
 function planFileExists() {
   const planFilePath = permissionMode2.getPlanFilePath();
-  return !!planFilePath && existsSync11(planFilePath);
+  return !!planFilePath && existsSync12(planFilePath);
 }
 function readPlanFile() {
   const planFilePath = permissionMode2.getPlanFilePath();
   if (!planFilePath) {
     return "No plan file path set.";
   }
-  if (!existsSync11(planFilePath)) {
+  if (!existsSync12(planFilePath)) {
     return `Plan file not found at ${planFilePath}`;
   }
   try {
-    return readFileSync3(planFilePath, "utf-8");
+    return readFileSync4(planFilePath, "utf-8");
   } catch {
     return `Failed to read plan file at ${planFilePath}`;
   }
@@ -70427,7 +71059,7 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
           const client = await getClient2();
           const fileContent = await client.agents.exportFile(agentId);
           const fileName = `${agentId}.af`;
-          writeFileSync(fileName, JSON.stringify(fileContent, null, 2));
+          writeFileSync2(fileName, JSON.stringify(fileContent, null, 2));
           buffersRef.current.byId.set(cmdId2, {
             kind: "command",
             id: cmdId2,
@@ -72282,6 +72914,414 @@ var init_App2 = __esm(async () => {
   jsx_dev_runtime50 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
+// src/cli/utils/terminalKeybindingInstaller.ts
+var exports_terminalKeybindingInstaller2 = {};
+__export(exports_terminalKeybindingInstaller2, {
+  wezTermDeleteFixExists: () => wezTermDeleteFixExists2,
+  removeKeybindingForCurrentTerminal: () => removeKeybindingForCurrentTerminal2,
+  removeKeybinding: () => removeKeybinding2,
+  keybindingExists: () => keybindingExists2,
+  isWezTerm: () => isWezTerm2,
+  isVSCodeLikeTerminal: () => isVSCodeLikeTerminal2,
+  installWezTermDeleteFix: () => installWezTermDeleteFix2,
+  installKeybindingForCurrentTerminal: () => installKeybindingForCurrentTerminal2,
+  installKeybinding: () => installKeybinding2,
+  getWezTermConfigPath: () => getWezTermConfigPath2,
+  getKeybindingsPath: () => getKeybindingsPath2,
+  detectTerminalType: () => detectTerminalType2
+});
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { homedir as homedir8, platform as platform5 } from "node:os";
+import { dirname as dirname11, join as join17 } from "node:path";
+function detectTerminalType2() {
+  if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
+    return "cursor";
+  }
+  if (process.env.WINDSURF_TRACE_ID || process.env.WINDSURF_CHANNEL) {
+    return "windsurf";
+  }
+  const termProgram = process.env.TERM_PROGRAM?.toLowerCase();
+  if (termProgram === "vscode")
+    return "vscode";
+  if (termProgram === "cursor")
+    return "cursor";
+  if (termProgram === "windsurf")
+    return "windsurf";
+  if (process.env.VSCODE_INJECTION === "1")
+    return "vscode";
+  return null;
+}
+function isVSCodeLikeTerminal2() {
+  return detectTerminalType2() !== null;
+}
+function getKeybindingsPath2(terminal) {
+  if (!terminal)
+    return null;
+  const appName = {
+    vscode: "Code",
+    cursor: "Cursor",
+    windsurf: "Windsurf"
+  }[terminal];
+  const os4 = platform5();
+  if (os4 === "darwin") {
+    return join17(homedir8(), "Library", "Application Support", appName, "User", "keybindings.json");
+  }
+  if (os4 === "win32") {
+    const appData = process.env.APPDATA;
+    if (!appData)
+      return null;
+    return join17(appData, appName, "User", "keybindings.json");
+  }
+  if (os4 === "linux") {
+    return join17(homedir8(), ".config", appName, "User", "keybindings.json");
+  }
+  return null;
+}
+function stripJsonComments2(jsonc) {
+  let result = jsonc.replace(/\/\/.*$/gm, "");
+  result = result.replace(/\/\*[\s\S]*?\*\//g, "");
+  result = result.replace(/,(\s*[}\]])/g, "$1");
+  return result;
+}
+function parseKeybindings2(content) {
+  try {
+    const stripped = stripJsonComments2(content);
+    const parsed = JSON.parse(stripped);
+    if (!Array.isArray(parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function keybindingExists2(keybindingsPath) {
+  if (!existsSync13(keybindingsPath))
+    return false;
+  try {
+    const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
+    const keybindings = parseKeybindings2(content);
+    if (!keybindings)
+      return false;
+    return keybindings.some((kb) => kb.key?.toLowerCase() === "shift+enter" && kb.command === "workbench.action.terminal.sendSequence" && kb.when?.includes("terminalFocus"));
+  } catch {
+    return false;
+  }
+}
+function createBackup2(keybindingsPath) {
+  if (!existsSync13(keybindingsPath))
+    return null;
+  const backupPath = `${keybindingsPath}.letta-backup`;
+  try {
+    copyFileSync2(keybindingsPath, backupPath);
+    return backupPath;
+  } catch {
+    return null;
+  }
+}
+function installKeybinding2(keybindingsPath) {
+  try {
+    if (keybindingExists2(keybindingsPath)) {
+      return { success: true, alreadyExists: true };
+    }
+    const parentDir = dirname11(keybindingsPath);
+    if (!existsSync13(parentDir)) {
+      mkdirSync4(parentDir, { recursive: true });
+    }
+    let keybindings = [];
+    let backupPath = null;
+    if (existsSync13(keybindingsPath)) {
+      backupPath = createBackup2(keybindingsPath);
+      const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
+      const parsed = parseKeybindings2(content);
+      if (parsed === null) {
+        return {
+          success: false,
+          error: `Could not parse ${keybindingsPath}. Please fix syntax errors and try again.`
+        };
+      }
+      keybindings = parsed;
+    }
+    keybindings.push(SHIFT_ENTER_KEYBINDING2);
+    const newContent = `${JSON.stringify(keybindings, null, 2)}
+`;
+    writeFileSync3(keybindingsPath, newContent, { encoding: "utf-8" });
+    return {
+      success: true,
+      backupPath: backupPath ?? undefined
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to install keybinding: ${message}`
+    };
+  }
+}
+function removeKeybinding2(keybindingsPath) {
+  try {
+    if (!existsSync13(keybindingsPath)) {
+      return { success: true };
+    }
+    const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
+    const keybindings = parseKeybindings2(content);
+    if (!keybindings) {
+      return {
+        success: false,
+        error: `Could not parse ${keybindingsPath}`
+      };
+    }
+    const filtered = keybindings.filter((kb) => !(kb.key?.toLowerCase() === "shift+enter" && kb.command === "workbench.action.terminal.sendSequence" && kb.when?.includes("terminalFocus")));
+    const newContent = `${JSON.stringify(filtered, null, 2)}
+`;
+    writeFileSync3(keybindingsPath, newContent, { encoding: "utf-8" });
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to remove keybinding: ${message}`
+    };
+  }
+}
+function installKeybindingForCurrentTerminal2() {
+  const terminal = detectTerminalType2();
+  if (!terminal) {
+    return {
+      success: false,
+      error: "Not running in a VS Code-like terminal"
+    };
+  }
+  const path17 = getKeybindingsPath2(terminal);
+  if (!path17) {
+    return {
+      success: false,
+      error: `Could not determine keybindings.json path for ${terminal}`
+    };
+  }
+  return installKeybinding2(path17);
+}
+function removeKeybindingForCurrentTerminal2() {
+  const terminal = detectTerminalType2();
+  if (!terminal) {
+    return {
+      success: false,
+      error: "Not running in a VS Code-like terminal"
+    };
+  }
+  const path17 = getKeybindingsPath2(terminal);
+  if (!path17) {
+    return {
+      success: false,
+      error: `Could not determine keybindings.json path for ${terminal}`
+    };
+  }
+  return removeKeybinding2(path17);
+}
+function isWezTerm2() {
+  return process.env.TERM_PROGRAM === "WezTerm";
+}
+function getWezTermConfigPath2() {
+  if (process.env.WEZTERM_CONFIG_FILE) {
+    return process.env.WEZTERM_CONFIG_FILE;
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  if (xdgConfig) {
+    const xdgPath = join17(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync13(xdgPath))
+      return xdgPath;
+  }
+  const configPath = join17(homedir8(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync13(configPath))
+    return configPath;
+  return join17(homedir8(), ".wezterm.lua");
+}
+function wezTermDeleteFixExists2(configPath) {
+  if (!existsSync13(configPath))
+    return false;
+  try {
+    const content = readFileSync5(configPath, { encoding: "utf-8" });
+    return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
+  } catch {
+    return false;
+  }
+}
+function installWezTermDeleteFix2() {
+  const configPath = getWezTermConfigPath2();
+  try {
+    if (wezTermDeleteFixExists2(configPath)) {
+      return { success: true, alreadyExists: true };
+    }
+    let content = "";
+    let backupPath = null;
+    if (existsSync13(configPath)) {
+      backupPath = `${configPath}.letta-backup`;
+      copyFileSync2(configPath, backupPath);
+      content = readFileSync5(configPath, { encoding: "utf-8" });
+    }
+    if (content.includes("return {") && !content.includes("local config")) {
+      content = content.replace(/return\s*\{/, "local config = {");
+      if (!content.includes("return config")) {
+        content = `${content.trimEnd()}
+
+return config
+`;
+      }
+    }
+    if (!content.trim()) {
+      content = `-- WezTerm configuration
+local config = {}
+
+return config
+`;
+    }
+    if (content.includes("return config")) {
+      content = content.replace("return config", `${WEZTERM_DELETE_FIX2}
+return config`);
+    } else {
+      content = `${content.trimEnd()}
+${WEZTERM_DELETE_FIX2}
+`;
+    }
+    const parentDir = dirname11(configPath);
+    if (!existsSync13(parentDir)) {
+      mkdirSync4(parentDir, { recursive: true });
+    }
+    writeFileSync3(configPath, content, { encoding: "utf-8" });
+    return {
+      success: true,
+      backupPath: backupPath ?? undefined
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to install WezTerm Delete key fix: ${message}`
+    };
+  }
+}
+var SHIFT_ENTER_KEYBINDING2, WEZTERM_DELETE_FIX2 = `
+-- Letta Code: Fix Delete key sending wrong sequence with kitty keyboard protocol
+-- See: https://github.com/wez/wezterm/issues/3758
+local wezterm = require 'wezterm'
+local keys = config.keys or {}
+table.insert(keys, {
+  key = 'Delete',
+  mods = 'NONE',
+  action = wezterm.action.SendString '\\x1b[3~',
+})
+config.keys = keys
+`;
+var init_terminalKeybindingInstaller2 = __esm(() => {
+  SHIFT_ENTER_KEYBINDING2 = {
+    key: "shift+enter",
+    command: "workbench.action.terminal.sendSequence",
+    args: { text: "\x1B\r" },
+    when: "terminalFocus"
+  };
+});
+
+// src/settings.ts
+var exports_settings2 = {};
+__export(exports_settings2, {
+  updateSettings: () => updateSettings2,
+  updateProjectSettings: () => updateProjectSettings2,
+  saveSettings: () => saveSettings2,
+  saveProjectSettings: () => saveProjectSettings2,
+  loadSettings: () => loadSettings2,
+  loadProjectSettings: () => loadProjectSettings2,
+  getSetting: () => getSetting2
+});
+import { homedir as homedir9 } from "node:os";
+import { join as join18 } from "node:path";
+function getSettingsPath2() {
+  return join18(homedir9(), ".letta", "settings.json");
+}
+async function loadSettings2() {
+  const settingsPath = getSettingsPath2();
+  try {
+    if (!exists(settingsPath)) {
+      await saveSettings2(DEFAULT_SETTINGS4);
+      return DEFAULT_SETTINGS4;
+    }
+    const content = await readFile(settingsPath);
+    const settings = JSON.parse(content);
+    return { ...DEFAULT_SETTINGS4, ...settings };
+  } catch (error) {
+    console.error("Error loading settings, using defaults:", error);
+    return DEFAULT_SETTINGS4;
+  }
+}
+async function saveSettings2(settings) {
+  const settingsPath = getSettingsPath2();
+  try {
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  } catch (error) {
+    console.error("Error saving settings:", error);
+    throw error;
+  }
+}
+async function updateSettings2(updates) {
+  const currentSettings = await loadSettings2();
+  const newSettings = { ...currentSettings, ...updates };
+  await saveSettings2(newSettings);
+  return newSettings;
+}
+async function getSetting2(key) {
+  const settings = await loadSettings2();
+  return settings[key];
+}
+function getProjectSettingsPath2() {
+  return join18(process.cwd(), ".letta", "settings.local.json");
+}
+async function loadProjectSettings2() {
+  const settingsPath = getProjectSettingsPath2();
+  try {
+    if (!exists(settingsPath)) {
+      return null;
+    }
+    const content = await readFile(settingsPath);
+    const settings = JSON.parse(content);
+    return settings;
+  } catch (error) {
+    console.error("Error loading project settings:", error);
+    return null;
+  }
+}
+async function saveProjectSettings2(settings) {
+  const settingsPath = getProjectSettingsPath2();
+  const dirPath = join18(process.cwd(), ".letta");
+  try {
+    if (!exists(dirPath)) {
+      await mkdir(dirPath, { recursive: true });
+    }
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  } catch (error) {
+    console.error("Error saving project settings:", error);
+    throw error;
+  }
+}
+async function updateProjectSettings2(updates) {
+  const currentSettings = await loadProjectSettings2() || { lastAgent: null };
+  const newSettings = { ...currentSettings, ...updates };
+  await saveProjectSettings2(newSettings);
+  return newSettings;
+}
+var DEFAULT_SETTINGS4;
+var init_settings2 = __esm(() => {
+  init_fs();
+  DEFAULT_SETTINGS4 = {
+    lastAgent: null,
+    tokenStreaming: false,
+    globalSharedBlockIds: {}
+  };
+});
+
 // src/tools/toolset.ts
 var exports_toolset2 = {};
 __export(exports_toolset2, {
@@ -72685,7 +73725,7 @@ var exports_create = {};
 __export(exports_create, {
   createAgent: () => createAgent2
 });
-import { join as join16 } from "node:path";
+import { join as join19 } from "node:path";
 async function createAgent2(name = DEFAULT_AGENT_NAME, model, embeddingModel = "openai/text-embedding-3-small", updateArgs, skillsDirectory, parallelToolCalls = true, enableSleeptime = false, systemPromptId, initBlocks, baseTools) {
   let modelHandle;
   if (model) {
@@ -72737,7 +73777,7 @@ async function createAgent2(name = DEFAULT_AGENT_NAME, model, embeddingModel = "
     }
   }
   const filteredMemoryBlocks = allowedBlockLabels && allowedBlockLabels.size > 0 ? defaultMemoryBlocks.filter((b) => allowedBlockLabels.has(b.label)) : defaultMemoryBlocks;
-  const resolvedSkillsDirectory = skillsDirectory || join16(process.cwd(), SKILLS_DIR);
+  const resolvedSkillsDirectory = skillsDirectory || join19(process.cwd(), SKILLS_DIR);
   try {
     const { skills, errors } = await discoverSkills(resolvedSkillsDirectory);
     if (errors.length > 0) {
@@ -74213,12 +75253,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join17 } = await import("path");
+  const { join: join20 } = await import("path");
   const { getVersion: getVersion3 } = await Promise.resolve().then(() => (init_version2(), exports_version));
   const { SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills3(), exports_skills2));
   const { exists: exists3 } = await Promise.resolve().then(() => (init_fs2(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join17(cwd2, SKILLS_DIR3);
+  const skillsDir = join20(cwd2, SKILLS_DIR3);
   const skillsExist = exists3(skillsDir);
   await settingsManager2.loadLocalProjectSettings(cwd2);
   const localPinned = settingsManager2.getLocalPinnedAgents(cwd2);
@@ -74444,9 +75484,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       process.exit(1);
     }
     const { resolve: resolve19 } = await import("path");
-    const { existsSync: existsSync12 } = await import("fs");
+    const { existsSync: existsSync14 } = await import("fs");
     const resolvedPath = resolve19(fromAfFile);
-    if (!existsSync12(resolvedPath)) {
+    if (!existsSync14(resolvedPath)) {
       console.error(`Error: AgentFile not found: ${resolvedPath}`);
       process.exit(1);
     }
@@ -74549,6 +75589,10 @@ Error: ${message}`);
     await handleHeadlessCommand2(process.argv, specifiedModel, skillsDirectory);
     return;
   }
+  try {
+    const { detectAndEnableKittyProtocol: detectAndEnableKittyProtocol2 } = await Promise.resolve().then(() => (init_kittyProtocolDetector(), exports_kittyProtocolDetector));
+    await detectAndEnableKittyProtocol2();
+  } catch {}
   const React14 = await Promise.resolve().then(() => __toESM(require_react2(), 1));
   const { render: render2 } = await init_build3().then(() => exports_build);
   const { useState: useState35, useEffect: useEffect26 } = React14;
@@ -74566,6 +75610,7 @@ Error: ${message}`);
     skillsDirectory: skillsDirectory2,
     fromAfFile: fromAfFile2
   }) {
+    const [showKeybindingSetup, setShowKeybindingSetup] = useState35(null);
     const [loadingState, setLoadingState] = useState35("selecting");
     const [agentId, setAgentId] = useState35(null);
     const [agentState, setAgentState] = useState35(null);
@@ -74573,6 +75618,63 @@ Error: ${message}`);
     const [isResumingSession, setIsResumingSession] = useState35(false);
     const [agentProvenance, setAgentProvenance] = useState35(null);
     const [selectedGlobalAgentId, setSelectedGlobalAgentId] = useState35(null);
+    useEffect26(() => {
+      async function autoInstallKeybinding() {
+        const {
+          detectTerminalType: detectTerminalType3,
+          getKeybindingsPath: getKeybindingsPath3,
+          keybindingExists: keybindingExists3,
+          installKeybinding: installKeybinding3
+        } = await Promise.resolve().then(() => (init_terminalKeybindingInstaller2(), exports_terminalKeybindingInstaller2));
+        const { loadSettings: loadSettings3, updateSettings: updateSettings3 } = await Promise.resolve().then(() => (init_settings2(), exports_settings2));
+        const terminal = detectTerminalType3();
+        if (!terminal) {
+          setShowKeybindingSetup(false);
+          return;
+        }
+        const settings2 = await loadSettings3();
+        const keybindingsPath = getKeybindingsPath3(terminal);
+        if (!keybindingsPath || settings2.shiftEnterKeybindingInstalled) {
+          setShowKeybindingSetup(false);
+          return;
+        }
+        if (keybindingExists3(keybindingsPath)) {
+          await updateSettings3({ shiftEnterKeybindingInstalled: true });
+          setShowKeybindingSetup(false);
+          return;
+        }
+        const result = installKeybinding3(keybindingsPath);
+        if (result.success) {
+          await updateSettings3({ shiftEnterKeybindingInstalled: true });
+        }
+        setShowKeybindingSetup(false);
+      }
+      async function autoInstallWezTermFix() {
+        const {
+          isWezTerm: isWezTerm3,
+          wezTermDeleteFixExists: wezTermDeleteFixExists3,
+          getWezTermConfigPath: getWezTermConfigPath3,
+          installWezTermDeleteFix: installWezTermDeleteFix3
+        } = await Promise.resolve().then(() => (init_terminalKeybindingInstaller2(), exports_terminalKeybindingInstaller2));
+        const { loadSettings: loadSettings3, updateSettings: updateSettings3 } = await Promise.resolve().then(() => (init_settings2(), exports_settings2));
+        if (!isWezTerm3())
+          return;
+        const settings2 = await loadSettings3();
+        if (settings2.wezTermDeleteFixInstalled)
+          return;
+        const configPath = getWezTermConfigPath3();
+        if (wezTermDeleteFixExists3(configPath)) {
+          await updateSettings3({ wezTermDeleteFixInstalled: true });
+          return;
+        }
+        const result = installWezTermDeleteFix3();
+        if (result.success) {
+          await updateSettings3({ wezTermDeleteFixInstalled: true });
+        }
+      }
+      autoInstallKeybinding();
+      autoInstallWezTermFix();
+    }, []);
     useEffect26(() => {
       async function checkAndStart() {
         await settingsManager2.loadLocalProjectSettings();
@@ -74757,8 +75859,8 @@ Error: ${message}`);
         await initializeLoadedSkillsFlag();
         try {
           const { discoverSkills: discoverSkills3, formatSkillsForMemory: formatSkillsForMemory3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills3(), exports_skills2));
-          const { join: join17 } = await import("path");
-          const resolvedSkillsDirectory = skillsDirectory2 || join17(process.cwd(), SKILLS_DIR3);
+          const { join: join20 } = await import("path");
+          const resolvedSkillsDirectory = skillsDirectory2 || join20(process.cwd(), SKILLS_DIR3);
           const { skills, errors } = await discoverSkills3(resolvedSkillsDirectory);
           if (errors.length > 0) {
             console.warn("Errors encountered during skill discovery:");
@@ -74835,6 +75937,9 @@ Error during initialization: ${message}`);
       loadingState,
       selectedGlobalAgentId
     ]);
+    if (showKeybindingSetup === null) {
+      return null;
+    }
     if (loadingState === "selecting") {
       return null;
     }
@@ -74897,4 +76002,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=8134ECE87ABE785364756E2164756E21
+//# debugId=F52C27FCEB893D3264756E2164756E21