openfox 2.0.76 → 2.0.78

package/dist/{chunk-46RORSKU.js → chunk-NZIYELSQ.js}

@@ -1,9 +1,9 @@
 import {
   getEventStore
-} from "./chunk-NGJ5XJ7D.js";
+} from "./chunk-M7EFXRDS.js";
 import {
   createChatPathConfirmationMessage
-} from "./chunk-O3NUNU4H.js";
+} from "./chunk-SJTG56CH.js";
 
 // src/server/tools/path-security.ts
 import { realpath } from "fs/promises";
@@ -416,10 +416,8 @@ function providePathConfirmation(callId, approved, alwaysAllow) {
     });
   } catch {
   }
-  if (approved) {
-    if (alwaysAllow) {
-      addAllowedPaths(pending.sessionId, pending.paths);
-    } else {
+  if (approved && alwaysAllow) {
+    if (pending.reason !== "dangerous_command" && pending.reason !== "git_no_verify") {
       addAllowedPaths(pending.sessionId, pending.paths);
     }
   }
@@ -451,6 +449,9 @@ function cancelPathConfirmationsForSession(sessionId, reason) {
 function hasPendingPathConfirmation(callId) {
   return pendingConfirmations.has(callId);
 }
+function getConfirmationSessionId(callId) {
+  return pendingConfirmations.get(callId)?.sessionId;
+}
 function getPendingConfirmationsBySession() {
   const bySession = {};
   for (const [_callId, pending] of pendingConfirmations.entries()) {
@@ -490,6 +491,7 @@ export {
   cancelPathConfirmation,
   cancelPathConfirmationsForSession,
   hasPendingPathConfirmation,
+  getConfirmationSessionId,
   getPendingConfirmationsBySession
 };
-//# sourceMappingURL=chunk-46RORSKU.js.map
+//# sourceMappingURL=chunk-NZIYELSQ.js.map

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

@@ -181,6 +181,10 @@ function runMigrations(db2) {
     logger.info("Migrating sessions table: adding workspace column");
     db2.exec(`ALTER TABLE sessions ADD COLUMN workspace TEXT`);
   }
+  if (!columnNames.includes("branch")) {
+    logger.info("Migrating sessions table: adding branch column");
+    db2.exec(`ALTER TABLE sessions ADD COLUMN branch TEXT`);
+  }
   logger.info("Database migrations completed");
 }
 
@@ -188,4 +192,4 @@ export {
   initDatabase,
   getDatabase
 };
-//# sourceMappingURL=chunk-7QXRQ5ZL.js.map
+//# sourceMappingURL=chunk-RGUUZD5B.js.map

package/dist/{chunk-EZK7CGJ7.js → chunk-RMXPVQP4.js}

@@ -19,6 +19,7 @@ var OUTPUT_LIMITS = {
     maxImageBytes: 2097152,
     // 2MB for images
     maxPdfPages: 50,
+    maxPdfImages: 20,
     maxFileBytes: 20971520
     // 20MB general file safety limit
   },
@@ -38,7 +39,8 @@ var OUTPUT_LIMITS = {
 };
 
 // src/server/tools/pdf-utils.ts
-import { getDocument } from "pdfjs-dist/legacy/build/pdf.mjs";
+import { getDocument, OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
+import { PNG } from "pngjs";
 var PDF_HEADER = Buffer.from("%PDF");
 function isPdfBuffer(buffer) {
   return buffer.length > 4 && buffer.subarray(0, 4).equals(PDF_HEADER);
@@ -63,47 +65,278 @@ function processPdfContent(text, maxBytes) {
   const isScanned = output.replace(/\[Page \d+\/\d+\]\n/g, "").trim().length === 0;
   return { output, truncated, isScanned };
 }
-async function extractPdfText(buffer) {
+var IMAGE_KIND_GRAYSCALE_1BPP = 1;
+var IMAGE_KIND_RGB_24BPP = 2;
+var IMAGE_KIND_RGBA_32BPP = 3;
+function getRgbaPixel(data, width, x, y, kind) {
+  if (kind === IMAGE_KIND_RGBA_32BPP) {
+    const i = (y * width + x) * 4;
+    return [data[i] ?? 0, data[i + 1] ?? 0, data[i + 2] ?? 0, data[i + 3] ?? 255];
+  }
+  if (kind === IMAGE_KIND_RGB_24BPP) {
+    const i = (y * width + x) * 3;
+    return [data[i] ?? 0, data[i + 1] ?? 0, data[i + 2] ?? 0, 255];
+  }
+  if (kind === IMAGE_KIND_GRAYSCALE_1BPP) {
+    const bytesPerRow = Math.ceil(width / 8);
+    const byteIdx = y * bytesPerRow + Math.floor(x / 8);
+    const bitIdx = 7 - x % 8;
+    const val = (data[byteIdx] ?? 0) >> bitIdx & 1 ? 255 : 0;
+    return [val, val, val, 255];
+  }
+  return [0, 0, 0, 255];
+}
+function toRgbaBuffer(data, width, height, kind) {
+  const rgba = new Uint8Array(width * height * 4);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const [r, g, b, a] = getRgbaPixel(data, width, x, y, kind);
+      const i = (y * width + x) * 4;
+      rgba[i] = r;
+      rgba[i + 1] = g;
+      rgba[i + 2] = b;
+      rgba[i + 3] = a;
+    }
+  }
+  return rgba;
+}
+function extractBitmapToRawImageData(bitmap) {
+  const canvas = new globalThis.OffscreenCanvas(bitmap.width, bitmap.height);
+  const ctx = canvas.getContext("2d");
+  ctx.drawImage(bitmap, 0, 0);
+  const imageData = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+  return {
+    width: bitmap.width,
+    height: bitmap.height,
+    data: new Uint8Array(imageData.data.buffer),
+    kind: IMAGE_KIND_RGBA_32BPP
+  };
+}
+function encodeImageToDataUrl(imgData, maxDimension = 1024) {
+  try {
+    let { width, height } = imgData;
+    let { data, kind } = imgData;
+    if (imgData.bitmap && !data) {
+      const converted = extractBitmapToRawImageData(imgData.bitmap);
+      data = converted.data;
+      kind = converted.kind;
+    }
+    if (!data) return null;
+    if (width * height * 4 > 20971520) return null;
+    if (maxDimension > 0 && (width > maxDimension || height > maxDimension)) {
+      const scale = maxDimension / Math.max(width, height);
+      const newWidth = Math.round(width * scale);
+      const newHeight = Math.round(height * scale);
+      const scaled = new Uint8Array(newWidth * newHeight * 4);
+      for (let y = 0; y < newHeight; y++) {
+        for (let x = 0; x < newWidth; x++) {
+          const srcX = Math.floor(x / scale);
+          const srcY = Math.floor(y / scale);
+          const dstI = (y * newWidth + x) * 4;
+          const [r, g, b, a] = getRgbaPixel(data, width, srcX, srcY, kind);
+          scaled[dstI] = r;
+          scaled[dstI + 1] = g;
+          scaled[dstI + 2] = b;
+          scaled[dstI + 3] = a;
+        }
+      }
+      width = newWidth;
+      height = newHeight;
+      const png2 = new PNG({ width, height });
+      Buffer.from(scaled.buffer, scaled.byteOffset, scaled.byteLength).copy(png2.data);
+      const pngBuffer2 = PNG.sync.write(png2);
+      return `data:image/png;base64,${pngBuffer2.toString("base64")}`;
+    }
+    let rgba;
+    if (kind === IMAGE_KIND_RGBA_32BPP) {
+      rgba = Uint8Array.from(
+        data instanceof Uint8ClampedArray ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : data
+      );
+    } else {
+      rgba = toRgbaBuffer(data, width, height, kind);
+    }
+    const png = new PNG({ width, height });
+    Buffer.from(rgba.buffer, rgba.byteOffset, rgba.byteLength).copy(png.data);
+    const pngBuffer = PNG.sync.write(png);
+    return `data:image/png;base64,${pngBuffer.toString("base64")}`;
+  } catch {
+    return null;
+  }
+}
+async function extractPageBlocks(page, pageIndex, pageCount, imageCounter, maxImages) {
+  const [textContent, opList] = await Promise.all([page.getTextContent(), page.getOperatorList()]);
+  const textItems = textContent.items.filter(
+    (item) => "str" in item
+  );
+  const textStr = textItems.map((t) => t.str).join(" ").trim();
+  const imageOpIndices = [];
+  for (let i = 0; i < opList.fnArray.length; i++) {
+    const op = opList.fnArray[i];
+    if (op === OPS.paintImageXObject || op === OPS.paintInlineImageXObject || op === OPS.paintImageMaskXObject || op === OPS.paintImageMaskXObjectGroup || op === OPS.paintImageXObjectRepeat || op === OPS.paintImageMaskXObjectRepeat || op === OPS.paintInlineImageXObjectGroup || op === OPS.paintSolidColorImageMask) {
+      imageOpIndices.push(i);
+    }
+  }
+  const blocks = [];
+  if (textStr) {
+    blocks.push({ type: "text", content: `[Page ${pageIndex}/${pageCount}]
+${textStr}` });
+  }
+  for (let imageOpIdx = 0; imageOpIdx < imageOpIndices.length; imageOpIdx++) {
+    if (imageCounter.count >= maxImages) {
+      imageCounter.limitReached = true;
+      break;
+    }
+    const opIdx = imageOpIndices[imageOpIdx];
+    if (opIdx === void 0) break;
+    const imgBlock = await extractImageBlock(page, opList, opIdx);
+    if (imgBlock) {
+      blocks.push(imgBlock);
+      imageCounter.count++;
+    }
+  }
+  return blocks;
+}
+function isValidPixelData(data) {
+  return data instanceof Uint8Array || data instanceof Uint8ClampedArray;
+}
+var IMAGE_RESOLVE_TIMEOUT_MS = 5e3;
+async function getObjectWithFallback(objs, objId) {
+  try {
+    return objs.get(objId);
+  } catch {
+  }
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => reject(new Error("timeout")), IMAGE_RESOLVE_TIMEOUT_MS);
+    try {
+      ;
+      objs.get(objId, (data) => {
+        clearTimeout(timeoutId);
+        resolve(data);
+      });
+    } catch (e) {
+      clearTimeout(timeoutId);
+      reject(e);
+    }
+  });
+}
+async function extractImageBlock(page, opList, opIdx) {
+  const args = opList.argsArray[opIdx];
+  const objId = Array.isArray(args) ? args[0] : void 0;
+  let imgData = null;
+  if (objId && typeof objId === "string") {
+    try {
+      const store = objId.startsWith("g_") ? page.commonObjs : page.objs;
+      const raw = await getObjectWithFallback(store, objId);
+      if (raw && typeof raw === "object" && "width" in raw && "height" in raw) {
+        const r = raw;
+        if (isValidPixelData(r["data"])) {
+          imgData = raw;
+        } else if (r["bitmap"] && !r["data"]) {
+          imgData = raw;
+        }
+      }
+    } catch {
+    }
+  } else if (Array.isArray(args) && args[0] && typeof args[0] === "object" && "width" in args[0]) {
+    const inline = args[0];
+    if (isValidPixelData(inline["data"])) {
+      imgData = args[0];
+    } else if (inline["bitmap"] && !inline["data"]) {
+      imgData = args[0];
+    }
+  }
+  if (imgData) {
+    const dataUrl = encodeImageToDataUrl(imgData);
+    if (dataUrl) {
+      return { type: "image", dataUrl };
+    }
+  }
+  return null;
+}
+async function extractPdfContent(buffer) {
   const doc = await getDocument({ data: Uint8Array.from(buffer) }).promise;
   const pageCount = doc.numPages;
-  const rawMeta = await doc.getMetadata();
-  const info = rawMeta.info;
-  const title = info?.["Title"] || null;
-  const author = info?.["Author"] || null;
-  const pages = [];
+  const allBlocks = [];
   const limitedPageCount = Math.min(pageCount, OUTPUT_LIMITS.read_file.maxPdfPages);
+  const maxImages = OUTPUT_LIMITS.read_file.maxPdfImages;
+  const imageCounter = { count: 0, limitReached: false };
+  let title = null;
+  let author = null;
+  try {
+    const rawMeta = await doc.getMetadata();
+    const info = rawMeta.info;
+    title = info?.["Title"] || null;
+    author = info?.["Author"] || null;
+  } catch {
+  }
   try {
     for (let i = 1; i <= limitedPageCount; i++) {
       const page = await doc.getPage(i);
       try {
-        const content = await page.getTextContent();
-        const pageText = content.items.map((item) => "str" in item ? item.str : "").join(" ");
-        pages.push(`[Page ${i}/${pageCount}]
-${pageText}`);
+        const blocks = await extractPageBlocks(page, i, pageCount, imageCounter, maxImages);
+        allBlocks.push(...blocks);
       } finally {
         page.cleanup();
       }
     }
+  } catch {
   } finally {
     doc.cleanup();
   }
-  let text = pages.join("\n\n");
   if (pageCount > limitedPageCount) {
-    text += `
+    allBlocks.push({
+      type: "text",
+      content: `[PDF has ${pageCount} pages, showing first ${limitedPageCount}. Use a shell command to process more.]`
+    });
+  }
+  if (imageCounter.limitReached) {
+    allBlocks.push({
+      type: "text",
+      content: `[Image limit reached: showing first ${maxImages} images out of more in this document.]`
+    });
+  }
+  return {
+    blocks: allBlocks,
+    pageCount,
+    title,
+    author,
+    imageCount: imageCounter.count,
+    imageLimitReached: imageCounter.limitReached
+  };
+}
+async function extractPdfText(buffer) {
+  const result = await extractPdfContent(buffer);
+  const text = result.blocks.filter((b) => b.type === "text").map((b) => b.content ?? "").join("\n\n");
+  return { text, pageCount: result.pageCount, title: result.title, author: result.author };
+}
 
-[PDF has ${pageCount} pages, showing first ${limitedPageCount}. Use a shell command to process more.]`;
+// src/server/utils/cache.ts
+import { createHash } from "crypto";
+function contentHash(data) {
+  return createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+function cacheSet(cache, key, value) {
+  const max = 50;
+  if (cache.size >= max) {
+    const first = cache.keys().next().value;
+    if (first !== void 0) cache.delete(first);
   }
-  return { text, pageCount, title, author };
+  cache.set(key, value);
 }
 
-// src/server/llm/resolve-attachments.ts
-function decodeDataUrlToText(data) {
+// src/server/utils/data-url.ts
+function decodeDataUrl(data) {
   const match = data.match(/^data:.*?;base64,(.+)$/);
-  if (match?.[1]) {
-    return Buffer.from(match[1], "base64").toString("utf8");
+  if (!match?.[1]) return null;
+  try {
+    return Buffer.from(match[1], "base64");
+  } catch {
+    return null;
   }
-  return data;
 }
+
+// src/server/llm/resolve-attachments.ts
+var pdfBlockCache = /* @__PURE__ */ new Map();
 async function extractPdfFromDataUrl(data, filename) {
   const base64Match = data.match(/^data:.*?;base64,(.+)$/);
   if (base64Match?.[1]) {
@@ -118,14 +351,50 @@ ${result.text}`;
   }
   return `[PDF: ${filename}] (could not extract text)`;
 }
+async function extractPdfBlocksFromDataUrl(data, filename) {
+  const cacheKey = contentHash(data);
+  const cached = pdfBlockCache.get(cacheKey);
+  if (cached) {
+    const result = [{ type: "text", text: `[PDF: ${filename}]` }];
+    result.push(...cached);
+    return result;
+  }
+  const base64Match = data.match(/^data:.*?;base64,(.+)$/);
+  if (!base64Match?.[1]) {
+    cacheSet(pdfBlockCache, cacheKey, []);
+    return [{ type: "text", text: `[PDF: ${filename}] (could not extract content)` }];
+  }
+  try {
+    const buffer = Buffer.from(base64Match[1], "base64");
+    const result = await extractPdfContent(buffer);
+    const body = [];
+    for (const block of result.blocks) {
+      if (block.type === "text" && block.content) {
+        body.push({ type: "text", text: block.content });
+      } else if (block.type === "image" && block.dataUrl) {
+        body.push({ type: "image_url", image_url: { url: block.dataUrl } });
+      }
+    }
+    cacheSet(pdfBlockCache, cacheKey, body);
+    const parts = [{ type: "text", text: `[PDF: ${filename}]` }];
+    parts.push(...body);
+    return parts;
+  } catch {
+    cacheSet(pdfBlockCache, cacheKey, []);
+    return [{ type: "text", text: `[PDF: ${filename}] (could not extract content)` }];
+  }
+}
 async function resolveAttachmentToText(attachment, supportsVision) {
   const mimeType = attachment.mimeType;
   if (TEXT_MIME_EXACT.includes(mimeType) || TEXT_MIME_PREFIXES.some((p) => mimeType.startsWith(p))) {
-    const text = decodeDataUrlToText(attachment.data);
+    const text = decodeDataUrl(attachment.data)?.toString("utf8") ?? attachment.data;
     return `[File: ${attachment.filename || "file"}]
 ${text}`;
   }
   if (mimeType === "application/pdf") {
+    if (attachment.pdfContent) {
+      return attachment.pdfContent;
+    }
     return extractPdfFromDataUrl(attachment.data, attachment.filename || "document.pdf");
   }
   if (supportsVision) {
@@ -136,6 +405,7 @@ ${text}`;
   }
   return `[Image: ${attachment.filename || "image"}] (vision not supported, cannot describe)`;
 }
+var isVisionAttachment = (attachment) => attachment.mimeType.startsWith("image/") || attachment.mimeType === "application/pdf";
 async function resolveAttachmentsInMessages(messages, supportsVision) {
   const result = [];
   for (const msg of messages) {
@@ -143,7 +413,7 @@ async function resolveAttachmentsInMessages(messages, supportsVision) {
       result.push(msg);
       continue;
     }
-    if (supportsVision && msg.attachments.every((a) => a.mimeType.startsWith("image/"))) {
+    if (supportsVision && msg.attachments.every(isVisionAttachment)) {
       result.push(msg);
       continue;
     }
@@ -151,7 +421,7 @@ async function resolveAttachmentsInMessages(messages, supportsVision) {
     if (msg.content?.trim()) parts.push(msg.content);
     const remainingImageAttachments = [];
     for (const attachment of msg.attachments) {
-      if (supportsVision && attachment.mimeType.startsWith("image/")) {
+      if (supportsVision && isVisionAttachment(attachment)) {
         remainingImageAttachments.push(attachment);
         continue;
       }
@@ -197,8 +467,8 @@ async function buildAttachmentContent(msgContent, attachments, modelSupportsVisi
     content.push({ type: "text", text: msgContent });
   }
   for (const attachment of attachments) {
-    const converted = await convertAttachment(attachment, modelSupportsVision);
-    content.push(converted);
+    const parts = await convertAttachment(attachment, modelSupportsVision);
+    content.push(...parts);
   }
   return content;
 }
@@ -222,7 +492,7 @@ function getThinking(msg, override) {
 function buildAssistantMessage(msg, thinkingField) {
   const result = {
     role: "assistant",
-    content: msg.content || null
+    content: msg.toolCalls?.length ? msg.content || "" : msg.content || null
   };
   if (msg.toolCalls?.length) {
     result["tool_calls"] = convertToolCalls(msg.toolCalls);
@@ -235,32 +505,28 @@ function buildAssistantMessage(msg, thinkingField) {
 async function convertAttachment(attachment, modelSupportsVision) {
   const mimeType = attachment.mimeType;
   if (TEXT_MIME_EXACT.includes(mimeType) || TEXT_MIME_PREFIXES.some((p) => mimeType.startsWith(p))) {
-    return {
-      type: "text",
-      text: `[File: ${attachment.filename || "file"}]
-${attachment.data}`
-    };
+    return [{ type: "text", text: `[File: ${attachment.filename || "file"}]
+${attachment.data}` }];
   }
   if (mimeType === "application/pdf") {
+    if (modelSupportsVision) {
+      return extractPdfBlocksFromDataUrl(attachment.data, attachment.filename || "document.pdf");
+    }
+    if (attachment.pdfContent) {
+      return [{ type: "text", text: attachment.pdfContent }];
+    }
     const text = await extractPdfFromDataUrl(attachment.data, attachment.filename || "document.pdf");
-    return { type: "text", text };
+    return [{ type: "text", text }];
   }
   if (modelSupportsVision) {
-    return {
-      type: "image_url",
-      image_url: { url: attachment.data }
-    };
+    return [{ type: "image_url", image_url: { url: attachment.data } }];
   }
   if (attachment.description) {
-    return {
-      type: "text",
-      text: `[Image: ${attachment.filename || "image"} - description: ${attachment.description}]`
-    };
+    return [
+      { type: "text", text: `[Image: ${attachment.filename || "image"} - description: ${attachment.description}]` }
+    ];
   }
-  return {
-    type: "text",
-    text: `[Image: ${attachment.filename || "image"}] (vision not supported, cannot describe)`
-  };
+  return [{ type: "text", text: `[Image: ${attachment.filename || "image"}] (vision not supported, cannot describe)` }];
 }
 async function convertMessages(messages, modelSupportsVision, thinkingField) {
   const filtered = messages.filter((msg) => {
@@ -398,7 +664,11 @@ export {
   isPdfBuffer,
   formatPdfErrorMessage,
   processPdfContent,
+  extractPdfContent,
   extractPdfText,
+  contentHash,
+  cacheSet,
+  decodeDataUrl,
   resolveAttachmentsInMessages,
   parseToolArguments,
   buildModelParams,
@@ -409,4 +679,4 @@ export {
   buildStreamingCreateParams,
   mapFinishReason
 };
-//# sourceMappingURL=chunk-EZK7CGJ7.js.map
+//# sourceMappingURL=chunk-RMXPVQP4.js.map