@qwen-code/arena-agent 0.0.10-dev.6 → 0.0.10-dev.7

package/dist/code-tools.js

@@ -12,11 +12,13 @@ import iconv from "iconv-lite";
 import mime from "mime/lite";
 import { executeBraveWebSearch } from "./brave-search.js";
 import { FetchPageReader } from "./fetch-page.js";
-import { replaceUniqueText } from "./file-edit.js";
+import { replaceFirstText, replaceUniqueText } from "./file-edit.js";
 import { generatedImageBytesForExtension } from "./image.js";
 import { generateImageWithModelRouter, } from "./model-router-media.js";
 import { executeRoutifyWebFetch, routifyWebFetchEnabled, } from "./routify-web-fetch.js";
+import { replayResponseFor } from "./replay-responses.js";
 import { toolDefinitions } from "./spec.js";
+import { boundedWebFetchResult, truncateCodeArenaText } from "./web-fetch-output.js";
 const knownTextApplicationMimeTypes = new Set([
     "application/ecmascript",
     "application/javascript",
@@ -451,9 +453,14 @@ function matchesGlob(filePath, pattern) {
                 matcher.test(path.posix.basename(normalized))));
     });
 }
-function packageNameIsSafe(value) {
+function packageNameIsSafe(value, mode) {
     if (!value || value.startsWith("-") || /\s/.test(value))
         return false;
+    if (mode === "react") {
+        // React captures reject version ranges before invoking npm, while accepting
+        // exact versions and tags such as latest. Keep other modes' validator intact.
+        return /^(?:@[\w.-]+\/)?[\w.-]+(?:@[\w.+-]+)?$/.test(value);
+    }
     return /^(?:@[\w.-]+\/)?[\w.-]+(?:@(?:[\w*^<>=|.+-]+))?$/.test(value);
 }
 function valueAtPath(value, instancePath) {
@@ -765,9 +772,14 @@ export class CodeToolExecutor {
             // 监听器不会补发已发生的 abort：已取消的 signal 必须在产生任何副作用
             // 之前短路，否则命令会照常 spawn 直到自然结束。
             this.signal?.throwIfAborted();
-            const argumentsValue = JSON.parse(typeof call.function?.arguments === "string"
+            const parsedArguments = JSON.parse(typeof call.function?.arguments === "string"
                 ? call.function.arguments
                 : "{}");
+            // React captures normalize a string-valued argument payload to an empty
+            // object before validating required fields (rather than echoing the string).
+            const argumentsValue = this.config.mode === "react" && typeof parsedArguments === "string"
+                ? {}
+                : parsedArguments;
             // The captured provider advertises these fields as required, but its
             // runtime still applies the documented defaults when a model omits
             // them. Preserve the byte-identical outgoing schema while matching the
@@ -779,6 +791,11 @@ export class CodeToolExecutor {
             else if (name === "list_files" || name === "glob_files") {
                 argumentsValue.path ??= "";
             }
+            else if (this.config.mode === "full-stack" && name === "bash" &&
+                argumentsValue && typeof argumentsValue === "object" &&
+                !Array.isArray(argumentsValue) && argumentsValue.workdir === undefined) {
+                argumentsValue.workdir = "";
+            }
             else if (name === "grep_files") {
                 argumentsValue.path ??= "";
                 argumentsValue.glob ??= "";
@@ -843,6 +860,13 @@ export class CodeToolExecutor {
         };
     }
     async dispatch(name, values, _toolCallId) {
+        // Replay mode (CODE_HARNESS_REPLAY_RESPONSES set): serve recorded outputs
+        // verbatim for nondeterministic tools (web_search/web_fetch/fetch_media/…)
+        // so replayed sessions stay offline and deterministic. Unlisted calls fall
+        // through to real execution.
+        const replayed = replayResponseFor(name, values);
+        if (replayed)
+            return replayed.output;
         switch (name) {
             case "read_file":
                 return this.readCodeFile(String(values.path), Number(values.offset), Number(values.limit));
@@ -1064,7 +1088,9 @@ export class CodeToolExecutor {
             status: "success",
             file: {
                 path: this.relativePath(target),
-                content: `${numbered}\n\n${footer}`,
+                content: this.config.mode === "react"
+                    ? truncateCodeArenaText(`${numbered}\n\n${footer}`)
+                    : `${numbered}\n\n${footer}`,
                 contentType: contentTypeForFile(target),
             },
             totalLines: lines.length,
@@ -1147,15 +1173,24 @@ export class CodeToolExecutor {
                 message: `File "${rawPath}" does not exist`,
             };
         }
-        const edited = replaceUniqueText(source, context, replacement, {
+        // React replaces the first exact occurrence, including when an indented
+        // context also occurs on a later, more deeply indented line. Keep the
+        // existing uniqueness check for fuzzy fallback and the other modes.
+        const replace = this.config.mode === "react" && context.length > 0 && source.includes(context)
+            ? replaceFirstText : replaceUniqueText;
+        const edited = replace(source, context, replacement, {
             whitespaceInsensitiveMultiline: true,
+            whitespaceInsensitiveSingleLine: this.config.mode === "react",
+            preserveNewlines: this.config.mode === "react",
         });
         if (edited === undefined) {
             // Captured sessions re-issue an edit after compaction or a retry. The
             // provider reports success without touching the file when the context
             // is already gone and the replacement is in place (f39 re-issues four
             // dashboard edits this way).
-            if (replacement && source.includes(replacement)) {
+            // That retry behavior comes from Full Stack captures. React still
+            // reports Context not found even when the replacement is present.
+            if (this.config.mode !== "react" && replacement && source.includes(replacement)) {
                 return this.mutationResult("Edited", rawPath);
             }
             return {
@@ -1198,6 +1233,19 @@ export class CodeToolExecutor {
             }
             current?.lines.push(line);
         }
+        if (this.config.mode === "react") {
+            // React parses duplicate operation paths before applying any writes.
+            // In particular, Delete + Add of the same file is an Add duplicate.
+            const seen = new Set();
+            for (const operation of operations) {
+                const target = await this.confinedPath(operation.path);
+                if (seen.has(target)) {
+                    const label = operation.kind[0].toUpperCase() + operation.kind.slice(1);
+                    return { status: "error", message: `${label} File Error: Duplicate Path: ${operation.path}` };
+                }
+                seen.add(target);
+            }
+        }
         for (const operation of operations) {
             const target = await this.confinedPath(operation.path);
             if (operation.kind === "add") {
@@ -1313,6 +1361,11 @@ export class CodeToolExecutor {
         return { status: "success" };
     }
     async listCodeFiles(rawPath) {
+        if (this.config.mode === "react" && rawPath === "/")
+            rawPath = ".";
+        if (this.config.mode === "react" && (path.isAbsolute(rawPath) || rawPath.includes(".."))) {
+            return { status: "error", message: "Path must be relative to project root (no absolute paths or '..' traversal)" };
+        }
         const target = await this.confinedPath(rawPath || ".");
         if (!(await this.existsWithExactCase(rawPath || ".")) ||
             !existsSync(target)) {
@@ -1321,7 +1374,8 @@ export class CodeToolExecutor {
         const files = this.orderListedFiles(await this.walkFiles(target));
         return {
             status: "success",
-            files: files.map((filePath) => ({ path: filePath })),
+            files: (this.config.mode === "react" ? files.slice(0, 500) : files)
+                .map((filePath) => ({ path: filePath })),
         };
     }
     async grepCodeFiles(values) {
@@ -1408,8 +1462,10 @@ export class CodeToolExecutor {
                 continue;
             }
             const lines = content.split("\n");
+            const searchLineCount = this.config.mode === "react" && lines.at(-1) === ""
+                ? lines.length - 1 : lines.length;
             const matchingLines = [];
-            for (let index = 0; index < lines.length; index += 1) {
+            for (let index = 0; index < searchLineCount; index += 1) {
                 if (expression.test(lines[index]))
                     matchingLines.push(index);
             }
@@ -1440,6 +1496,24 @@ export class CodeToolExecutor {
                         if (previousAfter.length > 0)
                             match.contextAfter = previousAfter;
                     }
+                    else if (this.config.mode === "react") {
+                        // The captured adapter attaches context lines to the preceding
+                        // match, even across ripgrep group separators. Only a file's first
+                        // match receives contextBefore. Do not duplicate overlapping groups.
+                        if (position === 0 && before > 0) {
+                            const contextBefore = lines.slice(Math.max(0, index - before), index);
+                            if (contextBefore.length)
+                                match.contextBefore = contextBefore;
+                        }
+                        const nextMatch = matchingLines[position + 1];
+                        const end = Math.min(index + 1 + after, nextMatch ?? searchLineCount);
+                        const contextAfter = lines.slice(index + 1, end);
+                        if (nextMatch !== undefined && before > 0) {
+                            contextAfter.push(...lines.slice(Math.max(end, index + 1, nextMatch - before), nextMatch));
+                        }
+                        if (contextAfter.length)
+                            match.contextAfter = contextAfter;
+                    }
                     else {
                         if (before > 0) {
                             match.contextBefore = lines.slice(Math.max(0, index - before), index);
@@ -1495,7 +1569,7 @@ export class CodeToolExecutor {
             return { status: "success", paths: [], truncated: false };
         }
         const allPaths = files
-            .filter((filePath) => matchesGlob(path.relative(target, filePath).split(path.sep).join("/"), pattern))
+            .filter((filePath) => matchesGlob(path.relative(target, filePath).split(path.sep).join("/"), pattern) || (this.config.mode === "react" && matchesGlob(this.relativePath(filePath), pattern)))
             .map((filePath) => this.relativePath(filePath));
         return {
             status: "success",
@@ -1568,11 +1642,11 @@ export class CodeToolExecutor {
         });
     }
     async installNpmPackages(packages) {
-        const invalid = packages.find((packageName) => !packageNameIsSafe(packageName));
+        const invalid = packages.find((packageName) => !packageNameIsSafe(packageName, this.config.mode));
         if (invalid) {
             return {
                 status: "error",
-                message: `Invalid package name: ${invalid}`,
+                message: `Invalid package name: ${this.config.mode === "react" ? JSON.stringify(invalid) : invalid}`,
             };
         }
         const args = ["install", "-S"];
@@ -1611,11 +1685,15 @@ export class CodeToolExecutor {
         };
     }
     async fullStackBash(command, workdir) {
+        const cwd = workdir.trim() || ".";
+        if (path.isAbsolute(cwd) || cwd.includes("..")) {
+            throw new Error(`Invalid workdir: ${cwd}. Commands run from the project root by default. Only use workdir for relative subdirectories, never absolute paths.`);
+        }
         const configuredTimeout = Number(process.env.CODE_HARNESS_BASH_TIMEOUT_SECONDS || 300);
         const timeoutSeconds = Number.isFinite(configuredTimeout) && configuredTimeout > 0
             ? configuredTimeout
             : 300;
-        const result = await this.bash(command, workdir.trim() || ".", timeoutSeconds);
+        const result = await this.bash(command, cwd, timeoutSeconds);
         const exitCode = result.exit_code;
         const stdout = String(result.stdout || "");
         const stderr = String(result.stderr || "");
@@ -1886,11 +1964,7 @@ export class CodeToolExecutor {
         const result = routifyWebFetchEnabled()
             ? await executeRoutifyWebFetch(url, format, { signal: this.signal })
             : await this.pageReader.readFormatted(url, format);
-        return {
-            status: "success",
-            title: String(result.title || "No Title Found"),
-            content: String(result.content || ""),
-        };
+        return boundedWebFetchResult(result);
     }
     async pexelsRequest(pathname, parameters) {
         const apiKey = process.env.PEXELS_API_KEY;
@@ -1929,7 +2003,7 @@ export class CodeToolExecutor {
             },
         });
     }
-    mapPexelsPhotos(payload) {
+    mapPexelsPhotos(payload, orientation) {
         const photos = Array.isArray(payload.photos) ? payload.photos : [];
         return photos.map((value) => {
             const photo = record(value);
@@ -1938,12 +2012,14 @@ export class CodeToolExecutor {
                 type: "image",
                 id: Number(photo.id),
                 pexelsUrl: stringValue(photo.url),
-                recommendedUrl: stringValue(source.large2x) ||
+                recommendedUrl: (orientation === "landscape" || orientation === "portrait"
+                    ? stringValue(source[orientation]) : "") ||
+                    stringValue(source.large2x) ||
                     stringValue(source.large) ||
                     stringValue(source.original),
-                thumbnailUrl: stringValue(source.medium) ||
-                    stringValue(source.small) ||
-                    stringValue(source.tiny),
+                thumbnailUrl: stringValue(source.tiny) ||
+                    stringValue(source.medium) ||
+                    stringValue(source.small),
                 width: Number(photo.width),
                 height: Number(photo.height),
                 creatorName: stringValue(photo.photographer),
@@ -1963,20 +2039,29 @@ export class CodeToolExecutor {
             const files = Array.isArray(video.video_files)
                 ? video.video_files.map(record)
                 : [];
-            const preferred = files.find((item) => stringValue(item.quality) === "hd") ||
-                files[0] ||
-                {};
+            // Captures contain full-resolution HD/UHD files. A quality label alone
+            // does not order renditions; compare their actual pixel dimensions.
+            const playable = files.filter((item) => stringValue(item.file_type) === "video/mp4" && stringValue(item.link));
+            const preferred = playable.sort((left, right) => (Number(right.width) || 0) * (Number(right.height) || 0) -
+                (Number(left.width) || 0) * (Number(left.height) || 0))[0] || files[0] || {};
             return {
                 type: "video",
                 id: Number(video.id),
                 pexelsUrl: stringValue(video.url),
                 recommendedUrl: stringValue(preferred.link),
-                thumbnailUrl: stringValue(pictures[0]?.picture),
+                thumbnailUrl: stringValue(video.image) || stringValue(pictures[0]?.picture),
                 width: Number(video.width),
                 height: Number(video.height),
                 duration: Number(video.duration),
                 creatorName: stringValue(user.name),
                 creatorUrl: stringValue(user.url),
+                videoFile: {
+                    url: stringValue(preferred.link),
+                    width: Number(preferred.width),
+                    height: Number(preferred.height),
+                    ...(preferred.quality !== undefined ? { quality: preferred.quality } : {}),
+                    fileType: stringValue(preferred.file_type),
+                },
             };
         });
     }
@@ -1994,7 +2079,7 @@ export class CodeToolExecutor {
         if (mediaType === "image" || mediaType === "both") {
             const photos = await this.pexelsRequest("/v1/search", common);
             totalResults += Number(photos.total_results || 0);
-            photoResults = this.mapPexelsPhotos(photos);
+            photoResults = this.mapPexelsPhotos(photos, orientation);
         }
         if (mediaType === "video" || mediaType === "both") {
             const videos = await this.pexelsRequest("/v1/videos/search", common);
@@ -2016,13 +2101,20 @@ export class CodeToolExecutor {
     }
     async fetchMedia(query, mediaType, count, orientation, size, locale) {
         const requestedCount = Math.min(10, Math.max(1, Math.trunc(count)));
-        return this.fetchMediaFromPexels(query, mediaType, requestedCount, orientation, size, locale);
+        try {
+            return await this.fetchMediaFromPexels(query, mediaType, requestedCount, orientation, size, locale);
+        }
+        catch (error) {
+            throw new Error(`Media fetch failed: ${errorMessage(error)}`);
+        }
     }
     async generateImage(rawPath, prompt, images) {
         if (this.generatedImageCount >= 10) {
             return {
                 status: "error",
-                message: "generate_image can be used at most 10 times per session",
+                message: this.config.mode === "react"
+                    ? "Failed to generate image: Image generation limit of 10 reached for this session. Use CSS gradients, SVG, or placeholder images for remaining visuals."
+                    : "generate_image can be used at most 10 times per session",
             };
         }
         this.generatedImageCount += 1;