@zyycn/claudex 1.0.3-fork.63859d8

package/dist/chunk-fbpftpf0.js

@@ -0,0 +1,69 @@
+// @bun
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-3vs3nm7w.js";
+import {
+  execa,
+  init_execa
+} from "./chunk-gzzfhtdv.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/which.ts
+async function whichNodeAsync(command) {
+  if (process.platform === "win32") {
+    const result2 = await execa(`where.exe ${command}`, {
+      shell: true,
+      stderr: "ignore",
+      reject: false
+    });
+    if (result2.exitCode !== 0 || !result2.stdout) {
+      return null;
+    }
+    return result2.stdout.trim().split(/\r?\n/)[0] || null;
+  }
+  const result = await execa(`which ${command}`, {
+    shell: true,
+    stderr: "ignore",
+    reject: false
+  });
+  if (result.exitCode !== 0 || !result.stdout) {
+    return null;
+  }
+  return result.stdout.trim();
+}
+function whichNodeSync(command) {
+  if (process.platform === "win32") {
+    try {
+      const result = execSync_DEPRECATED(`where.exe ${command}`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      const output = result.toString().trim();
+      return output.split(/\r?\n/)[0] || null;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const result = execSync_DEPRECATED(`which ${command}`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return result.toString().trim() || null;
+  } catch {
+    return null;
+  }
+}
+var bunWhich, which, whichSync;
+var init_which = __esm(() => {
+  init_execa();
+  init_execSyncWrapper();
+  bunWhich = typeof Bun !== "undefined" && typeof Bun.which === "function" ? Bun.which : null;
+  which = bunWhich ? async (command) => bunWhich(command) : whichNodeAsync;
+  whichSync = bunWhich ?? whichNodeSync;
+});
+
+export { which, whichSync, init_which };

package/dist/chunk-fbv4apne.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/process.ts
+function handleEPIPE(stream) {
+  return (err) => {
+    if (err.code === "EPIPE") {
+      stream.destroy();
+    }
+  };
+}
+function registerProcessOutputErrorHandlers() {
+  process.stdout.on("error", handleEPIPE(process.stdout));
+  process.stderr.on("error", handleEPIPE(process.stderr));
+}
+function writeOut(stream, data) {
+  if (stream.destroyed) {
+    return;
+  }
+  stream.write(data);
+}
+function writeToStdout(data) {
+  writeOut(process.stdout, data);
+}
+function writeToStderr(data) {
+  writeOut(process.stderr, data);
+}
+function exitWithError(message) {
+  console.error(message);
+  process.exit(1);
+}
+function peekForStdinData(stream, ms) {
+  return new Promise((resolve) => {
+    const done = (timedOut) => {
+      clearTimeout(peek);
+      stream.off("end", onEnd);
+      stream.off("data", onFirstData);
+      resolve(timedOut);
+    };
+    const onEnd = () => done(false);
+    const onFirstData = () => clearTimeout(peek);
+    const peek = setTimeout(done, ms, true);
+    stream.once("end", onEnd);
+    stream.once("data", onFirstData);
+  });
+}
+var init_process = () => {};
+
+export { registerProcessOutputErrorHandlers, writeToStdout, writeToStderr, exitWithError, peekForStdinData, init_process };

package/dist/chunk-fe28tydf.js

@@ -0,0 +1,87 @@
+// @bun
+import {
+  createDisabledBypassPermissionsContext,
+  init_AppState,
+  init_permissionSetup,
+  shouldDisableBypassPermissions,
+  useAppState,
+  useAppStateStore,
+  useSetAppState
+} from "./chunk-2ssrm349.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  getIsRemoteMode,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/permissions/bypassPermissionsKillswitch.ts
+async function checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState) {
+  if (bypassPermissionsCheckRan) {
+    return;
+  }
+  bypassPermissionsCheckRan = true;
+  if (!toolPermissionContext.isBypassPermissionsModeAvailable) {
+    return;
+  }
+  const shouldDisable = await shouldDisableBypassPermissions();
+  if (!shouldDisable) {
+    return;
+  }
+  setAppState((prev) => {
+    return {
+      ...prev,
+      toolPermissionContext: createDisabledBypassPermissionsContext(prev.toolPermissionContext)
+    };
+  });
+}
+function resetBypassPermissionsCheck() {
+  bypassPermissionsCheckRan = false;
+}
+function useKickOffCheckAndDisableBypassPermissionsIfNeeded() {
+  const toolPermissionContext = useAppState((s) => s.toolPermissionContext);
+  const setAppState = useSetAppState();
+  import_react.useEffect(() => {
+    if (getIsRemoteMode())
+      return;
+    checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState);
+  }, []);
+}
+async function checkAndDisableAutoModeIfNeeded(toolPermissionContext, setAppState, fastMode) {
+  if (false) {}
+}
+function resetAutoModeGateCheck() {
+  autoModeCheckRan = false;
+}
+function useKickOffCheckAndDisableAutoModeIfNeeded() {
+  const mainLoopModel = useAppState((s) => s.mainLoopModel);
+  const mainLoopModelForSession = useAppState((s) => s.mainLoopModelForSession);
+  const fastMode = useAppState((s) => s.fastMode);
+  const setAppState = useSetAppState();
+  const store = useAppStateStore();
+  const isFirstRunRef = import_react.useRef(true);
+  import_react.useEffect(() => {
+    if (getIsRemoteMode())
+      return;
+    if (isFirstRunRef.current) {
+      isFirstRunRef.current = false;
+    } else {
+      resetAutoModeGateCheck();
+    }
+    checkAndDisableAutoModeIfNeeded(store.getState().toolPermissionContext, setAppState, fastMode);
+  }, [mainLoopModel, mainLoopModelForSession, fastMode]);
+}
+var import_react, bypassPermissionsCheckRan = false, autoModeCheckRan = false;
+var init_bypassPermissionsKillswitch = __esm(() => {
+  init_AppState();
+  init_state();
+  init_permissionSetup();
+  import_react = __toESM(require_react(), 1);
+});
+
+export { checkAndDisableBypassPermissionsIfNeeded, resetBypassPermissionsCheck, useKickOffCheckAndDisableBypassPermissionsIfNeeded, useKickOffCheckAndDisableAutoModeIfNeeded, init_bypassPermissionsKillswitch };

package/dist/chunk-fhf695ja.js

@@ -0,0 +1,229 @@
+// @bun
+import {
+  getStoredChangelogFromMemory,
+  init_releaseNotes,
+  parseChangelog
+} from "./chunk-kzvcbm2a.js";
+import {
+  init_sessionStorage,
+  loadMessageLogs
+} from "./chunk-2ssrm349.js";
+import {
+  gt,
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  getDisplayPath,
+  getInitialSettings,
+  getSubscriptionName,
+  init_auth,
+  init_file,
+  init_settings1 as init_settings,
+  isClaudeAISubscriber
+} from "./chunk-kh4zk8k3.js";
+import {
+  init_format,
+  init_stringWidth,
+  stringWidth,
+  truncate,
+  truncateToWidth,
+  truncateToWidthNoEllipsis
+} from "./chunk-wgcssf6v.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  getDirectConnectServerUrl,
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/logoV2Utils.ts
+function getLayoutMode(columns) {
+  if (columns >= 70)
+    return "horizontal";
+  return "compact";
+}
+function calculateLayoutDimensions(columns, layoutMode, optimalLeftWidth) {
+  if (layoutMode === "horizontal") {
+    const leftWidth = optimalLeftWidth;
+    const usedSpace = BORDER_PADDING + CONTENT_PADDING + DIVIDER_WIDTH + leftWidth;
+    const availableForRight = columns - usedSpace;
+    let rightWidth = Math.max(30, availableForRight);
+    const totalWidth2 = Math.min(leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING, columns - BORDER_PADDING);
+    if (totalWidth2 < leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING) {
+      rightWidth = totalWidth2 - leftWidth - DIVIDER_WIDTH - CONTENT_PADDING;
+    }
+    return { leftWidth, rightWidth, totalWidth: totalWidth2 };
+  }
+  const totalWidth = Math.min(columns - BORDER_PADDING, MAX_LEFT_WIDTH + 20);
+  return {
+    leftWidth: totalWidth,
+    rightWidth: totalWidth,
+    totalWidth
+  };
+}
+function calculateOptimalLeftWidth(welcomeMessage, truncatedCwd, modelLine) {
+  const contentWidth = Math.max(stringWidth(welcomeMessage), stringWidth(truncatedCwd), stringWidth(modelLine), 20);
+  return Math.min(contentWidth + 4, MAX_LEFT_WIDTH);
+}
+function formatWelcomeMessage(username) {
+  if (!username || username.length > MAX_USERNAME_LENGTH) {
+    return "Welcome back!";
+  }
+  return `Welcome back ${username}!`;
+}
+function truncatePath(path, maxLength) {
+  if (stringWidth(path) <= maxLength)
+    return path;
+  const separator = "/";
+  const ellipsis = "\u2026";
+  const ellipsisWidth = 1;
+  const separatorWidth = 1;
+  const parts = path.split(separator);
+  const first = parts[0] || "";
+  const last = parts[parts.length - 1] || "";
+  const firstWidth = stringWidth(first);
+  const lastWidth = stringWidth(last);
+  if (parts.length === 1) {
+    return truncateToWidth(path, maxLength);
+  }
+  if (first === "" && ellipsisWidth + separatorWidth + lastWidth >= maxLength) {
+    return `${separator}${truncateToWidth(last, Math.max(1, maxLength - separatorWidth))}`;
+  }
+  if (first !== "" && ellipsisWidth * 2 + separatorWidth + lastWidth >= maxLength) {
+    return `${ellipsis}${separator}${truncateToWidth(last, Math.max(1, maxLength - ellipsisWidth - separatorWidth))}`;
+  }
+  if (parts.length === 2) {
+    const availableForFirst = maxLength - ellipsisWidth - separatorWidth - lastWidth;
+    return `${truncateToWidthNoEllipsis(first, availableForFirst)}${ellipsis}${separator}${last}`;
+  }
+  let available = maxLength - firstWidth - lastWidth - ellipsisWidth - 2 * separatorWidth;
+  if (available <= 0) {
+    const availableForFirst = Math.max(0, maxLength - lastWidth - ellipsisWidth - 2 * separatorWidth);
+    const truncatedFirst = truncateToWidthNoEllipsis(first, availableForFirst);
+    return `${truncatedFirst}${separator}${ellipsis}${separator}${last}`;
+  }
+  const middleParts = [];
+  for (let i = parts.length - 2;i > 0; i--) {
+    const part = parts[i];
+    if (part && stringWidth(part) + separatorWidth <= available) {
+      middleParts.unshift(part);
+      available -= stringWidth(part) + separatorWidth;
+    } else {
+      break;
+    }
+  }
+  if (middleParts.length === 0) {
+    return `${first}${separator}${ellipsis}${separator}${last}`;
+  }
+  return `${first}${separator}${ellipsis}${separator}${middleParts.join(separator)}${separator}${last}`;
+}
+async function getRecentActivity() {
+  if (cachePromise) {
+    return cachePromise;
+  }
+  const currentSessionId = getSessionId();
+  cachePromise = loadMessageLogs(10).then((logs) => {
+    cachedActivity = logs.filter((log) => {
+      if (log.isSidechain)
+        return false;
+      if (log.sessionId === currentSessionId)
+        return false;
+      if (log.summary?.includes("I apologize"))
+        return false;
+      const hasSummary = log.summary && log.summary !== "No prompt";
+      const hasFirstPrompt = log.firstPrompt && log.firstPrompt !== "No prompt";
+      return hasSummary || hasFirstPrompt;
+    }).slice(0, 3);
+    return cachedActivity;
+  }).catch(() => {
+    cachedActivity = [];
+    return cachedActivity;
+  });
+  return cachePromise;
+}
+function getRecentActivitySync() {
+  return cachedActivity;
+}
+function getLogoDisplayData() {
+  const version = process.env.DEMO_VERSION ?? "1.0.3-fork.63859d8";
+  const serverUrl = getDirectConnectServerUrl();
+  const displayPath = process.env.DEMO_VERSION ? "/code/claude" : getDisplayPath(getCwd());
+  const cwd = serverUrl ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, "")}` : displayPath;
+  const billingType = isClaudeAISubscriber() ? getSubscriptionName() : "API Usage Billing";
+  const agentName = getInitialSettings().agent;
+  return {
+    version,
+    cwd,
+    billingType,
+    agentName
+  };
+}
+function formatModelAndBilling(modelName, billingType, availableWidth) {
+  const separator = " \xB7 ";
+  const combinedWidth = stringWidth(modelName) + separator.length + stringWidth(billingType);
+  const shouldSplit = combinedWidth > availableWidth;
+  if (shouldSplit) {
+    return {
+      shouldSplit: true,
+      truncatedModel: truncate(modelName, availableWidth),
+      truncatedBilling: truncate(billingType, availableWidth)
+    };
+  }
+  return {
+    shouldSplit: false,
+    truncatedModel: truncate(modelName, Math.max(availableWidth - stringWidth(billingType) - separator.length, 10)),
+    truncatedBilling: billingType
+  };
+}
+function getRecentReleaseNotesSync(maxItems) {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog2 = "";
+    if (changelog2) {
+      const commits = changelog2.trim().split(`
+`).filter(Boolean);
+      return commits.slice(0, maxItems);
+    }
+    return [];
+  }
+  const changelog = getStoredChangelogFromMemory();
+  if (!changelog) {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = parseChangelog(changelog);
+  } catch {
+    return [];
+  }
+  const allNotes = [];
+  const versions = Object.keys(parsed).sort((a, b) => gt(a, b) ? -1 : 1).slice(0, 3);
+  for (const version of versions) {
+    const notes = parsed[version];
+    if (notes) {
+      allNotes.push(...notes);
+    }
+  }
+  return allNotes.slice(0, maxItems);
+}
+var MAX_LEFT_WIDTH = 50, MAX_USERNAME_LENGTH = 20, BORDER_PADDING = 4, DIVIDER_WIDTH = 1, CONTENT_PADDING = 2, cachedActivity, cachePromise = null;
+var init_logoV2Utils = __esm(() => {
+  init_state();
+  init_stringWidth();
+  init_auth();
+  init_cwd();
+  init_file();
+  init_format();
+  init_releaseNotes();
+  init_semver();
+  init_sessionStorage();
+  init_settings();
+  cachedActivity = [];
+});
+
+export { getLayoutMode, calculateLayoutDimensions, calculateOptimalLeftWidth, formatWelcomeMessage, truncatePath, getRecentActivity, getRecentActivitySync, getLogoDisplayData, formatModelAndBilling, getRecentReleaseNotesSync, init_logoV2Utils };

package/dist/chunk-fht1rp3n.js

@@ -0,0 +1,266 @@
+// @bun
+import {
+  expandPastedTextRefs,
+  formatPastedTextRef,
+  generateTempFilePath,
+  getPastedTextRefNumLines,
+  init_history,
+  init_ide,
+  init_tempfile,
+  toIDEDisplayName
+} from "./chunk-2ssrm349.js";
+import {
+  init_instances,
+  instances_default
+} from "./chunk-e65m636c.js";
+import {
+  init_which,
+  whichSync
+} from "./chunk-fbpftpf0.js";
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-3vs3nm7w.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  logForDebugging,
+  writeFileSync_DEPRECATED
+} from "./chunk-sbbj6ta3.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/editor.ts
+import {
+  spawn,
+  spawnSync
+} from "child_process";
+import { basename } from "path";
+function isCommandAvailable(command) {
+  return !!whichSync(command);
+}
+function classifyGuiEditor(editor) {
+  const base = basename(editor.split(" ")[0] ?? "");
+  return GUI_EDITORS.find((g) => base.includes(g));
+}
+function guiGotoArgv(guiFamily, filePath, line) {
+  if (!line)
+    return [filePath];
+  if (VSCODE_FAMILY.has(guiFamily))
+    return ["-g", `${filePath}:${line}`];
+  if (guiFamily === "subl")
+    return [`${filePath}:${line}`];
+  return [filePath];
+}
+function openFileInExternalEditor(filePath, line) {
+  const editor = getExternalEditor();
+  if (!editor)
+    return false;
+  const parts = editor.split(" ");
+  const base = parts[0] ?? editor;
+  const editorArgs = parts.slice(1);
+  const guiFamily = classifyGuiEditor(editor);
+  if (guiFamily) {
+    const gotoArgv = guiGotoArgv(guiFamily, filePath, line);
+    const detachedOpts = { detached: true, stdio: "ignore" };
+    let child;
+    if (process.platform === "win32") {
+      const gotoStr = gotoArgv.map((a) => `"${a}"`).join(" ");
+      child = spawn(`${editor} ${gotoStr}`, { ...detachedOpts, shell: true });
+    } else {
+      child = spawn(base, [...editorArgs, ...gotoArgv], detachedOpts);
+    }
+    child.on("error", (e) => logForDebugging(`editor spawn failed: ${e}`, { level: "error" }));
+    child.unref();
+    return true;
+  }
+  const inkInstance = instances_default.get(process.stdout);
+  if (!inkInstance)
+    return false;
+  const useGotoLine = line && PLUS_N_EDITORS.test(basename(base));
+  inkInstance.enterAlternateScreen();
+  try {
+    const syncOpts = { stdio: "inherit" };
+    let result;
+    if (process.platform === "win32") {
+      const lineArg = useGotoLine ? `+${line} ` : "";
+      result = spawnSync(`${editor} ${lineArg}"${filePath}"`, {
+        ...syncOpts,
+        shell: true
+      });
+    } else {
+      const args = [
+        ...editorArgs,
+        ...useGotoLine ? [`+${line}`, filePath] : [filePath]
+      ];
+      result = spawnSync(base, args, syncOpts);
+    }
+    if (result.error) {
+      logForDebugging(`editor spawn failed: ${result.error}`, {
+        level: "error"
+      });
+      return false;
+    }
+    return true;
+  } finally {
+    inkInstance.exitAlternateScreen();
+  }
+}
+var GUI_EDITORS, PLUS_N_EDITORS, VSCODE_FAMILY, getExternalEditor;
+var init_editor = __esm(() => {
+  init_memoize();
+  init_instances();
+  init_debug();
+  init_which();
+  GUI_EDITORS = [
+    "code",
+    "cursor",
+    "windsurf",
+    "codium",
+    "subl",
+    "atom",
+    "gedit",
+    "notepad++",
+    "notepad"
+  ];
+  PLUS_N_EDITORS = /\b(vi|vim|nvim|nano|emacs|pico|micro|helix|hx)\b/;
+  VSCODE_FAMILY = new Set(["code", "cursor", "windsurf", "codium"]);
+  getExternalEditor = memoize_default(() => {
+    if (process.env.VISUAL?.trim()) {
+      return process.env.VISUAL.trim();
+    }
+    if (process.env.EDITOR?.trim()) {
+      return process.env.EDITOR.trim();
+    }
+    if (process.platform === "win32") {
+      return "start /wait notepad";
+    }
+    const editors = ["code", "vi", "nano"];
+    return editors.find((command) => isCommandAvailable(command));
+  });
+});
+
+// src/utils/promptEditor.ts
+function isGuiEditor(editor) {
+  return classifyGuiEditor(editor) !== undefined;
+}
+function editFileInEditor(filePath) {
+  const fs = getFsImplementation();
+  const inkInstance = instances_default.get(process.stdout);
+  if (!inkInstance) {
+    throw new Error("Ink instance not found - cannot pause rendering");
+  }
+  const editor = getExternalEditor();
+  if (!editor) {
+    return { content: null };
+  }
+  try {
+    fs.statSync(filePath);
+  } catch {
+    return { content: null };
+  }
+  const useAlternateScreen = !isGuiEditor(editor);
+  if (useAlternateScreen) {
+    inkInstance.enterAlternateScreen();
+  } else {
+    inkInstance.pause();
+    inkInstance.suspendStdin();
+  }
+  try {
+    const editorCommand = EDITOR_OVERRIDES[editor] ?? editor;
+    execSync_DEPRECATED(`${editorCommand} "${filePath}"`, {
+      stdio: "inherit"
+    });
+    const editedContent = fs.readFileSync(filePath, { encoding: "utf-8" });
+    return { content: editedContent };
+  } catch (err) {
+    if (typeof err === "object" && err !== null && "status" in err && typeof err.status === "number") {
+      const status = err.status;
+      if (status !== 0) {
+        const editorName = toIDEDisplayName(editor);
+        return {
+          content: null,
+          error: `${editorName} exited with code ${status}`
+        };
+      }
+    }
+    return { content: null };
+  } finally {
+    if (useAlternateScreen) {
+      inkInstance.exitAlternateScreen();
+    } else {
+      inkInstance.resumeStdin();
+      inkInstance.resume();
+    }
+  }
+}
+function recollapsePastedContent(editedPrompt, originalPrompt, pastedContents) {
+  let collapsed = editedPrompt;
+  for (const [id, content] of Object.entries(pastedContents)) {
+    if (content.type === "text") {
+      const pasteId = parseInt(id);
+      const contentStr = content.content;
+      const contentIndex = collapsed.indexOf(contentStr);
+      if (contentIndex !== -1) {
+        const numLines = getPastedTextRefNumLines(contentStr);
+        const ref = formatPastedTextRef(pasteId, numLines);
+        collapsed = collapsed.slice(0, contentIndex) + ref + collapsed.slice(contentIndex + contentStr.length);
+      }
+    }
+  }
+  return collapsed;
+}
+function editPromptInEditor(currentPrompt, pastedContents) {
+  const fs = getFsImplementation();
+  const tempFile = generateTempFilePath();
+  try {
+    const expandedPrompt = pastedContents ? expandPastedTextRefs(currentPrompt, pastedContents) : currentPrompt;
+    writeFileSync_DEPRECATED(tempFile, expandedPrompt, {
+      encoding: "utf-8",
+      flush: true
+    });
+    const result = editFileInEditor(tempFile);
+    if (result.content === null) {
+      return result;
+    }
+    let finalContent = result.content;
+    if (finalContent.endsWith(`
+`) && !finalContent.endsWith(`
+
+`)) {
+      finalContent = finalContent.slice(0, -1);
+    }
+    if (pastedContents) {
+      finalContent = recollapsePastedContent(finalContent, currentPrompt, pastedContents);
+    }
+    return { content: finalContent };
+  } finally {
+    try {
+      fs.unlinkSync(tempFile);
+    } catch {}
+  }
+}
+var EDITOR_OVERRIDES;
+var init_promptEditor = __esm(() => {
+  init_history();
+  init_instances();
+  init_editor();
+  init_execSyncWrapper();
+  init_fsOperations();
+  init_ide();
+  init_slowOperations();
+  init_tempfile();
+  EDITOR_OVERRIDES = {
+    code: "code -w",
+    subl: "subl --wait"
+  };
+});
+
+export { openFileInExternalEditor, getExternalEditor, init_editor, editFileInEditor, editPromptInEditor, init_promptEditor };