@wrongstack/core 0.285.0 → 0.287.0

package/dist/utils/index.js

@@ -10,6 +10,7 @@ function assertNever(x, message) {
 // src/utils/atomic-write.ts
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
+import { watch as watchDir } from "node:fs";
 import * as path from "node:path";
 
 // src/types/errors.ts
@@ -181,7 +182,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
         await fs.mkdir(dir, { recursive: true });
         continue;
       }
-      if (code !== "EEXIST") throw err;
+      if (code !== "EEXIST" && code !== "EPERM") throw err;
       try {
         const stat3 = await fs.stat(lockPath);
         if (Date.now() - stat3.mtimeMs > staleMs) {
@@ -191,7 +192,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       } catch {
         continue;
       }
-      if (Date.now() - started >= timeoutMs) {
+      const elapsed = Date.now() - started;
+      if (elapsed >= timeoutMs) {
         throw new FsError({
           message: `Timed out waiting for file lock: ${targetPath}`,
           code: "FS_ATOMIC_WRITE_FAILED",
@@ -199,7 +201,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
           context: { timeoutMs }
         });
       }
-      await new Promise((resolve5) => setTimeout(resolve5, 25));
+      await waitForLockRelease(lockPath, timeoutMs - elapsed);
     }
   }
   try {
@@ -215,6 +217,50 @@ async function withFileLock(targetPath, fn, opts = {}) {
     }
   }
 }
+async function waitForLockRelease(lockPath, remainingMs) {
+  const parentDir = path.dirname(lockPath);
+  const lockName = path.basename(lockPath);
+  const intervalMs = Math.min(remainingMs, 100);
+  return new Promise((resolve5) => {
+    let settled = false;
+    let watcher = null;
+    const timer = setTimeout(() => {
+      settled = true;
+      watcher?.close();
+      resolve5();
+    }, intervalMs);
+    try {
+      watcher = watchDir(parentDir, (eventType, filename) => {
+        if (settled) return;
+        if (filename === lockName && (eventType === "rename" || eventType === "change")) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve5();
+        }
+      });
+    } catch {
+      clearTimeout(timer);
+      if (!settled) {
+        settled = true;
+        setTimeout(resolve5, Math.min(remainingMs, 25));
+      }
+      return;
+    }
+    fs.access(lockPath).then(
+      () => {
+      },
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve5();
+        }
+      }
+    );
+  });
+}
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
@@ -1237,9 +1283,17 @@ function globToRegex(pat) {
   return new RegExp(re + "$");
 }
 function baseDir(pat) {
-  let i = pat.length - 1;
-  while (i >= 0 && !GLOB_CHARS.has(expectDefined(pat[i])) && pat[i] !== SEP && pat[i] !== "/") i--;
-  const cut = i >= 0 ? pat.lastIndexOf(SEP, i) : pat.lastIndexOf("/", i);
+  let firstGlob = pat.length;
+  for (let i = 0; i < pat.length; i++) {
+    if (GLOB_CHARS.has(expectDefined(pat[i]))) {
+      firstGlob = i;
+      break;
+    }
+  }
+  const cut = Math.max(
+    pat.lastIndexOf(SEP, firstGlob - 1),
+    pat.lastIndexOf("/", firstGlob - 1)
+  );
   return cut < 0 ? "." : pat.slice(0, cut);
 }
 async function expandGlob(pattern) {
@@ -1384,6 +1438,71 @@ function matchAny(patterns, input) {
   return patterns.some((p) => matchGlob(p, input));
 }
 
+// src/utils/incoming-images.ts
+var MAX_INCOMING_IMAGES = 8;
+var MAX_INCOMING_IMAGE_BYTES = 8 * 1024 * 1024;
+var ALLOWED_IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif"
+]);
+var IncomingImageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IncomingImageError";
+  }
+};
+var DATA_URL_RE = /^data:([a-z0-9.+-]+\/[a-z0-9.+-]+)?(?:;[a-z0-9-]+=[^;,]*)*(;base64)?,/i;
+function splitDataUrl(data) {
+  const match = DATA_URL_RE.exec(data);
+  if (!match) return { base64: data.trim() };
+  return {
+    base64: data.slice(match[0].length).trim(),
+    mediaType: match[1]?.toLowerCase()
+  };
+}
+function parseIncomingImages(images, legacyImageBase64) {
+  const raw = [...images ?? []];
+  if (legacyImageBase64) raw.push({ data: legacyImageBase64 });
+  if (raw.length === 0) return [];
+  if (raw.length > MAX_INCOMING_IMAGES) {
+    throw new IncomingImageError(
+      `Too many images: ${raw.length} (max ${MAX_INCOMING_IMAGES} per message).`
+    );
+  }
+  return raw.map((img, i) => {
+    const { base64, mediaType: fromUrl } = splitDataUrl(img.data ?? "");
+    const mediaType = (img.mediaType ?? fromUrl ?? "image/png").toLowerCase();
+    if (!ALLOWED_IMAGE_MEDIA_TYPES.has(mediaType)) {
+      throw new IncomingImageError(
+        `Image ${i + 1}: unsupported media type "${mediaType}" (allowed: ${[...ALLOWED_IMAGE_MEDIA_TYPES].join(", ")}).`
+      );
+    }
+    if (!base64) {
+      throw new IncomingImageError(`Image ${i + 1}: empty image data.`);
+    }
+    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(base64)) {
+      throw new IncomingImageError(`Image ${i + 1}: data is not valid base64.`);
+    }
+    const bytes = Math.floor(base64.length * 3 / 4);
+    if (bytes > MAX_INCOMING_IMAGE_BYTES) {
+      throw new IncomingImageError(
+        `Image ${i + 1}: ${(bytes / (1024 * 1024)).toFixed(1)} MB exceeds the ${MAX_INCOMING_IMAGE_BYTES / (1024 * 1024)} MB limit.`
+      );
+    }
+    return {
+      type: "image",
+      source: { type: "base64", media_type: mediaType, data: base64 }
+    };
+  });
+}
+function buildUserContentBlocks(text, images) {
+  const blocks = [...images];
+  if (text) blocks.push({ type: "text", text });
+  return blocks;
+}
+
 // src/utils/ip-guard.ts
 import * as dns from "node:dns/promises";
 import * as net from "node:net";
@@ -2343,8 +2462,8 @@ function subjectForToolInput(toolName, input, subjectKey) {
 }
 
 // src/utils/tool-wire-compact.ts
-var TOOL_DESCRIPTION_MAX_CHARS = 640;
-var SCHEMA_DESCRIPTION_MAX_CHARS = 180;
+var TOOL_DESCRIPTION_MAX_CHARS = 400;
+var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
 var compactCache = /* @__PURE__ */ new WeakMap();
 function compactToolDefinitionForWire(tool, opts = {}) {
   const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
@@ -3418,14 +3537,34 @@ function applyToolResultRenderModes(registry, modes) {
 
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
+import * as fs3 from "node:fs";
 import * as os from "node:os";
 import * as path4 from "node:path";
+function canonicalProjectRoot(absRoot) {
+  const checkoutRoot = path4.resolve(absRoot);
+  const dotGit = path4.join(checkoutRoot, ".git");
+  try {
+    if (!fs3.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs3.readFileSync(dotGit, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
+    if (!match?.[1]) return checkoutRoot;
+    const gitDir = path4.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path4.join(gitDir, "commondir");
+    if (!fs3.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path4.resolve(gitDir, fs3.readFileSync(commonDirFile, "utf8").trim());
+    if (path4.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path4.dirname(commonDir);
+  } catch {
+    return checkoutRoot;
+  }
+}
 function projectHash(absRoot) {
-  return createHash("sha256").update(path4.resolve(absRoot)).digest("hex").slice(0, 12);
+  return createHash("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
 }
 function projectSlug(absRoot) {
-  const base = slugify2(path4.basename(absRoot));
-  const hash = createHash("sha256").update(path4.resolve(absRoot)).digest("hex").slice(0, 6);
+  const identityRoot = canonicalProjectRoot(absRoot);
+  const base = slugify2(path4.basename(identityRoot));
+  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify2(name) {
@@ -3495,6 +3634,9 @@ export {
   DEFAULT_TOOL_DESCRIPTION_MODE,
   DEFAULT_TOOL_RESULT_RENDER_MODE,
   FORBIDDEN_PROTO_KEYS,
+  IncomingImageError,
+  MAX_INCOMING_IMAGES,
+  MAX_INCOMING_IMAGE_BYTES,
   applyToolDescriptionModeToTool,
   applyToolDescriptionModes,
   applyToolResultRenderModes,
@@ -3504,6 +3646,8 @@ export {
   buildChildEnv,
   buildCompletedWorkLedgerBlock,
   buildContextEvidenceDigest,
+  buildUserContentBlocks,
+  canonicalProjectRoot,
   coerceAgainstSchema,
   color,
   compactSchemaDescriptions,
@@ -3561,6 +3705,7 @@ export {
   normalizeToolDescriptionMode,
   normalizeToolResultRenderMode,
   onResize,
+  parseIncomingImages,
   projectHash,
   projectSlug,
   readJsonObjectFile,