@yeaft/webchat-agent 1.0.518 → 1.0.520

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.518",
+  "version": "1.0.520",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/workbench/file-ops.js

@@ -1,6 +1,6 @@
-import { readFile, writeFile, readdir, stat, unlink, rename, mkdir, rm, copyFile, cp } from 'fs/promises';
+import { readFile, realpath, writeFile, readdir, stat, unlink, rename, mkdir, rm, copyFile, cp } from 'fs/promises';
 import { existsSync } from 'fs';
-import { join, basename, dirname, extname } from 'path';
+import { join, basename, dirname, extname, isAbsolute, relative, resolve } from 'path';
 import { platform } from 'os';
 import ctx from '../context.js';
 import { resolveAndValidatePath, BINARY_EXTENSIONS } from './utils.js';
@@ -9,6 +9,19 @@ import { sendWorkbenchResult } from './request-routing.js';
 export const MAX_WORKBENCH_PREVIEW_BYTES = 20 * 1024 * 1024;
 export const WORKBENCH_FILE_CHUNK_BYTES = 1024 * 1024;
 
+async function validateResponseImagePath(filePath, workDir) {
+  const canonicalRoot = await realpath(resolve(workDir));
+  const canonicalFile = await realpath(resolveAndValidatePath(filePath, canonicalRoot));
+  const relativePath = relative(canonicalRoot, canonicalFile);
+  const outside = relativePath === '..'
+    || relativePath.startsWith(`..${platform() === 'win32' ? '\\' : '/'}`)
+    || isAbsolute(relativePath);
+  if (outside) throw new Error('Response image is outside the active workspace.');
+  const mimeType = BINARY_EXTENSIONS[extname(canonicalFile).toLowerCase()];
+  if (!mimeType?.startsWith('image/')) throw new Error('Response preview only supports image files.');
+  return canonicalFile;
+}
+
 async function reportFileTransferDropped(msg, base) {
   const errorResult = {
     ...base,
@@ -64,7 +77,9 @@ export async function handleReadFile(msg) {
   const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
 
   try {
-    const resolved = resolveAndValidatePath(filePath, workDir);
+    const resolved = msg.responseImagePreview
+      ? await validateResponseImagePath(filePath, workDir)
+      : resolveAndValidatePath(filePath, workDir);
     const ext = extname(resolved).toLowerCase();
     const mimeType = BINARY_EXTENSIONS[ext];
 

package/workbench/file-reference-resolver.js

@@ -1,5 +1,5 @@
-import { readdir, stat } from 'node:fs/promises';
-import { basename, join, relative, resolve } from 'node:path';
+import { readdir, realpath, stat } from 'node:fs/promises';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
 import { platform } from 'node:os';
 import ctx from '../context.js';
 import { resolveAndValidatePath } from './utils.js';
@@ -10,15 +10,28 @@ const MAX_SCANNED_ENTRIES = 5000;
 const MAX_DEPTH = 10;
 const SKIP_DIRS = new Set(['.git', 'node_modules', '__pycache__', '.next', '.nuxt', 'dist', 'build', '.cache', 'bin', 'obj']);
 
-async function isFile(path) {
-  try { return (await stat(path)).isFile(); } catch { return false; }
-}
-
 function comparable(value) {
   const normalized = String(value || '').replaceAll('\\', '/');
   return platform() === 'win32' ? normalized.toLowerCase() : normalized;
 }
 
+function isInsideWorkspace(root, candidate) {
+  const relativePath = relative(root, candidate);
+  return relativePath === '' || (relativePath !== '..'
+    && !relativePath.startsWith(`..${platform() === 'win32' ? '\\' : '/'}`)
+    && !isAbsolute(relativePath));
+}
+
+async function canonicalWorkspaceFile(candidate, canonicalRoot) {
+  try {
+    const canonicalPath = await realpath(candidate);
+    if (!isInsideWorkspace(canonicalRoot, canonicalPath) || !(await stat(canonicalPath)).isFile()) return null;
+    return canonicalPath;
+  } catch {
+    return null;
+  }
+}
+
 async function findUniqueBasenames(workDir, requestedPaths, {
   maxScannedEntries = MAX_SCANNED_ENTRIES,
   maxDepth = MAX_DEPTH,
@@ -67,24 +80,30 @@ export async function resolveFileReferences(references, workDir, scanOptions) {
   const unique = [...new Set((Array.isArray(references) ? references : [])
     .map(value => typeof value === 'string' ? value.trim() : '')
     .filter(Boolean))].slice(0, MAX_REFERENCES);
-  const exactMatches = await Promise.all(unique.map(async requestedPath => {
-    const exactPath = resolveAndValidatePath(requestedPath, workDir);
-    return await isFile(exactPath) ? exactPath : null;
-  }));
-  const unresolved = unique.filter((_path, index) => !exactMatches[index]);
-  const basenameScan = await findUniqueBasenames(workDir, unresolved, scanOptions);
   const root = resolve(workDir);
+  const canonicalRoot = await realpath(root);
+  const exactCandidates = unique.map(requestedPath => resolveAndValidatePath(requestedPath, root));
+  const exactMatches = await Promise.all(exactCandidates.map(exactPath => (
+    canonicalWorkspaceFile(exactPath, canonicalRoot)
+  )));
+  const unresolved = unique.filter((_path, index) => (
+    !exactMatches[index] && isInsideWorkspace(root, exactCandidates[index])
+  ));
+  const basenameScan = await findUniqueBasenames(root, unresolved, scanOptions);
 
-  return unique.flatMap((requestedPath, index) => {
+  const resolvedEntries = await Promise.all(unique.map(async (requestedPath, index) => {
     const matches = basenameScan.matches.get(comparable(basename(requestedPath))) || [];
-    const fallbackPath = basenameScan.complete && matches.length === 1 ? matches[0] : null;
+    const fallbackPath = basenameScan.complete && matches.length === 1
+      ? await canonicalWorkspaceFile(matches[0], canonicalRoot)
+      : null;
     const matchedPath = exactMatches[index] || fallbackPath;
-    if (!matchedPath) return [];
-    return [{
+    if (!matchedPath) return null;
+    return {
       requestedPath,
-      resolvedPath: relative(root, matchedPath).replaceAll('\\', '/') || basename(matchedPath),
-    }];
-  });
+      resolvedPath: relative(canonicalRoot, matchedPath).replaceAll('\\', '/') || basename(matchedPath),
+    };
+  }));
+  return resolvedEntries.filter(Boolean);
 }
 
 export async function handleResolveFileReferences(msg) {