openfox 2.0.74 → 2.0.76

package/README.md

@@ -85,6 +85,8 @@ openfox provider remove   # Remove provider
 
 OpenFox supports provider plugins loaded from the `plugins` directory inside its configuration folder. Plugins can add authentication methods, transports, provider presets, and model discovery without adding provider-specific code to the OpenFox core.
 
+You can install the plugin manually or directly from the UI.
+
 Default plugin directories:
 
 - macOS: `~/Library/Application Support/openfox/plugins`
@@ -93,8 +95,9 @@ Default plugin directories:
 
 Restart OpenFox after installing or updating a plugin.
 
-To authenticate with a ChatGPT Plus or Pro account, you can install the [`openfox-chatgpt`](https://github.com/arthurlacoste/openfox-chatgpt) plugin.
-To authenticate with a Github copilot account, you can install the [`openfox-github-copilot`](https://github.com/JamesDAdams/openfox-github-copilot) plugin.
+- To authenticate with a ChatGPT Plus or Pro account, you can install the [`openfox-chatgpt`](https://github.com/arthurlacoste/openfox-chatgpt) plugin.
+- To authenticate with a Github copilot account, you can install the [`openfox-github-copilot`](https://github.com/JamesDAdams/openfox-github-copilot) plugin.
+- To authenticate with a Google Antigravity account, you can install the [`openfox-google-antigravity`](https://github.com/JamesDAdams/openfox-google-antigravity) plugin.
 
 ## Screenshots
 

package/dist/{chat-handler-ETKFIHUO.js → chat-handler-3BZ4PDL2.js}

@@ -2,39 +2,40 @@ import {
   buildRunChatTurnParams,
   finalizeTurnCompletion,
   generateSessionNameForSession
-} from "./chunk-2DCJERYX.js";
+} from "./chunk-XTK6E2QR.js";
 import {
   runChatTurn
-} from "./chunk-ZRQDCQ7R.js";
-import "./chunk-2VBETAU2.js";
+} from "./chunk-HLHGNHMV.js";
+import "./chunk-D6CI2B7B.js";
+import "./chunk-NWO6GRYE.js";
+import "./chunk-KVRSAC4Z.js";
 import "./chunk-MF3UW36X.js";
 import "./chunk-WGMJCFCE.js";
 import "./chunk-EU3WWTFH.js";
-import "./chunk-XWBNYU2L.js";
-import "./chunk-E5LLEO3C.js";
-import "./chunk-UV3EMWL4.js";
-import "./chunk-PYB2UEC3.js";
+import "./chunk-7772ENZN.js";
+import "./chunk-DH3SSBZN.js";
+import "./chunk-LXFLRM7M.js";
+import "./chunk-OBQPXUXI.js";
+import "./chunk-4QHDQP2N.js";
+import "./chunk-YMFCFMMB.js";
 import "./chunk-I72ACQ6R.js";
-import "./chunk-NWO6GRYE.js";
-import "./chunk-UN26GIQG.js";
+import "./chunk-46RORSKU.js";
 import {
   getEventStore
-} from "./chunk-6XKM25OT.js";
+} from "./chunk-NGJ5XJ7D.js";
+import "./chunk-7QXRQ5ZL.js";
 import "./chunk-DJASQ2ZB.js";
 import {
   createChatMessageMessage,
   createPhaseChangedMessage,
   createSessionRunningMessage
-} from "./chunk-NOU2QIL5.js";
-import "./chunk-S7O77CVO.js";
-import "./chunk-QNKXZH3Z.js";
-import "./chunk-I4RWK2L2.js";
+} from "./chunk-O3NUNU4H.js";
 import "./chunk-J2GP3J3X.js";
 import "./chunk-V4IE7HJY.js";
 import "./chunk-YHEQTVFV.js";
 import "./chunk-EZK7CGJ7.js";
 import "./chunk-K44MW7JJ.js";
-import "./chunk-YD6NDTKF.js";
+import "./chunk-5GOOSZX7.js";
 import "./chunk-WGAAQASA.js";
 import "./chunk-CQGTEGKL.js";
 import "./chunk-5WRI5ZAA.js";
@@ -158,4 +159,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-ETKFIHUO.js.map
+//# sourceMappingURL=chat-handler-3BZ4PDL2.js.map

package/dist/chunk-46RORSKU.js

@@ -0,0 +1,495 @@
+import {
+  getEventStore
+} from "./chunk-NGJ5XJ7D.js";
+import {
+  createChatPathConfirmationMessage
+} from "./chunk-O3NUNU4H.js";
+
+// src/server/tools/path-security.ts
+import { realpath } from "fs/promises";
+import { resolve, normalize, join, basename, sep, posix, win32 } from "path";
+import { homedir, tmpdir } from "os";
+var SAFE_PATHS = /* @__PURE__ */ new Set([
+  "/dev/null",
+  "/dev/zero",
+  "/dev/random",
+  "/dev/urandom",
+  "/dev/stdin",
+  "/dev/stdout",
+  "/dev/stderr",
+  "/dev/fd/0",
+  "/dev/fd/1",
+  "/dev/fd/2"
+]);
+var ALLOWED_ROOTS = ["/tmp", "/var/tmp", tmpdir()];
+var SENSITIVE_FILE_PATTERNS = [
+  // Dotenv files (but not .envrc, .env-example, .env.example)
+  /^\.env$/,
+  // .env
+  /^\.env\.(?!example)[a-zA-Z0-9_.-]+$/,
+  // .env.local, .env.production (not .env.example)
+  // Credential files
+  /^credentials\.json$/i,
+  /^secrets?\.(?:json|ya?ml|toml)$/i,
+  // Private keys
+  /\.pem$/i,
+  /\.key$/i,
+  /^id_rsa/,
+  /^id_ed25519/,
+  /^id_ecdsa/,
+  /^id_dsa/,
+  // Auth configs
+  /^\.netrc$/
+];
+function isSensitivePath(path) {
+  const fileName = basename(path);
+  if (!fileName) return false;
+  return SENSITIVE_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
+}
+var sessionAllowedPaths = /* @__PURE__ */ new Map();
+function addAllowedPath(sessionId, path) {
+  if (!sessionAllowedPaths.has(sessionId)) {
+    sessionAllowedPaths.set(sessionId, /* @__PURE__ */ new Set());
+  }
+  sessionAllowedPaths.get(sessionId).add(normalize(path));
+}
+function addAllowedPaths(sessionId, paths) {
+  for (const path of paths) {
+    addAllowedPath(sessionId, path);
+  }
+}
+function isPathAllowed(sessionId, path) {
+  const allowed = sessionAllowedPaths.get(sessionId);
+  if (!allowed) return false;
+  return allowed.has(normalize(path));
+}
+function clearAllowedPaths(sessionId) {
+  sessionAllowedPaths.delete(sessionId);
+}
+async function safeRealpath(path) {
+  const absolutePath = normalize(resolve(path));
+  try {
+    return await realpath(absolutePath);
+  } catch {
+    const missingSegments = [];
+    let current = absolutePath;
+    while (true) {
+      try {
+        const canonicalParent = await realpath(current);
+        return normalize(join(canonicalParent, ...missingSegments.reverse()));
+      } catch {
+        const parent = resolve(current, "..");
+        if (parent === current) return absolutePath;
+        missingSegments.push(basename(current));
+        current = parent;
+      }
+    }
+  }
+}
+async function isPathWithinSandbox(path, workdir, sessionId) {
+  const normalizedWorkdir = normalize((await safeRealpath(workdir)).replace(/\/+$/, ""));
+  let resolvedPath;
+  try {
+    resolvedPath = normalize(await realpath(path));
+  } catch {
+    try {
+      const { readlink } = await import("fs/promises");
+      const linkTarget = await readlink(path);
+      const linkDir = resolve(path, "..");
+      resolvedPath = await safeRealpath(resolve(linkDir, linkTarget));
+    } catch {
+      resolvedPath = await safeRealpath(path);
+    }
+  }
+  resolvedPath = resolvedPath.replace(/\/+$/, "");
+  if (resolvedPath === normalizedWorkdir || resolvedPath.startsWith(normalizedWorkdir + sep)) {
+    return { allowed: true, resolvedPath };
+  }
+  for (const root of ALLOWED_ROOTS) {
+    const normalizedRoot = normalize((await safeRealpath(root)).replace(/\/+$/, ""));
+    if (resolvedPath === normalizedRoot || resolvedPath.startsWith(normalizedRoot + sep)) {
+      return { allowed: true, resolvedPath };
+    }
+  }
+  if (sessionId && (isPathAllowed(sessionId, path) || isPathAllowed(sessionId, resolvedPath))) {
+    return { allowed: true, resolvedPath };
+  }
+  return { allowed: false, resolvedPath };
+}
+function looksLikeRegex(str) {
+  return /[*?+[\]\\]/.test(str);
+}
+var isWindows = () => process.platform === "win32";
+function isWindowsAbsolutePath(str) {
+  return /^[A-Za-z]:[\\/]/.test(str);
+}
+function normalizeExtracted(path) {
+  return isWindowsAbsolutePath(path) ? win32.normalize(path) : posix.normalize(path);
+}
+function isPlaceholderToken(str) {
+  return str.includes("__URL__") || str.includes("__FILEURL__") || str.includes("__SED__") || str.includes("__COMMIT_MSG__");
+}
+function extractAbsolutePathsFromCommand(command) {
+  if (!command.trim()) {
+    return [];
+  }
+  const paths = [];
+  const home = homedir();
+  let sanitized = command.replace(/https?:\/\/[^\s'"]+/g, " __URL__ ").replace(/ftp:\/\/[^\s'"]+/g, " __URL__ ");
+  sanitized = sanitized.replace(/(?<!\w)s\/[^/]*\/[^/]*\/[gip]*/g, " __SED__ ");
+  sanitized = sanitized.replace(/(?<!\w)s\|[^|]*\|[^|]*\|[gip]*/g, " __SED__ ");
+  sanitized = sanitized.replace(/(?<!\w)s:[^:]*:[^:]*:[gip]*/g, " __SED__ ");
+  sanitized = sanitized.replace(
+    /git\s+commit\b.*?(?:-(?:[a-zA-Z]*m)(?=\s)|--message)\s+(["'])(?:(?!\1).)*\1/g,
+    (match2) => match2.replace(/\/[^\s"'|&;<>`()]+/g, " __COMMIT_MSG__ ")
+  );
+  const fileUrlMatches = command.matchAll(/file:\/\/([^\s'"]+)/g);
+  for (const match2 of fileUrlMatches) {
+    const filePath = match2[1];
+    if (filePath && !isSafePath(filePath)) {
+      paths.push(normalizeExtracted(filePath));
+    }
+  }
+  sanitized = sanitized.replace(/file:\/\/[^\s'"]+/g, " __FILEURL__ ");
+  const tildePattern = /(?:^|[\s='"(])~(\/[^\s'"()]*)?(?=[\s'"()]|$)/g;
+  let match;
+  while ((match = tildePattern.exec(sanitized)) !== null) {
+    const pathPart = match[1] ?? "";
+    const fullPath = home + pathPart;
+    const resolved = normalize(resolve(fullPath));
+    if (!isSafePath(resolved)) {
+      paths.push(resolved);
+    }
+  }
+  const quotedPattern = /["']([^"']+)["']/g;
+  while ((match = quotedPattern.exec(sanitized)) !== null) {
+    const content = match[1];
+    if (content.startsWith("/") && content.endsWith("/")) {
+      continue;
+    }
+    if (content.startsWith("/") && looksLikeRegex(content)) {
+      continue;
+    }
+    if (isWindowsAbsolutePath(content)) {
+      const resolved = normalizeExtracted(content);
+      if (!isSafePath(resolved)) {
+        paths.push(resolved);
+      }
+    } else if (!isWindows() && content.startsWith("/")) {
+      const resolved = normalizeExtracted(content);
+      if (!isSafePath(resolved)) {
+        paths.push(resolved);
+      }
+    } else if (content.startsWith("~")) {
+      const pathPart = content.slice(1);
+      const fullPath = join(home, pathPart);
+      const resolved = normalize(resolve(fullPath));
+      if (!isSafePath(resolved)) {
+        paths.push(resolved);
+      }
+    }
+  }
+  if (isWindows()) {
+    const winAbsolutePattern = /(?:^|[\s=(])([A-Za-z]:[\\/][^\s"'|&;<>`()]+)/g;
+    while ((match = winAbsolutePattern.exec(sanitized)) !== null) {
+      const candidate = match[1];
+      if (isPlaceholderToken(candidate)) continue;
+      const resolved = normalizeExtracted(candidate);
+      if (!isSafePath(resolved)) {
+        paths.push(resolved);
+      }
+    }
+  } else {
+    const absolutePattern = /(?:^|[\s=(])(\/[^\s"'|&;<>`()]+)/g;
+    while ((match = absolutePattern.exec(sanitized)) !== null) {
+      const candidate = match[1];
+      if (isPlaceholderToken(candidate)) continue;
+      if (looksLikeRegex(candidate)) continue;
+      const resolved = normalizeExtracted(candidate);
+      if (resolved === "/" || resolved === "") continue;
+      if (!isSafePath(resolved)) {
+        paths.push(resolved);
+      }
+    }
+  }
+  return [...new Set(paths)];
+}
+function extractSensitivePathsFromCommand(command) {
+  if (!command.trim()) {
+    return [];
+  }
+  const paths = [];
+  const quotedPattern = /["']([^"']+)["']/g;
+  let match;
+  while ((match = quotedPattern.exec(command)) !== null) {
+    const content = match[1];
+    if (isSensitivePath(content)) {
+      paths.push(content);
+    }
+  }
+  const unquoted = command.replace(/["'][^"']*["']/g, " ").replace(/[|&;><]/g, " ");
+  const tokens = unquoted.split(/\s+/).filter(Boolean);
+  for (const token of tokens) {
+    if (token.startsWith("-")) continue;
+    if (token.includes("://")) continue;
+    if (isSensitivePath(token)) {
+      paths.push(token);
+    }
+  }
+  return [...new Set(paths)];
+}
+function isSafePath(path) {
+  const normalized = posix.normalize(path);
+  return SAFE_PATHS.has(normalized);
+}
+async function checkPathsAccess(paths, workdir, sessionId) {
+  if (paths.length === 0) {
+    return { needsConfirmation: false, deniedPaths: [], sensitivePaths: [] };
+  }
+  const deniedPaths = [];
+  const sensitivePaths = [];
+  for (const path of paths) {
+    const result = await isPathWithinSandbox(path, workdir, sessionId);
+    if (!result.allowed) {
+      deniedPaths.push(result.resolvedPath);
+    }
+    if (isSensitivePath(path) && !isPathAllowed(sessionId ?? "", path)) {
+      sensitivePaths.push(result.resolvedPath);
+    }
+  }
+  const uniqueDenied = [...new Set(deniedPaths)];
+  const uniqueSensitive = [...new Set(sensitivePaths)];
+  return {
+    needsConfirmation: uniqueDenied.length > 0 || uniqueSensitive.length > 0,
+    deniedPaths: uniqueDenied,
+    sensitivePaths: uniqueSensitive
+  };
+}
+var DANGEROUS_PATTERNS = [
+  /sudo\s/,
+  /rm\s+(-rf?|--recursive)\s+[~]/,
+  /chmod\s+777/,
+  />\s*\/dev\/sd/,
+  /mkfs\s/,
+  /dd\s+if=/,
+  /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;/
+];
+function extractDangerousPatterns(command) {
+  const dangerous = [];
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(command)) {
+      dangerous.push(pattern.source);
+    }
+  }
+  return dangerous;
+}
+function extractGitNoVerify(command) {
+  const subCommands = command.split(/\s*(?:&&|\|\||\||;)\s*/);
+  for (const sub of subCommands) {
+    const parts = sub.trim().split(/\s+/);
+    const gitIndex = parts.indexOf("git");
+    const subCmd = parts[gitIndex + 1];
+    if (gitIndex >= 0 && subCmd && !subCmd.startsWith("-")) {
+      const gitArgs = parts.slice(gitIndex + 2);
+      if (gitArgs.some((a) => a === "--no-verify" || a === "-n")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function requestPathAccess(paths, workdir, sessionId, callId, tool, onEvent, dangerLevel, command, isSubAgent) {
+  if (isSubAgent) {
+    const result2 = await checkPathsAccess(paths, workdir, sessionId);
+    if (!result2.needsConfirmation) return;
+    if (dangerLevel === "dangerous") {
+      const allPaths2 = [.../* @__PURE__ */ new Set([...result2.deniedPaths, ...result2.sensitivePaths])];
+      addAllowedPaths(sessionId, allPaths2);
+      return;
+    }
+    const allPaths = [.../* @__PURE__ */ new Set([...result2.deniedPaths, ...result2.sensitivePaths])];
+    const hasDenied2 = result2.deniedPaths.length > 0;
+    const hasSensitive2 = result2.sensitivePaths.length > 0;
+    const reason2 = hasDenied2 && hasSensitive2 ? "both" : hasDenied2 ? "outside_workdir" : "sensitive_file";
+    throw new PathAccessDeniedError(allPaths, tool, reason2);
+  }
+  const emitPendingEvent = (confirmationPaths, confirmationReason) => {
+    try {
+      const eventStore = getEventStore();
+      eventStore.append(sessionId, {
+        type: "path.confirmation_pending",
+        data: { callId, tool, paths: confirmationPaths, workdir, reason: confirmationReason }
+      });
+    } catch {
+    }
+  };
+  if (command && extractGitNoVerify(command)) {
+    emitPendingEvent([workdir], "git_no_verify");
+    const confirmationPromise2 = registerPathConfirmation(callId, [workdir], sessionId, tool, workdir, "git_no_verify");
+    onEvent(createChatPathConfirmationMessage(callId, tool, ["git --no-verify detected"], workdir, "git_no_verify"));
+    const approved2 = await confirmationPromise2;
+    if (!approved2) {
+      throw new PathAccessDeniedError(
+        ["git --no-verify"],
+        tool,
+        "git_no_verify",
+        "User denied git command with --no-verify. The agent must not use --no-verify and must resolve the issue (e.g., fix lint errors, resolve conflicts) that prevents the commit."
+      );
+    }
+  }
+  if (dangerLevel !== "dangerous" && command) {
+    const dangerousPatterns = extractDangerousPatterns(command);
+    if (dangerousPatterns.length > 0) {
+      emitPendingEvent([workdir], "dangerous_command");
+      const confirmationPromise2 = registerPathConfirmation(
+        callId,
+        [workdir],
+        sessionId,
+        tool,
+        workdir,
+        "dangerous_command"
+      );
+      onEvent(
+        createChatPathConfirmationMessage(callId, tool, [dangerousPatterns.join(", ")], workdir, "dangerous_command")
+      );
+      const approved2 = await confirmationPromise2;
+      if (!approved2) {
+        throw new PathAccessDeniedError(dangerousPatterns, tool, "dangerous_command");
+      }
+    }
+  }
+  const result = await checkPathsAccess(paths, workdir, sessionId);
+  if (!result.needsConfirmation) {
+    return;
+  }
+  if (dangerLevel === "dangerous") {
+    const allPaths = [.../* @__PURE__ */ new Set([...result.deniedPaths, ...result.sensitivePaths])];
+    addAllowedPaths(sessionId, allPaths);
+    return;
+  }
+  const allPathsNeedingConfirmation = [.../* @__PURE__ */ new Set([...result.deniedPaths, ...result.sensitivePaths])];
+  const hasDenied = result.deniedPaths.length > 0;
+  const hasSensitive = result.sensitivePaths.length > 0;
+  const reason = hasDenied && hasSensitive ? "both" : hasDenied ? "outside_workdir" : "sensitive_file";
+  emitPendingEvent(allPathsNeedingConfirmation, reason);
+  const confirmationPromise = registerPathConfirmation(
+    callId,
+    allPathsNeedingConfirmation,
+    sessionId,
+    tool,
+    workdir,
+    reason
+  );
+  onEvent(createChatPathConfirmationMessage(callId, tool, allPathsNeedingConfirmation, workdir, reason));
+  const approved = await confirmationPromise;
+  if (!approved) {
+    throw new PathAccessDeniedError(allPathsNeedingConfirmation, tool, reason);
+  }
+}
+var PathAccessDeniedError = class extends Error {
+  constructor(paths, tool, reason = "outside_workdir", customMessage) {
+    const reasonText = reason === "sensitive_file" ? "sensitive files (may contain secrets)" : reason === "both" ? "paths outside workdir and sensitive files" : reason === "git_no_verify" ? "git commands with --no-verify" : "paths outside workdir";
+    super(customMessage ?? `User denied access to ${reasonText}: ${paths.join(", ")}`);
+    this.paths = paths;
+    this.tool = tool;
+    this.reason = reason;
+    this.customMessage = customMessage;
+    this.name = "PathAccessDeniedError";
+  }
+};
+var pendingConfirmations = /* @__PURE__ */ new Map();
+function registerPathConfirmation(callId, paths, sessionId, tool, workdir, reason) {
+  return new Promise((resolve2, reject) => {
+    pendingConfirmations.set(callId, { resolve: resolve2, reject, paths, sessionId, tool, workdir, reason });
+  });
+}
+function providePathConfirmation(callId, approved, alwaysAllow) {
+  const pending = pendingConfirmations.get(callId);
+  if (!pending) {
+    return { found: false };
+  }
+  try {
+    const eventStore = getEventStore();
+    eventStore.append(pending.sessionId, {
+      type: "path.confirmation_responded",
+      data: { callId, approved, alwaysAllow: alwaysAllow ?? false }
+    });
+  } catch {
+  }
+  if (approved) {
+    if (alwaysAllow) {
+      addAllowedPaths(pending.sessionId, pending.paths);
+    } else {
+      addAllowedPaths(pending.sessionId, pending.paths);
+    }
+  }
+  pending.resolve(approved);
+  pendingConfirmations.delete(callId);
+  return { found: true, sessionId: pending.sessionId, approved };
+}
+function cancelPathConfirmation(callId, reason) {
+  const pending = pendingConfirmations.get(callId);
+  if (!pending) {
+    return false;
+  }
+  pending.reject(new Error(reason));
+  pendingConfirmations.delete(callId);
+  return true;
+}
+function cancelPathConfirmationsForSession(sessionId, reason) {
+  let cancelledCount = 0;
+  for (const [callId, pending] of pendingConfirmations.entries()) {
+    if (pending.sessionId !== sessionId) {
+      continue;
+    }
+    pending.reject(new Error(reason));
+    pendingConfirmations.delete(callId);
+    cancelledCount += 1;
+  }
+  return cancelledCount;
+}
+function hasPendingPathConfirmation(callId) {
+  return pendingConfirmations.has(callId);
+}
+function getPendingConfirmationsBySession() {
+  const bySession = {};
+  for (const [_callId, pending] of pendingConfirmations.entries()) {
+    const entry = {
+      callId: _callId,
+      tool: pending.tool,
+      paths: pending.paths,
+      workdir: pending.workdir,
+      reason: pending.reason
+    };
+    const existing = bySession[pending.sessionId];
+    if (existing) {
+      existing.push(entry);
+    } else {
+      bySession[pending.sessionId] = [entry];
+    }
+  }
+  return bySession;
+}
+
+export {
+  isSensitivePath,
+  addAllowedPath,
+  addAllowedPaths,
+  isPathAllowed,
+  clearAllowedPaths,
+  isPathWithinSandbox,
+  extractAbsolutePathsFromCommand,
+  extractSensitivePathsFromCommand,
+  checkPathsAccess,
+  extractDangerousPatterns,
+  extractGitNoVerify,
+  requestPathAccess,
+  PathAccessDeniedError,
+  registerPathConfirmation,
+  providePathConfirmation,
+  cancelPathConfirmation,
+  cancelPathConfirmationsForSession,
+  hasPendingPathConfirmation,
+  getPendingConfirmationsBySession
+};
+//# sourceMappingURL=chunk-46RORSKU.js.map

package/dist/{chunk-S7O77CVO.js → chunk-4QHDQP2N.js}

@@ -1,7 +1,7 @@
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-QNKXZH3Z.js";
+} from "./chunk-YMFCFMMB.js";
 
 // src/server/utils/platform.ts
 import os from "os";
@@ -63,4 +63,4 @@ export {
   isWindowsPath,
   isAbsolutePath
 };
-//# sourceMappingURL=chunk-S7O77CVO.js.map
+//# sourceMappingURL=chunk-4QHDQP2N.js.map

package/dist/{chunk-YD6NDTKF.js → chunk-5GOOSZX7.js}

@@ -26,4 +26,4 @@ export {
   isClientMessage,
   isServerMessage
 };
-//# sourceMappingURL=chunk-YD6NDTKF.js.map
+//# sourceMappingURL=chunk-5GOOSZX7.js.map

package/dist/{chunk-XWBNYU2L.js → chunk-7772ENZN.js}

@@ -1,6 +1,6 @@
 import {
   getPlatformShell
-} from "./chunk-S7O77CVO.js";
+} from "./chunk-4QHDQP2N.js";
 import {
   streamWithSegments
 } from "./chunk-J2GP3J3X.js";
@@ -419,13 +419,14 @@ async function* streamLLMPure(options) {
           const fullName = toolNames.get(value.index);
           if (!seenToolIndices.has(value.index) && fullName) {
             seenToolIndices.add(value.index);
+            const displayName = options.subAgentAliases?.has(fullName) ? "call_sub_agent" : fullName;
             const accumulatedArgs = toolArgs.get(value.index);
             yield {
               type: "tool.preparing",
               data: {
                 messageId,
                 index: value.index,
-                name: fullName,
+                name: displayName,
                 ...accumulatedArgs ? { arguments: accumulatedArgs } : {}
               }
             };
@@ -678,4 +679,4 @@ export {
   createChatDoneEvent,
   consumeStreamGenerator
 };
-//# sourceMappingURL=chunk-XWBNYU2L.js.map
+//# sourceMappingURL=chunk-7772ENZN.js.map

package/dist/{chunk-I4RWK2L2.js → chunk-7QXRQ5ZL.js}

@@ -176,8 +176,8 @@ function runMigrations(db2) {
   if (!columnNames.includes("workspace") && columnNames.includes("worktree")) {
     logger.info("Migrating sessions table: renaming worktree to workspace");
     db2.exec(`ALTER TABLE sessions RENAME COLUMN worktree TO workspace`);
-  }
-  if (!columnNames.includes("workspace")) {
+    columnNames[columnNames.indexOf("worktree")] = "workspace";
+  } else if (!columnNames.includes("workspace")) {
     logger.info("Migrating sessions table: adding workspace column");
     db2.exec(`ALTER TABLE sessions ADD COLUMN workspace TEXT`);
   }
@@ -188,4 +188,4 @@ export {
   initDatabase,
   getDatabase
 };
-//# sourceMappingURL=chunk-I4RWK2L2.js.map
+//# sourceMappingURL=chunk-7QXRQ5ZL.js.map