openfox 2.0.74 → 2.0.76

package/dist/{chunk-2VBETAU2.js → chunk-D6CI2B7B.js}

@@ -1,3 +1,9 @@
+import {
+  createMcpTools
+} from "./chunk-NWO6GRYE.js";
+import {
+  applyMcpServerUpdate
+} from "./chunk-KVRSAC4Z.js";
 import {
   getGitBranch,
   listWorkspaces
@@ -18,13 +24,13 @@ import {
   createToolCallEvent,
   createToolResultEvent,
   streamLLMPure
-} from "./chunk-XWBNYU2L.js";
+} from "./chunk-7772ENZN.js";
 import {
   startInspectProxy
-} from "./chunk-E5LLEO3C.js";
+} from "./chunk-DH3SSBZN.js";
 import {
   getProject
-} from "./chunk-UV3EMWL4.js";
+} from "./chunk-LXFLRM7M.js";
 import {
   checkAborted,
   createProcess,
@@ -35,24 +41,30 @@ import {
   spawnShellProcess,
   startProcessCommand,
   stopProcess
-} from "./chunk-PYB2UEC3.js";
+} from "./chunk-OBQPXUXI.js";
+import {
+  SETTINGS_KEYS,
+  deleteSetting,
+  getSetting,
+  setSetting
+} from "./chunk-YMFCFMMB.js";
 import {
   getMaxPerSession,
   getSessionProcessCount,
   terminateProcessTree
 } from "./chunk-I72ACQ6R.js";
 import {
-  createMcpTools
-} from "./chunk-NWO6GRYE.js";
-import {
-  applyMcpServerUpdate
-} from "./chunk-UN26GIQG.js";
+  PathAccessDeniedError,
+  extractAbsolutePathsFromCommand,
+  extractSensitivePathsFromCommand,
+  requestPathAccess
+} from "./chunk-46RORSKU.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
   getEventStore,
   getRuntimeConfig
-} from "./chunk-6XKM25OT.js";
+} from "./chunk-NGJ5XJ7D.js";
 import {
   buildContextMessagesFromEventHistory,
   foldContextState,
@@ -67,15 +79,8 @@ import {
   createChatDoneMessage,
   createChatMessageMessage,
   createChatMessageUpdatedMessage,
-  createChatPathConfirmationMessage,
   createQueueStateMessage
-} from "./chunk-NOU2QIL5.js";
-import {
-  SETTINGS_KEYS,
-  deleteSetting,
-  getSetting,
-  setSetting
-} from "./chunk-QNKXZH3Z.js";
+} from "./chunk-O3NUNU4H.js";
 import {
   modelSupportsVision
 } from "./chunk-V4IE7HJY.js";
@@ -99,430 +104,10 @@ import {
 
 // src/server/tools/read.ts
 import { readFile as readFile2, stat, readdir } from "fs/promises";
-import { extname, join as join2 } from "path";
-
-// src/server/tools/tool-helpers.ts
-import { resolve as resolve2, isAbsolute } from "path";
-
-// 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));
-}
-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);
-    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);
-      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);
-  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) {
-  return new Promise((resolve6, reject) => {
-    pendingConfirmations.set(callId, { resolve: resolve6, reject, paths, sessionId });
-  });
-}
-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 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;
-}
+import { extname, join } from "path";
 
 // src/server/tools/tool-helpers.ts
+import { resolve, isAbsolute } from "path";
 function buildSignal(timeoutMs, contextSignal) {
   const timeoutSignal = AbortSignal.timeout(timeoutMs);
   if (contextSignal) {
@@ -570,7 +155,7 @@ function createTool(name, definition, handler2) {
     async execute(args, context) {
       const startTime = Date.now();
       const helpers = {
-        resolvePath: (path) => isAbsolute(path) ? path : resolve2(context.workdir, path),
+        resolvePath: (path) => isAbsolute(path) ? path : resolve(context.workdir, path),
         checkPathAccess: async (paths, command) => {
           if (context.onEvent) {
             await requestPathAccess(
@@ -620,7 +205,7 @@ function createTool(name, definition, handler2) {
 // src/server/tools/file-tracker.ts
 import { createHash } from "crypto";
 import { readFile } from "fs/promises";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve2 } from "path";
 var FileNotReadError = class extends Error {
   constructor(path) {
     super(`File "${path}" must be read before writing. Use read_file first.`);
@@ -649,7 +234,7 @@ async function computeFileHash(filePath) {
   }
 }
 async function validateFileForWrite(filePath, readFiles) {
-  const normalizedPath = resolve3(filePath);
+  const normalizedPath = resolve2(filePath);
   const currentHash = await computeFileHash(normalizedPath);
   if (currentHash === null) {
     return { valid: true };
@@ -889,7 +474,7 @@ async function listDirectory(dirPath, relativePath) {
     let sizeStr = "";
     if (!entry.isDirectory()) {
       try {
-        const entryStat = await stat(join2(dirPath, entry.name));
+        const entryStat = await stat(join(dirPath, entry.name));
         sizeStr = `  ${formatSize(entryStat.size).padStart(7)}`;
       } catch {
       }
@@ -1402,7 +987,7 @@ Make sure whitespace and indentation match exactly.`
 
 // src/server/tools/shell.ts
 import { spawn } from "child_process";
-import { resolve as resolve4, isAbsolute as isAbsolute2 } from "path";
+import { resolve as resolve3, isAbsolute as isAbsolute2 } from "path";
 import { access } from "fs/promises";
 import stripAnsi from "strip-ansi";
 
@@ -1428,7 +1013,7 @@ async function checkRtkAvailability() {
     rtkAvailable = true;
   } catch {
     try {
-      const out = await new Promise((resolve6, reject) => {
+      const out = await new Promise((resolve5, reject) => {
         const proc = spawn("rtk", ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
         let output = "";
         proc.stdout?.on("data", (d) => {
@@ -1436,7 +1021,7 @@ async function checkRtkAvailability() {
         });
         proc.on("error", reject);
         proc.on("close", (code) => {
-          if (code === 0) resolve6(output.trim());
+          if (code === 0) resolve5(output.trim());
           else reject(new Error(`exit ${code}`));
         });
       });
@@ -1495,12 +1080,12 @@ var runCommandTool = createTool(
     const pathsToCheck = [workingDir];
     const commandPaths = extractAbsolutePathsFromCommand(args.command);
     for (const cmdPath of commandPaths) {
-      const resolved = isAbsolute2(cmdPath) ? cmdPath : resolve4(workingDir, cmdPath);
+      const resolved = isAbsolute2(cmdPath) ? cmdPath : resolve3(workingDir, cmdPath);
       pathsToCheck.push(resolved);
     }
     const sensitivePaths = extractSensitivePathsFromCommand(args.command);
     for (const sensitivePath of sensitivePaths) {
-      const resolved = isAbsolute2(sensitivePath) ? sensitivePath : resolve4(workingDir, sensitivePath);
+      const resolved = isAbsolute2(sensitivePath) ? sensitivePath : resolve3(workingDir, sensitivePath);
       pathsToCheck.push(resolved);
     }
     await helpers.checkPathAccess(pathsToCheck, args.command);
@@ -1550,7 +1135,7 @@ ${result.stderr}`;
 async function tryRtkRewrite(command) {
   if (!await checkRtkAvailability()) return command;
   try {
-    const result = await new Promise((resolve6, reject) => {
+    const result = await new Promise((resolve5, reject) => {
       const proc = spawn("rtk", ["rewrite", command], {
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 2e3
@@ -1561,7 +1146,7 @@ async function tryRtkRewrite(command) {
       });
       proc.on("error", reject);
       proc.on("close", (code) => {
-        if (code === 0 || code === 3) resolve6(stdout.trim());
+        if (code === 0 || code === 3) resolve5(stdout.trim());
         else reject(new Error(`exit ${code}`));
       });
     });
@@ -1571,7 +1156,7 @@ async function tryRtkRewrite(command) {
   return command;
 }
 function executeCommand(command, cwd, timeout, signal, onProgress) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve5, reject) => {
     if (checkAborted(signal)) {
       reject(new Error("Command aborted before execution"));
       return;
@@ -1610,7 +1195,7 @@ function executeCommand(command, cwd, timeout, signal, onProgress) {
         let output = stdout.trim();
         if (output) output += "\n\n";
         output += "[interrupted by user]";
-        resolve6({
+        resolve5({
           stdout: output,
           stderr: stderr.trim(),
           exitCode: 130
@@ -1622,7 +1207,7 @@ function executeCommand(command, cwd, timeout, signal, onProgress) {
         if (output) output += "\n\n";
         output += `[Exit code: 124]
 [Process timed out after ${timeout}ms]`;
-        resolve6({
+        resolve5({
           stdout: output,
           stderr: stderr.trim(),
           exitCode: 124
@@ -1638,7 +1223,7 @@ function executeCommand(command, cwd, timeout, signal, onProgress) {
         if (output) output += "\n\n";
         output += `[Exit code: 124]
 [Process timed out after ${timeout}ms]`;
-        resolve6({
+        resolve5({
           stdout: output,
           stderr: stderr.trim(),
           exitCode: 124
@@ -1649,14 +1234,14 @@ function executeCommand(command, cwd, timeout, signal, onProgress) {
         let output = stdout.trim();
         if (output) output += "\n\n";
         output += "[interrupted by user]";
-        resolve6({
+        resolve5({
           stdout: output,
           stderr: stderr.trim(),
           exitCode: 130
         });
         return;
       }
-      resolve6({
+      resolve5({
         stdout: stdout.trim(),
         stderr: stderr.trim(),
         exitCode: code ?? 1
@@ -1821,18 +1406,18 @@ ${Object.entries(schema.fields).map(([f, t]) => `  ${f}: ${t}`).join("\n")}`
 
 // src/server/sub-agents/manager.ts
 import { readFile as readFile8, access as access5 } from "fs/promises";
-import { join as join7, dirname as dirname5, isAbsolute as isAbsolute3 } from "path";
+import { join as join6, dirname as dirname5, isAbsolute as isAbsolute3 } from "path";
 
 // src/server/agents/registry.ts
 import { readdir as readdir3, readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3, access as access3, unlink as unlink2 } from "fs/promises";
-import { join as join4, dirname as dirname2 } from "path";
+import { join as join3, dirname as dirname2 } from "path";
 import { constants as constants2 } from "fs";
 import { fileURLToPath } from "url";
 import matter2 from "gray-matter";
 
 // src/server/shared/item-loader.ts
 import { readdir as readdir2, readFile as readFile4, access as access2, writeFile as writeFile3, mkdir as mkdir2, unlink } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 import { constants } from "fs";
 import matter from "gray-matter";
 async function pathExists(path) {
@@ -1864,7 +1449,7 @@ async function loadItemsFromDir(dir, options) {
   const items = [];
   for (const file of files) {
     try {
-      const raw = await readFile4(join3(dir, file), "utf-8");
+      const raw = await readFile4(join2(dir, file), "utf-8");
       const { data, content } = matter(raw);
       if (data.id && content.trim()) {
         items.push({
@@ -1888,12 +1473,12 @@ async function saveItemToDir(dir, item, ext, serialize) {
     await mkdir2(dir, { recursive: true });
   }
   const meta = item.metadata;
-  const filePath = join3(dir, `${meta.id}${ext}`);
+  const filePath = join2(dir, `${meta.id}${ext}`);
   await writeFile3(filePath, serialize(item), "utf-8");
 }
 var jsonSerializer = (item) => JSON.stringify(item, null, 2) + "\n";
 async function deleteItemFromDir(dir, id, ext) {
-  const filePath = join3(dir, `${id}${ext}`);
+  const filePath = join2(dir, `${id}${ext}`);
   try {
     await unlink(filePath);
     return { success: true };
@@ -1904,14 +1489,14 @@ async function deleteItemFromDir(dir, id, ext) {
 
 // src/server/agents/registry.ts
 var __bundleDir = dirname2(fileURLToPath(import.meta.url));
-var DEFAULTS_DIR = join4(__bundleDir, "defaults");
-var DEFAULTS_DIR_ALT = join4(__bundleDir, "agent-defaults");
+var DEFAULTS_DIR = join3(__bundleDir, "defaults");
+var DEFAULTS_DIR_ALT = join3(__bundleDir, "agent-defaults");
 var AGENT_EXTENSION = ".agent.md";
 function getAgentsDir(configDir) {
-  return join4(configDir, "agents");
+  return join3(configDir, "agents");
 }
 function getProjectAgentsDir(projectDir) {
-  return join4(projectDir, ".openfox", "agents");
+  return join3(projectDir, ".openfox", "agents");
 }
 async function pathExists2(path) {
   try {
@@ -1952,7 +1537,7 @@ async function loadAgentsFromDir(dir) {
   const agents = [];
   for (const file of files) {
     try {
-      const raw = await readFile5(join4(dir, file), "utf-8");
+      const raw = await readFile5(join3(dir, file), "utf-8");
       const agent = parseAgentFile(raw, file);
       if (agent) {
         agents.push(agent);
@@ -2037,7 +1622,7 @@ async function isDefaultAgent(agentId) {
 }
 function getAgentFilePaths(agentsDir, agentId) {
   const hyphenated = agentId.replace(/_/g, "-");
-  return [join4(agentsDir, `${agentId}${AGENT_EXTENSION}`), join4(agentsDir, `${hyphenated}${AGENT_EXTENSION}`)];
+  return [join3(agentsDir, `${agentId}${AGENT_EXTENSION}`), join3(agentsDir, `${hyphenated}${AGENT_EXTENSION}`)];
 }
 function findAgentById(agentId, agents) {
   return agents.find((a) => a.metadata.id === agentId);
@@ -2071,7 +1656,7 @@ async function saveAgent(configDir, agent) {
   if (!await pathExists2(agentsDir)) {
     await mkdir3(agentsDir, { recursive: true });
   }
-  const filePath = join4(agentsDir, `${agent.metadata.id}${AGENT_EXTENSION}`);
+  const filePath = join3(agentsDir, `${agent.metadata.id}${AGENT_EXTENSION}`);
   const content = matter2.stringify(agent.prompt, agent.metadata);
   await writeFile4(filePath, content, "utf-8");
 }
@@ -2095,7 +1680,7 @@ async function deleteAgent(configDir, agentId) {
 
 // src/server/context/instructions.ts
 import { readFile as readFile6, access as access4 } from "fs/promises";
-import { join as join5, dirname as dirname3 } from "path";
+import { join as join4, dirname as dirname3 } from "path";
 import { constants as constants3 } from "fs";
 var INSTRUCTION_FILENAMES = ["AGENTS.md", "CLAUDE.md"];
 async function findInstructionFiles(workdir) {
@@ -2112,7 +1697,7 @@ async function findInstructionFiles(workdir) {
   }
   for (const dir of pathsToCheck) {
     for (const filename of INSTRUCTION_FILENAMES) {
-      const filePath = join5(dir, filename);
+      const filePath = join4(dir, filename);
       if (await fileExists(filePath)) {
         foundFiles.push({
           path: filePath,
@@ -2185,22 +1770,22 @@ async function fileExists(path) {
 }
 
 // src/server/skills/registry.ts
-import { writeFile as writeFile5, mkdir as mkdir4, unlink as unlink3, readdir as readdir4, readFile as readFile7, realpath as realpath2, rm } from "fs/promises";
-import { join as join6, dirname as dirname4 } from "path";
+import { writeFile as writeFile5, mkdir as mkdir4, unlink as unlink3, readdir as readdir4, readFile as readFile7, realpath, rm } from "fs/promises";
+import { join as join5, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { homedir as homedir2 } from "os";
+import { homedir } from "os";
 import matter3 from "gray-matter";
 var __bundleDir2 = dirname4(fileURLToPath2(import.meta.url));
-var DEFAULTS_DIR2 = join6(__bundleDir2, "defaults");
-var DEFAULTS_DIR_ALT2 = join6(__bundleDir2, "skill-defaults");
+var DEFAULTS_DIR2 = join5(__bundleDir2, "defaults");
+var DEFAULTS_DIR_ALT2 = join5(__bundleDir2, "skill-defaults");
 var SKILL_EXTENSION = ".skill.md";
 var SKILL_SETTING_PREFIX = "skill.enabled.";
 var PORTABLE_NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function getSkillsDir(configDir) {
-  return join6(configDir, "skills");
+  return join5(configDir, "skills");
 }
 function getProjectSkillsDir(projectDir) {
-  return join6(projectDir, ".openfox", "skills");
+  return join5(projectDir, ".openfox", "skills");
 }
 function portableDisplayName(data, id) {
   const metadata = data["metadata"];
@@ -2228,8 +1813,8 @@ async function loadPortableSkills(dir, source) {
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const packageDir = join6(dir, entry.name);
-    const entrypoint = join6(packageDir, "SKILL.md");
+    const packageDir = join5(dir, entry.name);
+    const entrypoint = join5(packageDir, "SKILL.md");
     try {
       const content = await readFile7(entrypoint, "utf-8");
       const parsed = matter3(content);
@@ -2238,7 +1823,7 @@ async function loadPortableSkills(dir, source) {
       const description = typeof data["description"] === "string" ? data["description"].trim() : "";
       const prompt = parsed.content.trim();
       if (!id || !description || !prompt) continue;
-      const resolvedDirectory = await realpath2(packageDir);
+      const resolvedDirectory = await realpath(packageDir);
       const warnings = [];
       if (id.length > 64 || !PORTABLE_NAME_REGEX.test(id)) {
         warnings.push("Skill name must use 1-64 lowercase letters, numbers, and single hyphens");
@@ -2269,10 +1854,10 @@ async function loadPortableSkills(dir, source) {
 async function annotateLegacySkills(skills, dir, source) {
   return Promise.all(
     skills.map(async (skill) => {
-      const entrypoint = join6(dir, `${skill.metadata.id}${SKILL_EXTENSION}`);
+      const entrypoint = join5(dir, `${skill.metadata.id}${SKILL_EXTENSION}`);
       let resolvedEntrypoint = entrypoint;
       try {
-        resolvedEntrypoint = await realpath2(entrypoint);
+        resolvedEntrypoint = await realpath(entrypoint);
       } catch {
       }
       return {
@@ -2322,16 +1907,16 @@ async function loadAllSkills(configDir, projectDir, options = {}) {
   return (await loadAllSkillsWithDiagnostics(configDir, projectDir, options)).skills;
 }
 async function loadAllSkillsWithDiagnostics(configDir, projectDir, options = {}) {
-  const home = options.homeDir ?? homedir2();
+  const home = options.homeDir ?? homedir();
   const selected = (options.selectedDirectories ?? getSelectedSkillDirectories()).map(
-    (dir) => dir === "~" ? home : dir.startsWith("~/") ? join6(home, dir.slice(2)) : dir
+    (dir) => dir === "~" ? home : dir.startsWith("~/") ? join5(home, dir.slice(2)) : dir
   );
   const locations = [
     loadDefaultSkills(),
-    loadSkillsDirectory(join6(home, ".agents", "skills"), "global-shared"),
+    loadSkillsDirectory(join5(home, ".agents", "skills"), "global-shared"),
     loadUserSkills(configDir),
     ...selected.map((dir) => loadSkillsDirectory(dir, "selected")),
-    ...projectDir ? [loadSkillsDirectory(join6(projectDir, ".agents", "skills"), "project-shared"), loadProjectSkills(projectDir)] : []
+    ...projectDir ? [loadSkillsDirectory(join5(projectDir, ".agents", "skills"), "project-shared"), loadProjectSkills(projectDir)] : []
   ];
   const groups = await Promise.all(locations);
   const skillMap = /* @__PURE__ */ new Map();
@@ -2381,11 +1966,11 @@ function findSkillById(skillId, skills) {
   return skills.find((s) => s.metadata.id === skillId);
 }
 async function skillExists(configDir, skillId, projectDir) {
-  if (await pathExists(join6(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`))) return true;
-  if (await pathExists(join6(getSkillsDir(configDir), skillId, "SKILL.md"))) return true;
-  if (projectDir && await pathExists(join6(getProjectSkillsDir(projectDir), `${skillId}${SKILL_EXTENSION}`)))
+  if (await pathExists(join5(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`))) return true;
+  if (await pathExists(join5(getSkillsDir(configDir), skillId, "SKILL.md"))) return true;
+  if (projectDir && await pathExists(join5(getProjectSkillsDir(projectDir), `${skillId}${SKILL_EXTENSION}`)))
     return true;
-  if (projectDir && await pathExists(join6(getProjectSkillsDir(projectDir), skillId, "SKILL.md"))) return true;
+  if (projectDir && await pathExists(join5(getProjectSkillsDir(projectDir), skillId, "SKILL.md"))) return true;
   return false;
 }
 function portableFrontmatter(skill) {
@@ -2401,9 +1986,9 @@ function portableFrontmatter(skill) {
   };
 }
 async function savePortableSkill(dir, skill) {
-  const packageDir = join6(dir, skill.metadata.id);
+  const packageDir = join5(dir, skill.metadata.id);
   await mkdir4(packageDir, { recursive: true });
-  await writeFile5(join6(packageDir, "SKILL.md"), matter3.stringify(skill.prompt, portableFrontmatter(skill)), "utf-8");
+  await writeFile5(join5(packageDir, "SKILL.md"), matter3.stringify(skill.prompt, portableFrontmatter(skill)), "utf-8");
 }
 async function saveSkill(configDir, skill) {
   await savePortableSkill(getSkillsDir(configDir), skill);
@@ -2486,7 +2071,7 @@ async function deleteSkill(configDir, skillId) {
   if (isDefault) {
     return { success: false, reason: "Cannot delete built-in defaults" };
   }
-  const filePath = join6(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`);
+  const filePath = join5(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`);
   try {
     await unlink3(filePath);
     deleteSetting(`${SKILL_SETTING_PREFIX}${skillId}`);
@@ -2522,6 +2107,21 @@ function createToolProgressHandler(append, messageId, callId, _sessionId) {
 // src/server/chat/execute-tools.ts
 import stripAnsi2 from "strip-ansi";
 var INTERRUPTED_ERROR = "Tool execution was interrupted by user";
+function extractSubAgentPrompt(args) {
+  return args["prompt"] || args["query"] || args["task"] || "";
+}
+async function transformSubAgentAliases(toolCalls, toolRegistry) {
+  const hasCallSubAgent = toolRegistry.tools.some((t) => t.name === "call_sub_agent");
+  if (!hasCallSubAgent) return;
+  const agents = await loadAllAgentsDefault();
+  for (const tc of toolCalls) {
+    const agentDef = findAgentById(tc.name, agents);
+    if (!agentDef?.metadata.subagent) continue;
+    const prompt = extractSubAgentPrompt(tc.arguments);
+    tc.name = "call_sub_agent";
+    tc.arguments = { subAgentType: agentDef.metadata.id, prompt };
+  }
+}
 function createInterruptedResult(startTime) {
   return {
     success: false,
@@ -2538,6 +2138,7 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
   if (ctx.signal?.aborted) {
     throw new Error("Aborted");
   }
+  await transformSubAgentAliases(toolCalls, ctx.toolRegistry);
   for (const toolCall of toolCalls) {
     append(createToolCallEvent(assistantMsgId, toolCall));
   }
@@ -2843,6 +2444,8 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
       const requestedMaxTokens = modelSettings.maxTokens ?? 16384;
       modelSettings = { ...modelSettings, maxTokens: Math.min(requestedMaxTokens, availableForOutput) };
     }
+    const allAgents = await loadAllAgentsDefault();
+    const subAgentAliases = new Set(getSubAgents(allAgents).map((a) => a.metadata.id));
     const streamGen = streamLLMPure({
       messageId: assistantMsgId,
       systemPrompt: assembledRequest.systemPrompt,
@@ -2851,6 +2454,7 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
       tools: assembledRequest.tools,
       toolChoice: "auto",
       signal,
+      subAgentAliases,
       ...config.retryPatterns ? { retryPatterns: config.retryPatterns } : {},
       ...modelSettings && { modelSettings }
     });
@@ -2909,7 +2513,7 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
     sessionManager.setCurrentContextSize(sessionId, result.usage.promptTokens, config.subAgentMetadata?.subAgentId);
     if (!compacting) {
       const contextState2 = sessionManager.getContextState(sessionId);
-      const { shouldCompact, appendCompactionPrompt } = await import("./compactor-4UKYWC5F.js");
+      const { shouldCompact, appendCompactionPrompt } = await import("./compactor-BB3YYVRP.js");
       if (shouldCompact(contextState2.currentTokens, contextState2.maxTokens, runtimeConfig.context.compactionThreshold)) {
         appendCompactionPrompt(sessionId, append);
         compacting = true;
@@ -3609,7 +3213,7 @@ async function loadGitIgnoreRules(workdir) {
   if (!isAbsolute3(workdir)) return "";
   let currentDir = workdir;
   while (true) {
-    const gitignorePath = join7(currentDir, ".gitignore");
+    const gitignorePath = join6(currentDir, ".gitignore");
     try {
       await access5(gitignorePath);
       const content = await readFile8(gitignorePath, "utf-8");
@@ -3814,7 +3418,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-APW7MY4E.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-JRCUWPJO.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -4100,7 +3704,7 @@ var webFetchTool = createTool(
 // src/server/dev-server/manager.ts
 import "child_process";
 import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { resolve as resolve5, join as join8 } from "path";
+import { resolve as resolve4, join as join7 } from "path";
 import net from "net";
 var MAX_LOG_LINES = 2e3;
 var MAX_LOG_BYTES = 1e5;
@@ -4108,7 +3712,7 @@ var DEFAULT_PROBE_PORT = 10469;
 var MAX_PORT_SCAN = 200;
 var PROBE_TIMEOUT_MS = 300;
 var getDevServerConfigPath = (workdir) => {
-  return join8(resolve5(workdir), ".openfox", "dev.json");
+  return join7(resolve4(workdir), ".openfox", "dev.json");
 };
 var ERROR_PATTERNS = [
   /EADDRINUSE/,
@@ -4157,7 +3761,7 @@ var DevServerManager = class {
     this._sessionManager = sm;
   }
   resolveWorkdir(workdir) {
-    return resolve5(workdir);
+    return resolve4(workdir);
   }
   getInstance(workdir) {
     const key = this.resolveWorkdir(workdir);
@@ -4255,7 +3859,7 @@ var DevServerManager = class {
   }
   async saveConfig(workdir, config) {
     const resolved = this.resolveWorkdir(workdir);
-    const dirPath = join8(resolved, ".openfox");
+    const dirPath = join7(resolved, ".openfox");
     await mkdir5(dirPath, { recursive: true });
     const configPath = getDevServerConfigPath(workdir);
     await writeFile6(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
@@ -4813,7 +4417,7 @@ var mcpConfigTool = createTool(
       mcpNotifyChanged?.(sessionId);
     }
     async function rebuildTools() {
-      const { setMcpTools: setMcpTools2 } = await import("./tools-APW7MY4E.js");
+      const { setMcpTools: setMcpTools2 } = await import("./tools-JRCUWPJO.js");
       const mcpTools = createMcpTools(mcpManagerForTools);
       setMcpTools2(mcpTools);
     }
@@ -4899,7 +4503,9 @@ var mcpConfigTool = createTool(
       notifyContextChanged(context.sessionId);
       const server = mcpManagerForTools.getServer(args.name);
       const toolCount = server?.tools.length ?? 0;
-      return helpers.success(`Updated MCP server "${args.name}" (${toolCount} tools discovered). ${APPLY_PROMPT_MESSAGE}`);
+      return helpers.success(
+        `Updated MCP server "${args.name}" (${toolCount} tools discovered). ${APPLY_PROMPT_MESSAGE}`
+      );
     }
     if (args.action === "remove") {
       if (!args.name) return helpers.error("Missing required field: name");
@@ -5243,39 +4849,11 @@ function validateToolAction(toolName, action, permissions) {
   }
   return void 0;
 }
-function extractSubAgentPrompt(args) {
-  return args["prompt"] || args["query"] || args["task"] || "";
-}
 function createRegistryFromTools(tools, allowedTools, toolPermissions, agentId, isSubAgent) {
   const toolMap = /* @__PURE__ */ new Map();
   for (const tool of tools) {
     toolMap.set(tool.name, tool);
   }
-  async function trySubAgentAlias(name, args, context) {
-    if (!toolMap.has("call_sub_agent")) {
-      return null;
-    }
-    try {
-      const agents = await loadAllAgentsDefault();
-      const agentDef = findAgentById(name, agents);
-      if (!agentDef?.metadata.subagent) {
-        return null;
-      }
-      const prompt = extractSubAgentPrompt(args);
-      logger.info("Sub-agent alias transformation", {
-        from: name,
-        to: "call_sub_agent",
-        subAgentType: name
-      });
-      return callSubAgentTool.execute({ subAgentType: name, prompt }, context);
-    } catch (err) {
-      logger.warn("Sub-agent alias resolution failed", {
-        tool: name,
-        error: err instanceof Error ? err.message : String(err)
-      });
-      return null;
-    }
-  }
   return {
     tools,
     definitions: tools.map((t) => t.definition),
@@ -5351,8 +4929,6 @@ function createRegistryFromTools(tools, allowedTools, toolPermissions, agentId,
           };
         }
       }
-      const aliasResult = await trySubAgentAlias(name, args, context);
-      if (aliasResult) return aliasResult;
       return {
         success: false,
         error: `Unknown tool: ${name}. Available tools: ${tools.map((t) => t.name).join(", ")}`,
@@ -5429,10 +5005,6 @@ function createToolRegistry() {
 }
 
 export {
-  requestPathAccess,
-  PathAccessDeniedError,
-  providePathConfirmation,
-  cancelPathConfirmationsForSession,
   pathExists,
   getDefaultIds,
   loadItemsFromDir,
@@ -5493,4 +5065,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-2VBETAU2.js.map
+//# sourceMappingURL=chunk-D6CI2B7B.js.map