@makerbi/remodex 1.5.4 → 1.5.8

package/src/workspace-handler.js

@@ -1,5 +1,5 @@
 // FILE: workspace-handler.js
-// Purpose: Executes workspace-scoped reverse patch previews/applies without touching unrelated repo changes.
+// Purpose: Executes workspace-scoped previews, reads, and patch operations without touching unrelated repo changes.
 // Layer: Bridge handler
 // Exports: handleWorkspaceRequest
 // Depends on: child_process, fs, os, path, ./codex-home, ./git-handler
@@ -8,7 +8,7 @@ const { execFile } = require("child_process");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-const { promisify } = require("util");
+const { promisify, TextDecoder } = require("util");
 const { resolveCodexGeneratedImagesRoot } = require("./codex-home");
 const { gitStatus } = require("./git-handler");
 const {
@@ -23,6 +23,9 @@ const execFileAsync = promisify(execFile);
 const GIT_TIMEOUT_MS = 30_000;
 const MAX_IMAGE_READ_BYTES = 8 * 1024 * 1024;
 const MAX_IMAGE_PREVIEW_READ_BYTES = 2 * 1024 * 1024;
+const MAX_TEXT_FILE_READ_BYTES = 2 * 1024 * 1024;
+const BINARY_SNIFF_BYTES = 8 * 1024;
+const MAX_BASENAME_FALLBACK_MATCHES = 2;
 const MIN_IMAGE_PREVIEW_PIXEL_DIMENSION = 128;
 const MAX_IMAGE_PREVIEW_PIXEL_DIMENSION = 3_200;
 const IMAGE_PREVIEW_RETRY_SCALE = 0.75;
@@ -32,6 +35,7 @@ const IMAGE_MIME_TYPES_BY_EXTENSION = new Map([
   [".jpg", "image/jpeg"],
   [".jpeg", "image/jpeg"],
   [".png", "image/png"],
+  [".svg", "image/svg+xml"],
   [".gif", "image/gif"],
   [".webp", "image/webp"],
   [".heic", "image/heic"],
@@ -83,6 +87,9 @@ async function handleWorkspaceMethod(method, params) {
   if (method === "workspace/readImage") {
     return workspaceReadImage(params);
   }
+  if (method === "workspace/readFile") {
+    return workspaceReadFile(params);
+  }
 
   const cwd = await resolveWorkspaceCwd(params);
   const repoRoot = await resolveRepoRoot(cwd);
@@ -111,6 +118,60 @@ async function handleWorkspaceMethod(method, params) {
   }
 }
 
+// Reads a UTF-8 text file from the active workspace for the phone-side read-only viewer.
+async function workspaceReadFile(params) {
+  const requestedPath = firstNonEmptyString([params.path, params.filePath, params.localPath]);
+  if (!requestedPath) {
+    throw workspaceError("missing_file_path", "The request must include a file path.");
+  }
+
+  const cwd = await resolveWorkspaceCwd(params);
+  const realWorkspaceRoot = await resolveReadableWorkspaceRoot(cwd);
+  const realFilePath = await resolveWorkspaceTextFilePath(cwd, requestedPath, realWorkspaceRoot);
+  if (!realFilePath) {
+    throw workspaceError("file_not_found", "The file no longer exists on this Mac.");
+  }
+  if (!realWorkspaceRoot || !isPathInside(realFilePath, realWorkspaceRoot)) {
+    throw workspaceError("file_path_not_allowed", "Only files in the current workspace can be viewed.");
+  }
+
+  const stat = await fs.promises.stat(realFilePath);
+  if (!stat.isFile()) {
+    throw workspaceError("file_not_found", "The path is not a file.");
+  }
+  if (stat.size > MAX_TEXT_FILE_READ_BYTES) {
+    throw workspaceError(
+      "file_too_large",
+      "This file is too large to send to the phone. Open it on the Mac or ask for a smaller section."
+    );
+  }
+
+  const result = {
+    path: realFilePath,
+    fileName: path.basename(realFilePath),
+    byteLength: stat.size,
+    mtimeMs: stat.mtimeMs,
+    encoding: "utf-8",
+  };
+  if (params.includeContent === false || params.metadataOnly === true) {
+    return result;
+  }
+  if (isUnchangedTextFileRead(params, stat)) {
+    return {
+      ...result,
+      notModified: true,
+    };
+  }
+
+  const data = await fs.promises.readFile(realFilePath);
+  const content = decodeUtf8TextFile(data);
+  return {
+    ...result,
+    content,
+    lineCount: countLines(content),
+  };
+}
+
 // Reads recognized local image files from the bound repo, Codex image cache, or host temp screenshot folders.
 async function workspaceReadImage(params) {
   const requestedPath = firstNonEmptyString([params.path, params.filePath, params.localPath]);
@@ -125,10 +186,7 @@ async function workspaceReadImage(params) {
     ? path.resolve(requestedPath)
     : path.resolve(cwd || process.cwd(), requestedPath);
   const extension = path.extname(imagePath).toLowerCase();
-  const mimeType = IMAGE_MIME_TYPES_BY_EXTENSION.get(extension);
-  if (!mimeType) {
-    throw workspaceError("unsupported_image_type", "Only local image files can be previewed.");
-  }
+  let mimeType = IMAGE_MIME_TYPES_BY_EXTENSION.get(extension);
 
   const [realImagePath, realGeneratedImagesRoot] = await Promise.all([
     realpathOrNull(imagePath),
@@ -154,6 +212,12 @@ async function workspaceReadImage(params) {
   if (!stat.isFile()) {
     throw workspaceError("image_not_found", "The image path is not a file.");
   }
+  if (!mimeType) {
+    mimeType = await sniffImageMimeType(realImagePath);
+  }
+  if (!mimeType) {
+    throw workspaceError("unsupported_image_type", "Only local image files can be previewed.");
+  }
   const includeData = params.includeData !== false && params.metadataOnly !== true;
   const maxPixelDimension = normalizedPreviewPixelDimension(params);
   if (stat.size > MAX_IMAGE_READ_BYTES && !maxPixelDimension) {
@@ -181,7 +245,9 @@ async function workspaceReadImage(params) {
     };
   }
 
-  const data = maxPixelDimension
+  const data = mimeType === "image/svg+xml"
+    ? await readSVGPreviewData(realImagePath, stat.size)
+    : maxPixelDimension
     ? await readPreviewImageData(realImagePath, maxPixelDimension, stat.size)
     : await fs.promises.readFile(realImagePath);
   return {
@@ -202,6 +268,45 @@ function normalizedPreviewPixelDimension(params) {
   );
 }
 
+async function sniffImageMimeType(filePath) {
+  let header;
+  try {
+    const handle = await fs.promises.open(filePath, "r");
+    try {
+      header = Buffer.alloc(512);
+      const read = await handle.read(header, 0, header.length, 0);
+      header = header.subarray(0, read.bytesRead);
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return null;
+  }
+
+  if (header.length >= 8 && header.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+    return "image/png";
+  }
+  if (header.length >= 3 && header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff) {
+    return "image/jpeg";
+  }
+  if (header.length >= 6 && (header.subarray(0, 6).toString("ascii") === "GIF87a" || header.subarray(0, 6).toString("ascii") === "GIF89a")) {
+    return "image/gif";
+  }
+  if (header.length >= 12 && header.subarray(0, 4).toString("ascii") === "RIFF" && header.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  if (looksLikeSVGHeader(header)) {
+    return "image/svg+xml";
+  }
+
+  return null;
+}
+
+function looksLikeSVGHeader(header) {
+  const sample = header.toString("utf8").replace(/^\uFEFF/, "").trimStart().toLowerCase();
+  return sample.startsWith("<svg") || (sample.startsWith("<?xml") && sample.includes("<svg"));
+}
+
 async function realTemporaryImageRoots() {
   const candidates = [
     os.tmpdir(),
@@ -210,6 +315,9 @@ async function realTemporaryImageRoots() {
 
   if (process.platform === "darwin") {
     candidates.push("/tmp");
+    candidates.push(path.join(os.homedir(), "Library", "Caches", "com.raycast-x.macos", "clipboard"));
+    candidates.push(path.join(os.homedir(), "Library", "Application Support", "CleanShot", "media"));
+    candidates.push(path.join(os.homedir(), "Library", "Application Support", "CleanShot X", "media"));
   }
 
   const roots = await Promise.all(
@@ -218,8 +326,8 @@ async function realTemporaryImageRoots() {
   return Array.from(new Set(roots.filter(Boolean)));
 }
 
-// Image previews are read-only, so non-git Codex scratch workspaces can be scoped to their cwd.
-async function resolveImageWorkspaceRoot(cwd) {
+// Read-only previews can scope non-git Codex scratch folders to cwd while rejecting broad roots.
+async function resolveReadableWorkspaceRoot(cwd) {
   const realRepoRoot = await resolveRepoRoot(cwd).then(realpathOrNull).catch(() => null);
   if (realRepoRoot) {
     return realRepoRoot;
@@ -232,14 +340,99 @@ async function resolveImageWorkspaceRoot(cwd) {
   return realCwd;
 }
 
+async function resolveImageWorkspaceRoot(cwd) {
+  return resolveReadableWorkspaceRoot(cwd);
+}
+
+// Handles assistant links that only include a filename by finding one unique workspace match.
+async function resolveWorkspaceTextFilePath(cwd, requestedPath, realWorkspaceRoot) {
+  const filePath = path.isAbsolute(requestedPath)
+    ? path.resolve(requestedPath)
+    : path.resolve(cwd, requestedPath);
+  const realFilePath = await realpathOrNull(filePath);
+  if (realFilePath || path.isAbsolute(requestedPath) || !realWorkspaceRoot) {
+    return realFilePath;
+  }
+
+  if (!isBareFileName(requestedPath)) {
+    return null;
+  }
+
+  return resolveUniqueWorkspaceBasenameMatch(realWorkspaceRoot, requestedPath);
+}
+
+async function resolveUniqueWorkspaceBasenameMatch(realWorkspaceRoot, requestedFileName) {
+  const matches = await findWorkspaceBasenameMatches(realWorkspaceRoot, requestedFileName);
+  if (matches.length === 0) {
+    return null;
+  }
+  if (matches.length > 1) {
+    throw workspaceError(
+      "file_path_ambiguous",
+      `Multiple files named "${requestedFileName}" exist in this workspace. Use a path with folders.`
+    );
+  }
+  return matches[0];
+}
+
+async function findWorkspaceBasenameMatches(realWorkspaceRoot, requestedFileName) {
+  const matches = [];
+  const output = await git(realWorkspaceRoot, "ls-files", "-co", "--exclude-standard").catch(() => "");
+  const relativePaths = output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  for (const relativePath of relativePaths) {
+    if (path.basename(relativePath) !== requestedFileName) {
+      continue;
+    }
+    const realCandidate = await realpathOrNull(path.resolve(realWorkspaceRoot, relativePath));
+    if (realCandidate && isPathInside(realCandidate, realWorkspaceRoot)) {
+      matches.push(realCandidate);
+      if (matches.length >= MAX_BASENAME_FALLBACK_MATCHES) {
+        break;
+      }
+    }
+  }
+  return matches;
+}
+
+function isBareFileName(candidatePath) {
+  return candidatePath === path.basename(candidatePath)
+    && candidatePath !== "."
+    && candidatePath !== "..";
+}
+
 function isBroadWorkspaceRoot(candidatePath) {
   const normalized = path.resolve(candidatePath);
   return normalized === path.parse(normalized).root
     || normalized === path.resolve(os.homedir());
 }
 
+function decodeUtf8TextFile(data) {
+  const sample = data.subarray(0, Math.min(data.length, BINARY_SNIFF_BYTES));
+  if (sample.includes(0)) {
+    throw workspaceError("binary_file", "This file looks binary, so it cannot be shown as text.");
+  }
+
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(data);
+  } catch {
+    throw workspaceError("unsupported_text_encoding", "Only UTF-8 text files can be viewed.");
+  }
+}
+
+function countLines(content) {
+  if (!content) {
+    return 0;
+  }
+  const newlineCount = (content.match(/\n/g) || []).length;
+  return content.endsWith("\n") ? newlineCount : newlineCount + 1;
+}
+
 async function readPreviewImageData(imagePath, maxPixelDimension, originalByteLength) {
-  if (!usesSipsImagePreview()) {
+  if (!usesNativeImagePreview()) {
     if (originalByteLength <= MAX_IMAGE_PREVIEW_READ_BYTES) {
       return fs.promises.readFile(imagePath);
     }
@@ -262,7 +455,7 @@ async function readPreviewImageData(imagePath, maxPixelDimension, originalByteLe
     }
 
     try {
-      const previewData = await downsampleImageWithSips(
+      const previewData = await downsampleImageNative(
         imagePath,
         candidateDimension,
         Math.min(IMAGE_PREVIEW_TOOL_TIMEOUT_MS, remainingTimeoutMs)
@@ -294,6 +487,17 @@ async function readPreviewImageData(imagePath, maxPixelDimension, originalByteLe
   );
 }
 
+// SVGs are already compact vector source; send them as-is so the phone can render them in WebKit.
+async function readSVGPreviewData(imagePath, originalByteLength) {
+  if (originalByteLength > MAX_IMAGE_PREVIEW_READ_BYTES) {
+    throw workspaceError(
+      "image_too_large",
+      "This SVG is too large to send to the phone. Open it on the Mac or move a smaller preview into the workspace."
+    );
+  }
+  return fs.promises.readFile(imagePath);
+}
+
 function previewPixelDimensionCandidates(maxPixelDimension) {
   const dimensions = [];
   let next = maxPixelDimension;
@@ -318,18 +522,118 @@ function previewPixelDimensionCandidates(maxPixelDimension) {
   return Array.from(new Set(dimensions)).sort((a, b) => b - a);
 }
 
-function usesSipsImagePreview() {
+function usesNativeImagePreview() {
+  const normalizedPlatform = String(process.platform || "").trim().toLowerCase();
+  return normalizedPlatform === "darwin"
+    || normalizedPlatform === "macos"
+    || normalizedPlatform === "mac"
+    || normalizedPlatform === "win32"
+    || normalizedPlatform === "windows";
+}
+
+async function downsampleImageNative(imagePath, maxPixelDimension, timeoutMs = IMAGE_PREVIEW_TOOL_TIMEOUT_MS) {
+  return usesWindowsImagePreview()
+    ? downsampleImageWithPowerShell(imagePath, maxPixelDimension, timeoutMs)
+    : downsampleImageWithSips(imagePath, maxPixelDimension, timeoutMs);
+}
+
+function usesWindowsImagePreview() {
   const normalizedPlatform = String(process.platform || "").trim().toLowerCase();
-  return normalizedPlatform === "darwin" || normalizedPlatform === "macos" || normalizedPlatform === "mac";
+  return normalizedPlatform === "win32" || normalizedPlatform === "windows";
 }
 
 async function downsampleImageWithSips(imagePath, maxPixelDimension, timeoutMs = IMAGE_PREVIEW_TOOL_TIMEOUT_MS) {
   const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "remodex-image-preview-"));
   const outputPath = path.join(tempDir, `preview${path.extname(imagePath) || ".png"}`);
+  const command = resolveHostCommand("sips");
+  try {
+    await execFileAsync(command.file, [
+      ...command.args,
+      "-Z",
+      String(maxPixelDimension),
+      imagePath,
+      "--out",
+      outputPath,
+    ], {
+      timeout: Math.max(1, Math.floor(timeoutMs)),
+      maxBuffer: 1024 * 1024,
+    });
+    return await fs.promises.readFile(outputPath);
+  } finally {
+    await fs.promises.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+function resolveHostCommand(commandName) {
+  if (path.delimiter !== ";") {
+    return { file: commandName, args: [] };
+  }
+
+  const pathEntries = String(process.env.PATH || "")
+    .split(path.delimiter)
+    .filter(Boolean);
+  for (const entry of pathEntries) {
+    const jsShim = path.join(entry, `${commandName}.js`);
+    if (fs.existsSync(jsShim)) {
+      return { file: process.execPath, args: [jsShim] };
+    }
+  }
+  return { file: commandName, args: [] };
+}
+
+async function downsampleImageWithPowerShell(imagePath, maxPixelDimension, timeoutMs = IMAGE_PREVIEW_TOOL_TIMEOUT_MS) {
+  const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "remodex-image-preview-"));
+  const outputPath = path.join(tempDir, `preview${path.extname(imagePath) || ".png"}`);
+  const scriptPath = path.join(tempDir, "resize-preview.ps1");
+  const script = `
+param(
+  [Parameter(Mandatory=$true)][string]$InputPath,
+  [Parameter(Mandatory=$true)][string]$OutputPath,
+  [Parameter(Mandatory=$true)][int]$MaxDimension
+)
+Add-Type -AssemblyName System.Drawing
+$image = [System.Drawing.Image]::FromFile($InputPath)
+try {
+  $longest = [Math]::Max($image.Width, $image.Height)
+  if ($longest -le 0) { throw "Invalid image dimensions." }
+  $scale = [Math]::Min(1.0, [double]$MaxDimension / [double]$longest)
+  $targetWidth = [Math]::Max(1, [int][Math]::Round($image.Width * $scale))
+  $targetHeight = [Math]::Max(1, [int][Math]::Round($image.Height * $scale))
+  $bitmap = New-Object System.Drawing.Bitmap $targetWidth, $targetHeight
+  try {
+    $graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+    try {
+      $graphics.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
+      $graphics.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::HighQuality
+      $graphics.PixelOffsetMode = [System.Drawing.Drawing2D.PixelOffsetMode]::HighQuality
+      $graphics.DrawImage($image, 0, 0, $targetWidth, $targetHeight)
+    } finally {
+      $graphics.Dispose()
+    }
+    $bitmap.Save($OutputPath, [System.Drawing.Imaging.ImageFormat]::Png)
+  } finally {
+    if ($bitmap) { $bitmap.Dispose() }
+  }
+} finally {
+  $image.Dispose()
+}
+`;
   try {
-    await execFileAsync("sips", ["-Z", String(maxPixelDimension), imagePath, "--out", outputPath], {
+    await fs.promises.writeFile(scriptPath, script, "utf8");
+    await execFileAsync("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptPath,
+      imagePath,
+      outputPath,
+      String(maxPixelDimension),
+    ], {
       timeout: Math.max(1, Math.floor(timeoutMs)),
       maxBuffer: 1024 * 1024,
+      windowsHide: true,
     });
     return await fs.promises.readFile(outputPath);
   } finally {
@@ -357,6 +661,15 @@ function isUnchangedImageRead(params, stat, maxPixelDimension) {
     && cachedMtimeMs === stat.mtimeMs;
 }
 
+function isUnchangedTextFileRead(params, stat) {
+  const cachedByteLength = Number(params.ifByteLength);
+  const cachedMtimeMs = Number(params.ifMtimeMs);
+  return Number.isFinite(cachedByteLength)
+    && Number.isFinite(cachedMtimeMs)
+    && cachedByteLength === stat.size
+    && cachedMtimeMs === stat.mtimeMs;
+}
+
 // Validates the reverse patch against the current tree without writing repo files.
 async function workspaceRevertPatchPreview(repoRoot, params) {
   const forwardPatch = resolveForwardPatch(params);