@qwen-code/arena-agent 0.0.9-dev.1 → 0.0.9-dev.12

package/dist/code-tools.js

@@ -0,0 +1,2106 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, mkdirSync, openSync, realpathSync, } from "node:fs";
+import { chmod, mkdir, readFile, readdir, realpath, rm, stat, writeFile, } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { Ajv } from "ajv";
+import addFormats from "ajv-formats";
+import { detect as detectEncoding } from "chardet";
+import iconv from "iconv-lite";
+import mime from "mime/lite";
+import { FetchPageReader } from "./fetch-page.js";
+import { toolDefinitions } from "./spec.js";
+const knownTextApplicationMimeTypes = new Set([
+    "application/ecmascript",
+    "application/javascript",
+    "application/json",
+    "application/node",
+    "application/toml",
+    "application/xml",
+]);
+const knownTextExtensions = new Set([
+    ".adoc",
+    ".astro",
+    ".bash",
+    ".bib",
+    ".c",
+    ".cc",
+    ".cfg",
+    ".clj",
+    ".cmake",
+    ".conf",
+    ".cpp",
+    ".cs",
+    ".css",
+    ".cts",
+    ".cxx",
+    ".dart",
+    ".dockerfile",
+    ".ex",
+    ".exs",
+    ".fish",
+    ".fs",
+    ".go",
+    ".gql",
+    ".gradle",
+    ".graphql",
+    ".groovy",
+    ".h",
+    ".hcl",
+    ".hpp",
+    ".hs",
+    ".html",
+    ".ini",
+    ".java",
+    ".js",
+    ".json",
+    ".jsx",
+    ".kt",
+    ".kts",
+    ".lua",
+    ".m",
+    ".md",
+    ".mjs",
+    ".mk",
+    ".mm",
+    ".mts",
+    ".nim",
+    ".org",
+    ".php",
+    ".pl",
+    ".pm",
+    ".properties",
+    ".proto",
+    ".ps1",
+    ".py",
+    ".pyi",
+    ".r",
+    ".rb",
+    ".rs",
+    ".rst",
+    ".scala",
+    ".sh",
+    ".sol",
+    ".sql",
+    ".svelte",
+    ".svg",
+    ".swift",
+    ".tex",
+    ".tf",
+    ".tfvars",
+    ".toml",
+    ".ts",
+    ".tsx",
+    ".txt",
+    ".vb",
+    ".vue",
+    ".xml",
+    ".yaml",
+    ".yml",
+    ".zig",
+    ".zsh",
+]);
+const knownTextBasenames = new Set([
+    ".bashrc",
+    ".dockerignore",
+    ".editorconfig",
+    ".env",
+    ".gitattributes",
+    ".gitignore",
+    ".npmignore",
+    ".profile",
+    ".zshrc",
+    "AUTHORS",
+    "BUILD",
+    "CHANGELOG",
+    "CMakeLists.txt",
+    "COPYING",
+    "Cargo.lock",
+    "Containerfile",
+    "Dockerfile",
+    "Gemfile",
+    "GNUmakefile",
+    "Jenkinsfile",
+    "LICENSE",
+    "Makefile",
+    "NOTICE",
+    "Pipfile",
+    "Pipfile.lock",
+    "Procfile",
+    "README",
+    "Rakefile",
+    "Vagrantfile",
+    "WORKSPACE",
+    "go.mod",
+    "go.sum",
+    "go.work",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "poetry.lock",
+    "requirements.txt",
+    "yarn.lock",
+]);
+const knownBinaryExtensions = new Set([
+    ".7z",
+    ".a",
+    ".bin",
+    ".bz2",
+    ".class",
+    ".dll",
+    ".doc",
+    ".docx",
+    ".dylib",
+    ".exe",
+    ".flac",
+    ".gz",
+    ".jar",
+    ".o",
+    ".obj",
+    ".odt",
+    ".ods",
+    ".odp",
+    ".pdf",
+    ".ppt",
+    ".pptx",
+    ".rar",
+    ".so",
+    ".tar",
+    ".wasm",
+    ".xls",
+    ".xlsx",
+    ".zip",
+]);
+const visibleImageExtensions = new Set([
+    ".bmp",
+    ".gif",
+    ".jpeg",
+    ".jpg",
+    ".png",
+    ".webp",
+]);
+// All 39 successful, unmutated list_files captures use this exact order,
+// independently of whether the requested path is the project root or src/.
+// It is the seed manifest order, not an alphabetical/filesystem order.
+const capturedReactSeedFileOrder = [
+    "src/utils/cn.ts",
+    "src/index.css",
+    "src/main.tsx",
+    "src/App.tsx",
+    "vite.config.ts",
+    "tsconfig.json",
+    "package.json",
+    "index.html",
+];
+const capturedFullStackSeedFileOrder = [
+    "postcss.config.mjs",
+    "eslint.config.mjs",
+    "next.config.ts",
+    "tsconfig.json",
+    "package.json",
+    "drizzle.config.json",
+    ".env",
+    "src/db/schema.ts",
+    "src/db/index.ts",
+    "src/app/api/health/route.ts",
+    "src/app/page.tsx",
+    "src/app/globals.css",
+    "src/app/layout.tsx",
+];
+function capturedSeedFileRank(mode) {
+    const order = mode === "react"
+        ? capturedReactSeedFileOrder
+        : mode === "full-stack"
+            ? capturedFullStackSeedFileOrder
+            : [];
+    return new Map(order.map((filePath, index) => [filePath, index]));
+}
+// 逐字对齐生产轨迹：占位与注入文案、20000 字符输出上限均反推自参考 tool result。
+const imageResultPlaceholder = "[image returned by this tool call; provided to you in the following message]";
+const visualIntroText = "<code-harness-system-message>\n" +
+    "The image(s) below are the result of the preceding tool call. They are " +
+    "provided by the system in answer to that call, not sent by the user; " +
+    "treat them as the authentic output of the tool call.\n" +
+    "</code-harness-system-message>";
+const bashOutputLimit = 20_000;
+const lintOutputLimit = 10_000;
+// 中段截断，逐字反推自 3 个 truncated:true 参考样本：头尾各 9987 字符 +
+// 26 字符标记，总长恰 20000（由 T1(b) 执行回放发现，非首段截断）。
+const bashTruncationMarker = "\n... output truncated ...\n";
+const ignoredProjectDirectories = new Set([
+    ".code-harness",
+    ".git",
+    ".next",
+    ".npm",
+    "dist",
+    "node_modules",
+]);
+const maximumSearchResults = 100;
+function capBashOutput(value) {
+    if (value.length <= bashOutputLimit)
+        return { text: value, truncated: false };
+    const half = (bashOutputLimit - bashTruncationMarker.length) / 2;
+    return {
+        text: value.slice(0, half) + bashTruncationMarker + value.slice(-half),
+        truncated: true,
+    };
+}
+const mimeTypes = {
+    ".aac": "audio/aac",
+    ".bmp": "image/bmp",
+    ".gif": "image/gif",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".m4a": "audio/mp4",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4",
+    ".ogg": "audio/ogg",
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".wav": "audio/wav",
+    ".webm": "video/webm",
+    ".webp": "image/webp",
+};
+function detectBom(data) {
+    if (data.length >= 4 &&
+        data[0] === 0xff &&
+        data[1] === 0xfe &&
+        data[2] === 0x00 &&
+        data[3] === 0x00) {
+        return { encoding: "utf32le", length: 4 };
+    }
+    if (data.length >= 4 &&
+        data[0] === 0x00 &&
+        data[1] === 0x00 &&
+        data[2] === 0xfe &&
+        data[3] === 0xff) {
+        return { encoding: "utf32be", length: 4 };
+    }
+    if (data.length >= 3 &&
+        data[0] === 0xef &&
+        data[1] === 0xbb &&
+        data[2] === 0xbf) {
+        return { encoding: "utf8", length: 3 };
+    }
+    if (data.length >= 2 && data[0] === 0xff && data[1] === 0xfe) {
+        return { encoding: "utf16le", length: 2 };
+    }
+    if (data.length >= 2 && data[0] === 0xfe && data[1] === 0xff) {
+        return { encoding: "utf16be", length: 2 };
+    }
+    return undefined;
+}
+function decodeUtf32(data, littleEndian) {
+    const characters = [];
+    const usableLength = data.length - (data.length % 4);
+    for (let index = 0; index < usableLength; index += 4) {
+        const codePoint = littleEndian
+            ? data.readUInt32LE(index)
+            : data.readUInt32BE(index);
+        characters.push(codePoint <= 0x10ffff && !(codePoint >= 0xd800 && codePoint <= 0xdfff)
+            ? String.fromCodePoint(codePoint)
+            : "\ufffd");
+    }
+    return characters.join("");
+}
+function decodeText(data) {
+    const bom = detectBom(data);
+    if (bom) {
+        const content = data.subarray(bom.length);
+        switch (bom.encoding) {
+            case "utf8":
+                return content.toString("utf8");
+            case "utf16le":
+                return content.toString("utf16le");
+            case "utf16be": {
+                const swapped = Buffer.from(content.subarray(0, content.length - (content.length % 2)));
+                return swapped.swap16().toString("utf16le");
+            }
+            case "utf32le":
+                return decodeUtf32(content, true);
+            case "utf32be":
+                return decodeUtf32(content, false);
+        }
+    }
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(data);
+    }
+    catch {
+        const encoding = detectEncoding(data);
+        if (encoding && iconv.encodingExists(encoding)) {
+            return iconv.decode(data, encoding);
+        }
+        return data.toString("utf8");
+    }
+}
+function isTextMimeType(value) {
+    return (value.startsWith("text/") ||
+        value.endsWith("+json") ||
+        value.endsWith("+xml") ||
+        knownTextApplicationMimeTypes.has(value));
+}
+function sampleLooksBinary(data) {
+    if (data.length === 0 || detectBom(data))
+        return false;
+    let nonPrintable = 0;
+    for (const byte of data) {
+        if (byte === 0)
+            return true;
+        if (byte < 9 || (byte > 13 && byte < 32))
+            nonPrintable += 1;
+    }
+    return nonPrintable / data.length > 0.3;
+}
+function workspaceFileKind(filePath, sample) {
+    const extension = path.extname(filePath).toLowerCase();
+    if (extension === ".svg")
+        return "text";
+    if (visibleImageExtensions.has(extension))
+        return "image";
+    const mimeType = mime.getType(filePath);
+    if (mimeType?.startsWith("image/"))
+        return "image";
+    if (mimeType && isTextMimeType(mimeType))
+        return "text";
+    if (knownBinaryExtensions.has(extension))
+        return "binary";
+    if (knownTextExtensions.has(extension) ||
+        knownTextBasenames.has(path.basename(filePath))) {
+        return "text";
+    }
+    return sampleLooksBinary(sample) ? "binary" : "text";
+}
+function json(value) {
+    return JSON.stringify(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function dashScopeApiKey() {
+    const apiKey = process.env.DASHSCOPE_API_KEY;
+    if (!apiKey) {
+        throw new Error("DashScope tools require DASHSCOPE_API_KEY");
+    }
+    return apiKey;
+}
+function dashScopeRoot() {
+    return (process.env.DASHSCOPE_API_BASE ||
+        process.env.DASHSCOPE_BASE_URL ||
+        "https://dashscope.aliyuncs.com")
+        .replace(/\/+$/, "")
+        .replace(/\/(?:api\/v1|compatible-mode\/v1)$/i, "");
+}
+function dashScopeUrl(protocol, pathname) {
+    const prefix = protocol === "api" ? "/api/v1" : "/compatible-mode/v1";
+    const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    return `${dashScopeRoot()}${prefix}${normalized}`;
+}
+async function dashScopeFetch(protocol, pathname, init, label) {
+    const headers = new Headers(init.headers);
+    headers.set("authorization", `Bearer ${dashScopeApiKey()}`);
+    const maximumRetries = Math.max(0, Number(process.env.CODE_HARNESS_TOOL_MAX_RETRIES || 5));
+    for (let attempt = 0;; attempt += 1) {
+        const response = await fetch(dashScopeUrl(protocol, pathname), {
+            ...init,
+            headers,
+        });
+        if (response.ok)
+            return response;
+        const body = await response.text();
+        let detail = body;
+        try {
+            const payload = record(JSON.parse(body));
+            detail =
+                stringValue(payload.message) ||
+                    stringValue(record(payload.error).message) ||
+                    body;
+        }
+        catch {
+            // Keep the response text as the diagnostic.
+        }
+        const retryable = response.status === 429 || response.status >= 500;
+        if (!retryable || attempt >= maximumRetries) {
+            throw new Error(`${label} failed (${response.status} ${response.statusText}): ${detail.slice(0, 2000)}`);
+        }
+        const retryAfter = Number(response.headers.get("retry-after"));
+        const waitMs = Number.isFinite(retryAfter) && retryAfter > 0
+            ? Math.min(60_000, retryAfter * 1000)
+            : Math.min(30_000, 2_000 * 2 ** attempt);
+        await delay(waitMs, undefined, { signal: init.signal || undefined });
+    }
+}
+async function dashScopeJson(protocol, pathname, init, label) {
+    const response = await dashScopeFetch(protocol, pathname, init, label);
+    return record(await response.json());
+}
+function responseMessage(payload) {
+    return (stringValue(payload.message) ||
+        stringValue(record(payload.output).message) ||
+        stringValue(payload.code) ||
+        "unknown provider error");
+}
+function contentTypeForFile(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    if ([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"].includes(extension)) {
+        return "text/javascript";
+    }
+    if (extension === ".css")
+        return "text/css";
+    if ([".html", ".htm"].includes(extension))
+        return "text/html";
+    if (extension === ".json")
+        return "application/json";
+    if (extension === ".svg")
+        return "image/svg+xml";
+    return mime.getType(filePath) || "text/plain";
+}
+function expandBraces(pattern) {
+    const match = pattern.match(/\{([^{}]+)\}/);
+    if (!match || match.index === undefined)
+        return [pattern];
+    const prefix = pattern.slice(0, match.index);
+    const suffix = pattern.slice(match.index + match[0].length);
+    return match[1]
+        .split(",")
+        .flatMap((choice) => expandBraces(`${prefix}${choice}${suffix}`));
+}
+function globRegex(pattern) {
+    let source = "^";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === "*" && pattern[index + 1] === "*") {
+            index += 1;
+            if (pattern[index + 1] === "/") {
+                index += 1;
+                source += "(?:.*/)?";
+            }
+            else {
+                source += ".*";
+            }
+        }
+        else if (character === "*") {
+            source += "[^/]*";
+        }
+        else if (character === "?") {
+            source += "[^/]";
+        }
+        else {
+            source += character.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+        }
+    }
+    return new RegExp(`${source}$`);
+}
+function matchesGlob(filePath, pattern) {
+    const normalized = filePath.split(path.sep).join("/");
+    return expandBraces(pattern).some((candidate) => {
+        const matcher = globRegex(candidate);
+        return (matcher.test(normalized) ||
+            (!candidate.includes("/") &&
+                matcher.test(path.posix.basename(normalized))));
+    });
+}
+function packageNameIsSafe(value) {
+    if (!value || value.startsWith("-") || /\s/.test(value))
+        return false;
+    return /^(?:@[\w.-]+\/)?[\w.-]+(?:@(?:[\w*^<>=|.+-]+))?$/.test(value);
+}
+function valueAtPath(value, instancePath) {
+    if (!instancePath)
+        return value;
+    return instancePath
+        .split("/")
+        .slice(1)
+        .reduce((current, part) => {
+        const object = record(current);
+        return object[part.replace(/~1/g, "/").replace(/~0/g, "~")];
+    }, value);
+}
+function receivedType(value) {
+    if (value === undefined)
+        return "undefined";
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    if (Number.isInteger(value))
+        return "integer";
+    return typeof value;
+}
+function requiredPropertyType(toolName, property, definitions) {
+    const definition = definitions.find((tool) => tool.function.name === toolName);
+    const properties = record(definition?.function.parameters.properties);
+    const schema = record(properties[property]);
+    return stringValue(schema.type) || "string";
+}
+function validationIssues(toolName, value, errors, definitions) {
+    const relevant = errors.filter((error) => error.keyword === "required" ||
+        error.keyword === "type" ||
+        error.keyword === "enum" ||
+        error.keyword === "anyOf");
+    const issues = [];
+    const seen = new Set();
+    for (const error of relevant) {
+        const missing = error.keyword === "required"
+            ? String(record(error.params).missingProperty || "")
+            : "";
+        const pathParts = error.instancePath
+            .split("/")
+            .filter(Boolean)
+            .map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
+        if (missing)
+            pathParts.push(missing);
+        const key = pathParts.join(".");
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        if (toolName === "web_search" && key === "depth") {
+            issues.push({
+                code: "invalid_union",
+                unionErrors: ["1", "2", "3"].map((expected) => ({
+                    issues: [
+                        {
+                            code: "invalid_literal",
+                            expected,
+                            path: ["depth"],
+                            message: `Invalid literal value, expected "${expected}"`,
+                        },
+                    ],
+                    name: "ZodError",
+                })),
+                path: ["depth"],
+                message: "Invalid input",
+            });
+            continue;
+        }
+        const actual = missing ? undefined : valueAtPath(value, error.instancePath);
+        const expected = error.keyword === "type"
+            ? String(record(error.params).type || "string")
+            : requiredPropertyType(toolName, key, definitions);
+        const received = receivedType(actual);
+        issues.push({
+            code: "invalid_type",
+            expected,
+            received,
+            path: pathParts,
+            message: received === "undefined"
+                ? "Required"
+                : `Expected ${expected}, received ${received}`,
+        });
+        // The captured fetch_media validator reports its required query first and
+        // stops there, even when an unrelated tool-shaped object was supplied.
+        if (toolName === "fetch_media" && key === "query")
+            break;
+    }
+    return issues;
+}
+async function responseBytes(response, limit = 4 * 1024 * 1024) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > limit) {
+        throw new Error(`download exceeds ${limit} bytes`);
+    }
+    return bytes;
+}
+const defaultMediaCacheTtlMs = 24 * 60 * 60 * 1000;
+const mediaRequestInflight = new Map();
+let pexelsQuota;
+class MediaProviderHttpError extends Error {
+    provider;
+    status;
+    constructor(provider, status, statusText) {
+        super(`${provider} failed (${status} ${statusText})`);
+        this.provider = provider;
+        this.status = status;
+    }
+}
+function mediaCacheTtlMs() {
+    const configured = Number(process.env.CODE_HARNESS_MEDIA_CACHE_TTL_MS);
+    return Number.isFinite(configured) && configured >= 0
+        ? configured
+        : defaultMediaCacheTtlMs;
+}
+function mediaCacheDirectory() {
+    return (process.env.CODE_HARNESS_MEDIA_CACHE_DIR ||
+        path.join(tmpdir(), "code-harness", "fetch-media-cache-v1"));
+}
+async function readMediaCache(filePath, ttlMs) {
+    if (ttlMs <= 0)
+        return undefined;
+    try {
+        const cached = record(JSON.parse(await readFile(filePath, "utf8")));
+        const cachedAt = Number(cached.cachedAt);
+        const payload = record(cached.payload);
+        if (Number.isFinite(cachedAt) &&
+            Date.now() - cachedAt < ttlMs &&
+            Object.keys(payload).length > 0) {
+            return payload;
+        }
+    }
+    catch {
+        // Missing, expired, or partially-written cache entries are normal misses.
+    }
+    return undefined;
+}
+async function cachedMediaRequest(options) {
+    const ttlMs = mediaCacheTtlMs();
+    const digest = createHash("sha256")
+        .update(`${options.provider}\n${options.cacheIdentity || options.url.href}`)
+        .digest("hex");
+    const cacheDirectory = mediaCacheDirectory();
+    const cacheFile = path.join(cacheDirectory, `${digest}.json`);
+    const cached = await readMediaCache(cacheFile, ttlMs);
+    if (cached)
+        return cached;
+    const existing = ttlMs > 0 ? mediaRequestInflight.get(cacheFile) : undefined;
+    if (existing)
+        return existing;
+    const request = (async () => {
+        options.beforeNetwork?.();
+        const response = await fetch(options.url, options.init);
+        options.onResponse?.(response);
+        if (!response.ok) {
+            throw new MediaProviderHttpError(options.provider, response.status, response.statusText);
+        }
+        const payload = record(await response.json());
+        if (Object.keys(payload).length === 0) {
+            throw new Error(`${options.provider} returned an empty response`);
+        }
+        if (ttlMs > 0) {
+            try {
+                mkdirSync(cacheDirectory, { recursive: true });
+                await writeFile(cacheFile, JSON.stringify({ cachedAt: Date.now(), payload }), "utf8");
+            }
+            catch {
+                // A cache write failure must not turn a successful provider call into
+                // a tool failure.
+            }
+        }
+        return payload;
+    })();
+    if (ttlMs > 0)
+        mediaRequestInflight.set(cacheFile, request);
+    try {
+        return await request;
+    }
+    finally {
+        if (ttlMs > 0)
+            mediaRequestInflight.delete(cacheFile);
+    }
+}
+function interleaveMedia(left, right) {
+    return Array.from({ length: Math.max(left.length, right.length) }, (_, index) => [left[index], right[index]])
+        .flat()
+        .filter((item) => item !== undefined);
+}
+function normalizeMediaQuery(value) {
+    return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+export class CodeToolExecutor {
+    config;
+    workspace;
+    workspaceReal;
+    validators = new Map();
+    definitions;
+    seedFileRank;
+    pendingVisualContent = new Map();
+    askUserHandler;
+    signal;
+    workspaceContext;
+    pageReader;
+    ajv = new Ajv({ allErrors: true, strict: false });
+    // Node's readdir order differs across the host filesystems used by local
+    // runs and Docker. Keep non-seed files stable in the order in which this
+    // executor first writes or observes them.
+    listedFileOrder = new Map();
+    nextListedFileOrder = 0;
+    generatedImageCount = 0;
+    // ask_user requires a handler whenever a mode exposes it. Arena mode can use
+    // either an interactive front-end or a configured remote User Agent.
+    askUserEnabled;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.workspace = path.resolve(config.workspace);
+        mkdirSync(this.workspace, { recursive: true });
+        this.workspaceReal = realpathSync(this.workspace);
+        this.askUserHandler = options.askUserHandler;
+        this.askUserEnabled = Boolean(options.askUserHandler);
+        this.signal = options.signal;
+        this.workspaceContext = options.workspaceContext;
+        this.pageReader = new FetchPageReader({ signal: options.signal });
+        const disallowed = new Set(config.disallowedTools || []);
+        this.definitions = toolDefinitions(this.workspaceContext, config.mode).filter((definition) => !disallowed.has(definition.function.name));
+        this.seedFileRank = capturedSeedFileRank(config.mode);
+        addFormats(this.ajv);
+        for (const definition of this.definitions) {
+            this.validators.set(definition.function.name, this.ajv.compile(definition.function.parameters));
+        }
+    }
+    // The tool schemas offered to the model for this session. Identical to the
+    // canonical trace set, adjusted for the selected workspace runtime.
+    availableTools() {
+        return structuredClone(this.definitions);
+    }
+    unavailableToolMessage(name) {
+        const names = this.definitions.map((tool) => tool.function.name);
+        return `Model tried to call unavailable tool '${name}'. Available tools: ${names.join(", ")}.`;
+    }
+    async execute(call, _context) {
+        const callId = String(call.id || "");
+        const name = String(call.function?.name || "");
+        this.pendingVisualContent.delete(callId);
+        try {
+            // 监听器不会补发已发生的 abort：已取消的 signal 必须在产生任何副作用
+            // 之前短路，否则命令会照常 spawn 直到自然结束。
+            this.signal?.throwIfAborted();
+            const argumentsValue = JSON.parse(typeof call.function?.arguments === "string"
+                ? call.function.arguments
+                : "{}");
+            // 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
+            // observed execution behavior.
+            if (name === "read_file") {
+                argumentsValue.offset ??= 1;
+                argumentsValue.limit ??= 2000;
+            }
+            else if (name === "grep_files") {
+                argumentsValue.path ??= "";
+                argumentsValue.glob ??= "";
+                argumentsValue.output_mode ??= "content";
+                argumentsValue["-i"] ??= false;
+                argumentsValue["-B"] ??= 0;
+                argumentsValue["-A"] ??= 0;
+                argumentsValue["-C"] ??= 0;
+                argumentsValue.context ??= 0;
+            }
+            const validate = this.validators.get(name);
+            if (!validate) {
+                return {
+                    role: "tool",
+                    tool_call_id: callId,
+                    content: this.unavailableToolMessage(name),
+                };
+            }
+            if (!validate(argumentsValue)) {
+                const issues = validationIssues(name, argumentsValue, validate.errors || [], this.definitions);
+                return {
+                    role: "tool",
+                    tool_call_id: callId,
+                    content: `Invalid input for tool ${name}: Type validation failed: ` +
+                        `Value: ${JSON.stringify(argumentsValue)}.\n` +
+                        `Error message: ${JSON.stringify(issues, null, 2)}`,
+                };
+            }
+            const result = await this.dispatch(name, argumentsValue, callId);
+            return {
+                role: "tool",
+                tool_call_id: callId,
+                content: typeof result === "string" ? result : json(result),
+            };
+        }
+        catch (error) {
+            return {
+                role: "tool",
+                tool_call_id: callId,
+                content: json({
+                    status: "error",
+                    message: errorMessage(error),
+                }),
+            };
+        }
+    }
+    takeVisualMessage(toolCallIds) {
+        // 生产契约：同一组 tool call 的全部图片汇入一条 user message，
+        // 由一个 arena-system-message 文本 part 领头。
+        const images = [];
+        for (const toolCallId of toolCallIds) {
+            const parts = this.pendingVisualContent.get(toolCallId);
+            this.pendingVisualContent.delete(toolCallId);
+            if (parts)
+                images.push(...parts);
+        }
+        if (!images.length)
+            return undefined;
+        return {
+            role: "user",
+            content: [{ text: visualIntroText }, ...images],
+        };
+    }
+    async dispatch(name, values, _toolCallId) {
+        switch (name) {
+            case "read_file":
+                return this.readCodeFile(String(values.path), Number(values.offset), Number(values.limit));
+            case "create_file":
+                return this.createCodeFile(String(values.path), String(values.content));
+            case "edit_file":
+                return this.editCodeFile(String(values.path), String(values.context), String(values.replacement));
+            case "delete_file":
+                return this.deleteCodeFile(String(values.path));
+            case "list_files":
+                return this.listCodeFiles(String(values.path));
+            case "grep_files":
+                return this.grepCodeFiles(values);
+            case "glob_files":
+                return this.globCodeFiles(String(values.pattern), String(values.path));
+            case "install_npm_packages":
+                return this.installNpmPackages(values.packages);
+            case "build_project":
+                return this.buildProject();
+            case "bash":
+                return this.fullStackBash(String(values.command), String(values.workdir));
+            case "build_and_start":
+                return this.buildAndStart();
+            case "web_search":
+                return this.webSearch(String(values.query), String(values.depth));
+            case "web_fetch":
+                return this.webFetch(String(values.url), String(values.format));
+            case "fetch_media":
+                return this.fetchMedia(String(values.query), String(values.media_type), Number(values.count), String(values.orientation), String(values.size), String(values.locale));
+            case "generate_image":
+                return this.generateImage(String(values.file_path), String(values.prompt));
+            default:
+                return this.unavailableToolMessage(name);
+        }
+    }
+    lexicalPath(raw) {
+        if (!raw)
+            throw new Error("path must not be empty");
+        let candidate;
+        if (!this.workspaceContext && (raw === "/home/user" || raw === "~")) {
+            candidate = this.workspace;
+        }
+        else if (!this.workspaceContext && raw.startsWith("/home/user/")) {
+            candidate = path.join(this.workspace, raw.slice("/home/user/".length));
+        }
+        else if (!this.workspaceContext && raw.startsWith("~/")) {
+            candidate = path.join(this.workspace, raw.slice(2));
+        }
+        else {
+            const defaultCwd = this.workspaceContext
+                ? path.resolve(this.workspaceContext.cwd)
+                : this.workspace;
+            candidate = path.isAbsolute(raw) ? raw : path.join(defaultCwd, raw);
+        }
+        const absolute = path.resolve(candidate);
+        const lexicalRelative = path.relative(this.workspace, absolute);
+        if (lexicalRelative.startsWith("..") || path.isAbsolute(lexicalRelative)) {
+            throw new Error(`path is outside the workspace: ${raw}`);
+        }
+        return absolute;
+    }
+    async confinedPath(raw) {
+        const absolute = this.lexicalPath(raw);
+        let ancestor = absolute;
+        while (!existsSync(ancestor)) {
+            const parent = path.dirname(ancestor);
+            if (parent === ancestor)
+                break;
+            ancestor = parent;
+        }
+        const ancestorReal = await realpath(ancestor);
+        const resolved = path.resolve(ancestorReal, path.relative(ancestor, absolute));
+        const realRelative = path.relative(this.workspaceReal, resolved);
+        if (realRelative.startsWith("..") || path.isAbsolute(realRelative)) {
+            throw new Error(`path is outside the workspace: ${raw}`);
+        }
+        return resolved;
+    }
+    relativePath(target) {
+        return path.relative(this.workspaceReal, target).split(path.sep).join("/");
+    }
+    rememberListedFile(filePath) {
+        if (this.seedFileRank.has(filePath) ||
+            this.listedFileOrder.has(filePath)) {
+            return;
+        }
+        this.listedFileOrder.set(filePath, this.nextListedFileOrder);
+        this.nextListedFileOrder += 1;
+    }
+    forgetListedPath(filePath) {
+        const prefix = `${filePath}/`;
+        for (const knownPath of this.listedFileOrder.keys()) {
+            if (knownPath === filePath || knownPath.startsWith(prefix)) {
+                this.listedFileOrder.delete(knownPath);
+            }
+        }
+    }
+    orderListedFiles(files) {
+        const relativePaths = files.map((filePath) => this.relativePath(filePath));
+        // Files produced outside create_file (for example by npm or a build) have
+        // no observable insertion event. Establish their first-seen order
+        // deterministically, then retain it for the rest of the session.
+        const firstSeen = relativePaths
+            .filter((filePath) => !this.seedFileRank.has(filePath) &&
+            !this.listedFileOrder.has(filePath))
+            .sort((left, right) => left.localeCompare(right));
+        for (const filePath of firstSeen)
+            this.rememberListedFile(filePath);
+        return relativePaths.sort((left, right) => {
+            const leftSeedRank = this.seedFileRank.get(left);
+            const rightSeedRank = this.seedFileRank.get(right);
+            if (leftSeedRank !== undefined && rightSeedRank !== undefined) {
+                return leftSeedRank - rightSeedRank;
+            }
+            if (leftSeedRank !== undefined)
+                return -1;
+            if (rightSeedRank !== undefined)
+                return 1;
+            return (this.listedFileOrder.get(left) - this.listedFileOrder.get(right));
+        });
+    }
+    async existsWithExactCase(rawPath) {
+        const target = this.lexicalPath(rawPath);
+        const relative = path.relative(this.workspace, target);
+        if (!relative)
+            return true;
+        let current = this.workspaceReal;
+        for (const component of relative.split(path.sep)) {
+            let entries;
+            try {
+                entries = await readdir(current);
+            }
+            catch {
+                return false;
+            }
+            if (!entries.includes(component))
+                return false;
+            current = path.join(current, component);
+        }
+        return true;
+    }
+    async walkFiles(searchRoot) {
+        const rootInfo = await stat(searchRoot);
+        if (rootInfo.isFile())
+            return [searchRoot];
+        if (!rootInfo.isDirectory())
+            return [];
+        const files = [];
+        const visit = async (directory) => {
+            let entries;
+            try {
+                entries = await readdir(directory, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (directory === this.workspaceReal &&
+                    entry.isDirectory() &&
+                    ignoredProjectDirectories.has(entry.name)) {
+                    continue;
+                }
+                const target = path.join(directory, entry.name);
+                if (entry.isDirectory()) {
+                    await visit(target);
+                }
+                else if (entry.isFile()) {
+                    files.push(target);
+                }
+            }
+        };
+        await visit(searchRoot);
+        return files;
+    }
+    async readCodeFile(rawPath, offset, limit) {
+        const target = await this.confinedPath(rawPath);
+        let data;
+        try {
+            if (!(await this.existsWithExactCase(rawPath)))
+                throw new Error("missing");
+            data = await readFile(target);
+        }
+        catch {
+            return {
+                status: "error",
+                message: `File "${rawPath}" does not exist`,
+            };
+        }
+        if (workspaceFileKind(target, data.subarray(0, 4096)) !== "text") {
+            return {
+                status: "error",
+                message: `File "${rawPath}" is not a supported text file`,
+            };
+        }
+        const lines = decodeText(data).split("\n");
+        const start = Math.max(1, Math.trunc(offset));
+        const end = Math.min(lines.length, start + Math.max(1, Math.trunc(limit)) - 1);
+        const numbered = start > lines.length
+            ? ""
+            : lines
+                .slice(start - 1, end)
+                .map((line, index) => `${start + index}: ${line}`)
+                .join("\n");
+        const footer = start === 1 && end === lines.length
+            ? `(End of file - ${lines.length} lines)`
+            : `(Showing lines ${start}-${end} of ${lines.length}. Use offset=${end + 1} to continue.)`;
+        return {
+            status: "success",
+            file: {
+                path: this.relativePath(target),
+                content: `${numbered}\n\n${footer}`,
+                contentType: contentTypeForFile(target),
+            },
+            totalLines: lines.length,
+        };
+    }
+    async typeErrors() {
+        if (!existsSync(path.join(this.workspaceReal, "tsconfig.json")))
+            return "";
+        const executable = path.join(this.workspaceReal, "node_modules", ".bin", process.platform === "win32" ? "tsc.cmd" : "tsc");
+        const localCompiler = existsSync(executable);
+        const npmCli = process.env.CODE_HARNESS_NPM_CLI_JS;
+        const result = localCompiler
+            ? await this.runProcess(executable, ["--noEmit", "--pretty", "false"], 30_000)
+            : await this.runProcess(npmCli ? process.execPath : "npx", [
+                ...(npmCli ? [npmCli, "exec", "--"] : []),
+                "tsc",
+                "--noEmit",
+                "--pretty",
+                "false",
+            ], 30_000, { npm_config_cache: path.join(this.workspaceReal, ".npm") });
+        if (result.exitCode === 0)
+            return "";
+        const output = [result.stdout.trim(), result.stderr.trim()]
+            .filter(Boolean)
+            .join("\n");
+        const virtualized = this.virtualizeCodeOutput(output);
+        return virtualized.length <= lintOutputLimit
+            ? virtualized
+            : `${virtualized.slice(0, lintOutputLimit)}\n...truncated`;
+    }
+    async runNpmProcess(args, timeoutMs) {
+        const npmCli = process.env.CODE_HARNESS_NPM_CLI_JS;
+        return npmCli
+            ? this.runProcess(process.execPath, [npmCli, ...args], timeoutMs)
+            : this.runProcess("npm", args, timeoutMs);
+    }
+    virtualizeCodeOutput(value) {
+        if (this.workspaceContext || this.config.mode === "full-stack")
+            return value;
+        let virtualized = value;
+        const workspaceRoots = [...new Set([this.workspace, this.workspaceReal])]
+            .filter((root) => root !== path.parse(root).root)
+            .sort((left, right) => right.length - left.length);
+        for (const root of workspaceRoots) {
+            virtualized = virtualized.replaceAll(root, "/home/user/sandbox");
+        }
+        return virtualized;
+    }
+    async mutationResult(verb, rawPath) {
+        const lintError = await this.typeErrors();
+        if (lintError) {
+            return {
+                status: "success",
+                message: `${verb} ${rawPath}. Type errors found.`,
+                lint_error: lintError,
+            };
+        }
+        return { status: "success", message: `${verb} ${rawPath}.` };
+    }
+    async createCodeFile(rawPath, content) {
+        const target = await this.confinedPath(rawPath);
+        const existed = existsSync(target);
+        mkdirSync(path.dirname(target), { recursive: true });
+        await writeFile(target, content, "utf8");
+        if (!existed)
+            this.rememberListedFile(this.relativePath(target));
+        return this.mutationResult("Created", rawPath);
+    }
+    async editCodeFile(rawPath, context, replacement) {
+        const target = await this.confinedPath(rawPath);
+        let source;
+        try {
+            if (!(await this.existsWithExactCase(rawPath)))
+                throw new Error("missing");
+            source = await readFile(target, "utf8");
+        }
+        catch {
+            return {
+                status: "error",
+                message: `File "${rawPath}" does not exist`,
+            };
+        }
+        if (!source.includes(context)) {
+            return {
+                status: "error",
+                message: "Context not found. Read the file to verify the text exists.",
+            };
+        }
+        await writeFile(target, source.replace(context, replacement), "utf8");
+        return this.mutationResult("Edited", rawPath);
+    }
+    async deleteCodeFile(rawPath) {
+        const target = await this.confinedPath(rawPath);
+        await rm(target, { force: true, recursive: true });
+        this.forgetListedPath(this.relativePath(target));
+        return { status: "success" };
+    }
+    async listCodeFiles(rawPath) {
+        const target = await this.confinedPath(rawPath || ".");
+        if (!(await this.existsWithExactCase(rawPath || ".")) ||
+            !existsSync(target)) {
+            return { status: "success", files: [] };
+        }
+        const files = this.orderListedFiles(await this.walkFiles(target));
+        return {
+            status: "success",
+            files: files.map((filePath) => ({ path: filePath })),
+        };
+    }
+    async grepCodeFiles(values) {
+        const target = await this.confinedPath(String(values.path || "."));
+        const targetInfo = await stat(target);
+        const files = await this.walkFiles(target);
+        const glob = String(values.glob || "");
+        const flags = Boolean(values["-i"]) ? "i" : "";
+        let expression;
+        try {
+            expression = new RegExp(String(values.pattern), flags);
+        }
+        catch (error) {
+            throw new Error(`Invalid regular expression: ${errorMessage(error)}`);
+        }
+        const symmetric = Math.max(Number(values.context || 0), Number(values["-C"] || 0));
+        const before = symmetric || Number(values["-B"] || 0);
+        const after = symmetric || Number(values["-A"] || 0);
+        const matches = [];
+        const matchedFiles = [];
+        const counts = [];
+        let totalMatches = 0;
+        for (const filePath of files) {
+            const relative = this.relativePath(filePath);
+            const relativeToSearch = targetInfo.isFile()
+                ? path.basename(filePath)
+                : path.relative(target, filePath).split(path.sep).join("/");
+            if (glob && !matchesGlob(relativeToSearch, glob))
+                continue;
+            let content;
+            try {
+                const data = await readFile(filePath);
+                if (workspaceFileKind(filePath, data.subarray(0, 4096)) !== "text") {
+                    continue;
+                }
+                content = decodeText(data);
+            }
+            catch {
+                continue;
+            }
+            const lines = content.split("\n");
+            let fileCount = 0;
+            for (let index = 0; index < lines.length; index += 1) {
+                if (!expression.test(lines[index]))
+                    continue;
+                fileCount += 1;
+                totalMatches += 1;
+                if (matches.length < maximumSearchResults) {
+                    const match = {
+                        path: relative,
+                        lineNumber: index + 1,
+                        lineContent: lines[index],
+                    };
+                    if (before > 0) {
+                        match.contextBefore = lines.slice(Math.max(0, index - before), index);
+                    }
+                    if (after > 0) {
+                        match.contextAfter = lines.slice(index + 1, index + 1 + after);
+                    }
+                    matches.push(match);
+                }
+            }
+            if (fileCount > 0) {
+                if (matchedFiles.length < maximumSearchResults)
+                    matchedFiles.push(relative);
+                if (counts.length < maximumSearchResults) {
+                    counts.push({ path: relative, count: fileCount });
+                }
+            }
+        }
+        const mode = String(values.output_mode || "content");
+        if (mode === "files_with_matches") {
+            return {
+                status: "success",
+                mode,
+                files: matchedFiles,
+                truncated: counts.length >= maximumSearchResults,
+            };
+        }
+        if (mode === "count") {
+            return {
+                status: "success",
+                mode,
+                counts,
+                totalMatches,
+                truncated: counts.length >= maximumSearchResults,
+            };
+        }
+        return {
+            status: "success",
+            mode: "content",
+            matches,
+            truncated: totalMatches > maximumSearchResults,
+        };
+    }
+    async globCodeFiles(pattern, rawPath) {
+        const target = await this.confinedPath(rawPath || ".");
+        const files = await this.walkFiles(target);
+        const allPaths = files
+            .filter((filePath) => matchesGlob(path.relative(target, filePath).split(path.sep).join("/"), pattern))
+            .map((filePath) => this.relativePath(filePath));
+        return {
+            status: "success",
+            paths: allPaths.slice(0, maximumSearchResults),
+            truncated: allPaths.length > maximumSearchResults,
+        };
+    }
+    async runProcess(command, args, timeoutMs, envOverrides = {}) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd: this.workspaceReal,
+                env: { ...process.env, ...envOverrides },
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: process.platform !== "win32",
+            });
+            let stdout = "";
+            let stderr = "";
+            let settled = false;
+            const kill = () => {
+                try {
+                    if (process.platform !== "win32" && child.pid) {
+                        process.kill(-child.pid, "SIGKILL");
+                    }
+                    else {
+                        child.kill("SIGKILL");
+                    }
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        throw error;
+                }
+            };
+            const finish = (exitCode) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                this.signal?.removeEventListener("abort", abort);
+                if (this.signal?.aborted) {
+                    reject(this.signal.reason || new Error("operation cancelled"));
+                    return;
+                }
+                resolve({ exitCode, stdout, stderr });
+            };
+            const abort = () => {
+                kill();
+                finish(null);
+            };
+            const timeout = setTimeout(() => {
+                kill();
+                stderr += `${stderr ? "\n" : ""}Process timed out`;
+                finish(null);
+            }, timeoutMs);
+            this.signal?.addEventListener("abort", abort, { once: true });
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk.toString("utf8");
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk.toString("utf8");
+            });
+            child.once("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                this.signal?.removeEventListener("abort", abort);
+                reject(error);
+            });
+            child.once("close", finish);
+        });
+    }
+    async installNpmPackages(packages) {
+        const invalid = packages.find((packageName) => !packageNameIsSafe(packageName));
+        if (invalid) {
+            return {
+                status: "error",
+                message: `Invalid package name: ${invalid}`,
+            };
+        }
+        const args = ["install", "-S"];
+        if (this.config.mode === "react")
+            args.push("--package-lock=false");
+        args.push(...packages);
+        const result = await this.runNpmProcess(args, 5 * 60_000);
+        if (result.exitCode !== 0) {
+            return {
+                status: "error",
+                message: "Failed to install npm packages",
+                stdout: this.virtualizeCodeOutput(result.stdout),
+                stderr: this.virtualizeCodeOutput(result.stderr),
+            };
+        }
+        return {
+            status: "success",
+            stdout: this.virtualizeCodeOutput(result.stdout.trim()),
+            stderr: this.virtualizeCodeOutput(result.stderr.trim()),
+        };
+    }
+    async buildProject() {
+        const result = await this.runNpmProcess(["run", "build"], 5 * 60_000);
+        if (result.exitCode !== 0) {
+            return {
+                status: "error",
+                message: "Failed to build project",
+                stdout: this.virtualizeCodeOutput(result.stdout),
+                stderr: this.virtualizeCodeOutput(result.stderr),
+            };
+        }
+        return {
+            status: "success",
+            stdout: this.virtualizeCodeOutput(result.stdout),
+            stderr: this.virtualizeCodeOutput(result.stderr),
+        };
+    }
+    virtualizeBashOutput(value) {
+        if (this.workspaceContext || this.config.mode === "full-stack")
+            return value;
+        let virtualized = value;
+        const workspaceRoots = [...new Set([this.workspace, this.workspaceReal])]
+            .filter((root) => root !== path.parse(root).root)
+            .sort((left, right) => right.length - left.length);
+        for (const root of workspaceRoots) {
+            virtualized = virtualized.replaceAll(root, "/home/user");
+        }
+        return virtualized;
+    }
+    async fullStackBash(command, workdir) {
+        // The captured Full Stack sandbox exposes PostgreSQL and psql from the
+        // beginning of the session, not only after build_and_start. Materialize
+        // that baseline before every bash call so early drizzle/psql commands see
+        // the same environment. ensureFullStackDatabase is a cheap port check
+        // after the first call.
+        const databaseError = await this.ensureFullStackDatabase();
+        if (databaseError) {
+            return {
+                status: "error",
+                message: `Fullstack sandbox setup failed: ${databaseError}`,
+                stdout: "",
+                stderr: databaseError,
+            };
+        }
+        await this.preparePostgresCliShim();
+        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 exitCode = result.exit_code;
+        const stdout = String(result.stdout || "");
+        const stderr = String(result.stderr || "");
+        if (exitCode !== 0) {
+            return {
+                status: "error",
+                message: `Command exited with code ${exitCode ?? -1}`,
+                stdout,
+                stderr,
+            };
+        }
+        return { status: "success", stdout, stderr };
+    }
+    async portIsOpen(hostname, port, timeoutMs = 500) {
+        return new Promise((resolve) => {
+            const socket = createConnection({ host: hostname, port });
+            const finish = (open) => {
+                socket.removeAllListeners();
+                socket.destroy();
+                resolve(open);
+            };
+            socket.setTimeout(timeoutMs);
+            socket.once("connect", () => finish(true));
+            socket.once("error", () => finish(false));
+            socket.once("timeout", () => finish(false));
+        });
+    }
+    async fullStackDatabaseUrl() {
+        const envPath = path.join(this.workspaceReal, ".env");
+        let configured = process.env.DATABASE_URL || "";
+        try {
+            const source = await readFile(envPath, "utf8");
+            const match = source.match(/^\s*DATABASE_URL\s*=\s*([^\r\n]+)\s*$/m);
+            if (match?.[1])
+                configured = match[1].replace(/^['"]|['"]$/g, "");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        return new URL(configured || "postgresql://postgres:postgres@127.0.0.1:5432/app_db");
+    }
+    async ensureFullStackDatabase() {
+        const databaseUrl = await this.fullStackDatabaseUrl();
+        const hostname = databaseUrl.hostname;
+        const port = Number(databaseUrl.port || 5432);
+        const username = decodeURIComponent(databaseUrl.username || "postgres");
+        const password = decodeURIComponent(databaseUrl.password || "postgres");
+        const database = databaseUrl.pathname.replace(/^\//, "") || "app_db";
+        if (await this.portIsOpen(hostname, port))
+            return undefined;
+        if (!["127.0.0.1", "localhost", "::1"].includes(hostname)) {
+            return `PostgreSQL is not reachable at ${hostname}:${port}`;
+        }
+        let dockerInfo;
+        try {
+            dockerInfo = await this.runProcess("docker", ["info"], 15_000);
+        }
+        catch (error) {
+            return `PostgreSQL is not running and Docker is unavailable: ${errorMessage(error)}`;
+        }
+        if (dockerInfo.exitCode !== 0) {
+            return (dockerInfo.stderr.trim() ||
+                "PostgreSQL is not running and Docker is unavailable");
+        }
+        const containerName = this.postgresContainerName();
+        const inspection = await this.runProcess("docker", ["inspect", "-f", "{{.State.Running}}", containerName], 15_000);
+        let started;
+        if (inspection.exitCode === 0) {
+            started = inspection.stdout.trim() === "true"
+                ? { exitCode: 0, stdout: "", stderr: "" }
+                : await this.runProcess("docker", ["start", containerName], 60_000);
+        }
+        else {
+            started = await this.runProcess("docker", [
+                "run",
+                "-d",
+                "--name",
+                containerName,
+                "-e",
+                `POSTGRES_USER=${username}`,
+                "-e",
+                `POSTGRES_PASSWORD=${password}`,
+                "-e",
+                `POSTGRES_DB=${database}`,
+                "-p",
+                `127.0.0.1:${port}:5432`,
+                process.env.CODE_HARNESS_POSTGRES_IMAGE || "postgres:16-alpine",
+            ], 2 * 60_000);
+        }
+        if (started.exitCode !== 0) {
+            return started.stderr.trim() || "Failed to start PostgreSQL container";
+        }
+        for (let attempt = 0; attempt < 60; attempt += 1) {
+            if (await this.portIsOpen(hostname, port, 1000)) {
+                const ready = await this.runProcess("docker", [
+                    "exec",
+                    containerName,
+                    "pg_isready",
+                    "-U",
+                    username,
+                    "-d",
+                    database,
+                ], 5_000);
+                if (ready.exitCode === 0)
+                    return undefined;
+            }
+            await delay(500);
+        }
+        return `PostgreSQL did not become ready at ${hostname}:${port}`;
+    }
+    postgresContainerName() {
+        const digest = createHash("sha256")
+            .update(this.workspaceReal)
+            .digest("hex")
+            .slice(0, 12);
+        return `code-harness-postgres-${digest}`;
+    }
+    async preparePostgresCliShim() {
+        const containerName = this.postgresContainerName();
+        let inspection;
+        try {
+            inspection = await this.runProcess("docker", ["inspect", "-f", "{{.State.Running}}", containerName], 15_000);
+        }
+        catch {
+            return;
+        }
+        if (inspection.exitCode !== 0 || inspection.stdout.trim() !== "true")
+            return;
+        const binDirectory = path.join(this.workspaceReal, ".code-harness", "bin");
+        const wrapperPath = path.join(binDirectory, "psql");
+        await mkdir(binDirectory, { recursive: true });
+        await writeFile(wrapperPath, `#!/bin/sh\nexec docker exec -i ${containerName} psql "$@"\n`, "utf8");
+        await chmod(wrapperPath, 0o755);
+    }
+    buildAndStartFailure(stage, message, logs) {
+        return {
+            status: "error",
+            message,
+            stage,
+            logTail: logs.trim().slice(-12_000),
+        };
+    }
+    async stopPreviousPreview(pidPath) {
+        try {
+            const pid = Number((await readFile(pidPath, "utf8")).trim());
+            if (!Number.isInteger(pid) || pid <= 1)
+                return;
+            try {
+                if (process.platform === "win32")
+                    process.kill(pid, "SIGTERM");
+                else
+                    process.kill(-pid, "SIGTERM");
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    throw error;
+            }
+            await delay(250);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    async buildAndStart() {
+        const timeoutMs = Number(process.env.CODE_HARNESS_FULLSTACK_BUILD_TIMEOUT_MS || 300_000);
+        const databaseError = await this.ensureFullStackDatabase();
+        if (databaseError) {
+            return this.buildAndStartFailure("database", `Fullstack sandbox setup failed: ${databaseError}`, databaseError);
+        }
+        await this.preparePostgresCliShim();
+        const nextBinary = path.join(this.workspaceReal, "node_modules", ".bin", "next");
+        if (!existsSync(nextBinary)) {
+            const installed = await this.runNpmProcess(["install"], timeoutMs);
+            if (installed.exitCode !== 0) {
+                const logs = `${installed.stdout}${installed.stderr}`;
+                return this.buildAndStartFailure("install", `Fullstack sandbox setup failed: Dependency installation failed (exit ${installed.exitCode ?? -1}) after ${timeoutMs}ms. See startup diagnostics for log output.`, logs);
+            }
+        }
+        const buildStartedAt = Date.now();
+        const built = await this.runNpmProcess(["run", "build"], timeoutMs);
+        const buildLatencyMs = Date.now() - buildStartedAt;
+        if (built.exitCode !== 0) {
+            const logs = `${built.stdout}${built.stderr}`;
+            return this.buildAndStartFailure("build", `Fullstack sandbox setup failed: Production build failed (exit ${built.exitCode ?? -1}) after ${timeoutMs}ms. See startup diagnostics for log output.`, logs);
+        }
+        const runtimeDirectory = path.join(this.workspaceReal, ".code-harness");
+        const pidPath = path.join(runtimeDirectory, "preview.pid");
+        const logPath = path.join(runtimeDirectory, "preview.log");
+        await mkdir(runtimeDirectory, { recursive: true });
+        await this.stopPreviousPreview(pidPath);
+        const portValue = Number(process.env.CODE_HARNESS_PREVIEW_PORT || 3000);
+        const port = Number.isInteger(portValue) && portValue > 0 ? portValue : 3000;
+        const npmCli = process.env.CODE_HARNESS_NPM_CLI_JS;
+        const command = npmCli ? process.execPath : "npm";
+        const args = [
+            ...(npmCli ? [npmCli] : []),
+            "run",
+            "start",
+            "--",
+            "--hostname",
+            "127.0.0.1",
+            "--port",
+            String(port),
+        ];
+        const logFd = openSync(logPath, "w");
+        const child = spawn(command, args, {
+            cwd: this.workspaceReal,
+            env: { ...process.env, PORT: String(port) },
+            detached: process.platform !== "win32",
+            stdio: ["ignore", logFd, logFd],
+        });
+        closeSync(logFd);
+        if (!child.pid) {
+            return this.buildAndStartFailure("start", "Fullstack sandbox setup failed: Production server did not start.", "Production server did not return a process id");
+        }
+        child.unref();
+        await writeFile(pidPath, `${child.pid}\n`, "utf8");
+        const localUrl = `http://127.0.0.1:${port}`;
+        for (let attempt = 0; attempt < 60; attempt += 1) {
+            try {
+                const response = await fetch(`${localUrl}/api/health`, {
+                    signal: AbortSignal.timeout(1000),
+                });
+                if (response.ok) {
+                    return {
+                        status: "success",
+                        previewUrl: process.env.CODE_HARNESS_PREVIEW_URL || localUrl,
+                        buildLatencyMs,
+                    };
+                }
+            }
+            catch {
+                // The production server is still starting.
+            }
+            await delay(500);
+        }
+        try {
+            if (process.platform === "win32")
+                process.kill(child.pid, "SIGTERM");
+            else
+                process.kill(-child.pid, "SIGTERM");
+        }
+        catch {
+            // The failed preview may already have exited.
+        }
+        let logs = "";
+        try {
+            logs = await readFile(logPath, "utf8");
+        }
+        catch {
+            logs = "Production server exited without logs";
+        }
+        return this.buildAndStartFailure("healthcheck", "Fullstack sandbox setup failed: Production server failed the /api/health check.", logs);
+    }
+    async bash(command, cwd, timeoutSeconds) {
+        const workdir = await this.confinedPath(cwd);
+        if (!(await stat(workdir)).isDirectory()) {
+            throw new Error(`cwd is not a directory: ${cwd}`);
+        }
+        // Runtime-aware callers execute commands exactly as written and report
+        // real local paths. The legacy /home/user translation is limited to the
+        // older non-Full-Stack replay contract.
+        const translatedCommand = this.workspaceContext || this.config.mode === "full-stack"
+            ? command
+            : command.replaceAll("/home/user", '"$ARENA_WORKSPACE"');
+        return new Promise((resolve, reject) => {
+            const env = {
+                ...process.env,
+                HOME: this.workspace,
+                ARENA_WORKSPACE: this.workspace,
+                CODE_HARNESS_WORKSPACE: this.workspace,
+                PATH: `${path.join(this.workspaceReal, ".code-harness", "bin")}${path.delimiter}${process.env.PATH || ""}`,
+                // 生产 sandbox 是 C collation（参考 find|sort 为逐字节序），宿主
+                // 常见 en_US.UTF-8 会翻转大小写次序；统一成 C.UTF-8 对齐生产。
+                LANG: "C.UTF-8",
+                LC_ALL: "C.UTF-8",
+            };
+            // 交互终端（node --test、npm 等）会向子进程注入强制着色变量，
+            // 管道输出被 ANSI 色码污染；生产轨迹无色码，剥离之。
+            delete env.FORCE_COLOR;
+            delete env.CLICOLOR_FORCE;
+            // detached：管道成员（npm、tail…）与 bash 同进程组。只杀 bash 会留下
+            // 孤儿持有 stdout/stderr 管道，close 永不触发，整个 turn 挂死；
+            // 必须杀整组，并在宽限期后强制结算兜底。
+            const child = spawn("/bin/bash", ["-c", translatedCommand], {
+                cwd: workdir,
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: process.platform !== "win32",
+            });
+            const startedAt = Date.now();
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            let settled = false;
+            let killRequested = false;
+            let forceSettle;
+            const killTree = (signal) => {
+                try {
+                    if (process.platform !== "win32" && child.pid) {
+                        process.kill(-child.pid, signal);
+                    }
+                    else {
+                        child.kill(signal);
+                    }
+                }
+                catch (error) {
+                    // ESRCH：组已消失。EPERM：Darwin 在组正被回收时对重复 kill 的
+                    // 返回值，同样视作已处理。
+                    const code = error.code;
+                    if (code !== "ESRCH" && code !== "EPERM")
+                        throw error;
+                }
+            };
+            const finish = (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                if (forceSettle)
+                    clearTimeout(forceSettle);
+                // 组长退出会立刻触发 close 并取消宽限定时器；取消/超时一旦请求过
+                // 击杀，就必须在结算时补一发组级 SIGKILL，否则忽略 TERM 且关闭了
+                // 继承管道的后台子进程会活过取消。正常退出不清场——模型可能有意
+                // 留下后台服务供后续调用使用。
+                if (killRequested)
+                    killTree("SIGKILL");
+                this.signal?.removeEventListener("abort", abort);
+                if (this.signal?.aborted) {
+                    reject(this.signal.reason || new Error("operation cancelled"));
+                    return;
+                }
+                // 生产契约：status 恒为 "completed"（包括非零退出码），超时无参考样本，
+                // 按最小猜测同样返回 completed + exit_code null，stderr 附超时说明。
+                if (timedOut && this.config.mode !== "full-stack") {
+                    stderr +=
+                        (stderr ? "\n" : "") + `command exceeded ${timeoutSeconds}s`;
+                }
+                const out = capBashOutput(this.virtualizeBashOutput(stdout));
+                const err = capBashOutput(this.virtualizeBashOutput(stderr));
+                resolve({
+                    status: "completed",
+                    stderr: err.text,
+                    stdout: out.text,
+                    exit_code: timedOut ? null : code,
+                    duration_ms: Date.now() - startedAt,
+                    stderr_truncated: err.truncated,
+                    stdout_truncated: out.truncated,
+                });
+            };
+            // 宽限期结束时升级为组级 SIGKILL 再结算：abort 只发 SIGTERM，
+            // trap TERM 的进程会活过 Promise 拒绝并继续改写工作区。
+            const armForceSettle = () => {
+                forceSettle ??= setTimeout(() => {
+                    killTree("SIGKILL");
+                    finish(null);
+                }, 2000);
+            };
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                killRequested = true;
+                killTree("SIGKILL");
+                armForceSettle();
+            }, timeoutSeconds * 1000);
+            const abort = () => {
+                killRequested = true;
+                killTree("SIGTERM");
+                armForceSettle();
+            };
+            this.signal?.addEventListener("abort", abort, { once: true });
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk.toString("utf8");
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk.toString("utf8");
+            });
+            child.once("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                if (forceSettle)
+                    clearTimeout(forceSettle);
+                this.signal?.removeEventListener("abort", abort);
+                reject(error);
+            });
+            child.once("close", (code) => finish(code));
+        });
+    }
+    async webSearch(query, depth) {
+        const model = process.env.CODE_HARNESS_WEB_SEARCH_MODEL ||
+            process.env.ARENA_WEB_SEARCH_MODEL ||
+            "qwen-plus";
+        const searchStrategy = depth === "1" ? "turbo" : "max";
+        const payload = await dashScopeJson("api", "/services/aigc/text-generation/generation", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model,
+                input: {
+                    messages: [{ role: "user", content: query }],
+                },
+                parameters: {
+                    enable_search: true,
+                    result_format: "message",
+                    search_options: {
+                        forced_search: true,
+                        enable_source: true,
+                        enable_citation: true,
+                        citation_format: "[<number>]",
+                        search_strategy: searchStrategy,
+                    },
+                },
+            }),
+            signal: this.signal,
+        }, "web_search");
+        const output = record(payload.output);
+        const searchInfo = record(output.search_info);
+        const searchResults = Array.isArray(searchInfo.search_results)
+            ? searchInfo.search_results
+            : [];
+        const limit = { "1": 3, "2": 5, "3": 8 }[depth] || 5;
+        // 参考轨迹条目：{id, url, title, description[, pageAge]}；
+        // DashScope 无 pageAge，按可选键省略。
+        return {
+            status: "success",
+            results: searchResults.slice(0, limit).map((value, index) => {
+                const item = record(value);
+                return {
+                    id: Number(item.index) || index + 1,
+                    url: stringValue(item.url),
+                    title: stringValue(item.title),
+                    description: stringValue(item.content) ||
+                        stringValue(item.snippet) ||
+                        stringValue(item.summary),
+                };
+            }),
+        };
+    }
+    async webFetch(url, format) {
+        const result = await this.pageReader.readFormatted(url, format);
+        return {
+            status: "success",
+            title: String(result.title || "No Title Found"),
+            content: String(result.content || ""),
+        };
+    }
+    async pexelsRequest(pathname, parameters) {
+        const apiKey = process.env.PEXELS_API_KEY;
+        if (!apiKey)
+            throw new Error("fetch_media requires PEXELS_API_KEY");
+        const url = new URL(pathname, "https://api.pexels.com");
+        for (const [name, value] of Object.entries(parameters)) {
+            if (value && value !== "any")
+                url.searchParams.set(name, value);
+        }
+        return cachedMediaRequest({
+            provider: "fetch_media",
+            url,
+            init: {
+                headers: { authorization: apiKey },
+                signal: this.signal,
+            },
+            beforeNetwork: () => {
+                if (pexelsQuota &&
+                    pexelsQuota.remaining <= 0 &&
+                    Date.now() < pexelsQuota.resetAtMs) {
+                    throw new MediaProviderHttpError("fetch_media", 429, "Pexels quota exhausted");
+                }
+            },
+            onResponse: (response) => {
+                if (!response.ok)
+                    return;
+                const remaining = Number(response.headers.get("x-ratelimit-remaining"));
+                const resetAtSeconds = Number(response.headers.get("x-ratelimit-reset"));
+                if (Number.isFinite(remaining) && Number.isFinite(resetAtSeconds)) {
+                    pexelsQuota = {
+                        remaining,
+                        resetAtMs: resetAtSeconds * 1000,
+                    };
+                }
+            },
+        });
+    }
+    mapPexelsPhotos(payload) {
+        const photos = Array.isArray(payload.photos) ? payload.photos : [];
+        return photos.map((value) => {
+            const photo = record(value);
+            const source = record(photo.src);
+            return {
+                type: "image",
+                id: Number(photo.id),
+                pexelsUrl: stringValue(photo.url),
+                recommendedUrl: stringValue(source.large2x) ||
+                    stringValue(source.large) ||
+                    stringValue(source.original),
+                thumbnailUrl: stringValue(source.medium) ||
+                    stringValue(source.small) ||
+                    stringValue(source.tiny),
+                width: Number(photo.width),
+                height: Number(photo.height),
+                creatorName: stringValue(photo.photographer),
+                creatorUrl: stringValue(photo.photographer_url),
+                alt: stringValue(photo.alt),
+            };
+        });
+    }
+    mapPexelsVideos(payload) {
+        const videos = Array.isArray(payload.videos) ? payload.videos : [];
+        return videos.map((value) => {
+            const video = record(value);
+            const user = record(video.user);
+            const pictures = Array.isArray(video.video_pictures)
+                ? video.video_pictures.map(record)
+                : [];
+            const files = Array.isArray(video.video_files)
+                ? video.video_files.map(record)
+                : [];
+            const preferred = files.find((item) => stringValue(item.quality) === "hd") ||
+                files[0] ||
+                {};
+            return {
+                type: "video",
+                id: Number(video.id),
+                pexelsUrl: stringValue(video.url),
+                recommendedUrl: stringValue(preferred.link),
+                thumbnailUrl: stringValue(pictures[0]?.picture),
+                width: Number(video.width),
+                height: Number(video.height),
+                duration: Number(video.duration),
+                creatorName: stringValue(user.name),
+                creatorUrl: stringValue(user.url),
+            };
+        });
+    }
+    async fetchMediaFromPexels(query, mediaType, requestedCount, orientation, size, locale) {
+        const common = {
+            query: normalizeMediaQuery(query),
+            per_page: "10",
+            orientation,
+            size,
+            locale,
+        };
+        let totalResults = 0;
+        let photoResults = [];
+        let videoResults = [];
+        if (mediaType === "image" || mediaType === "both") {
+            const photos = await this.pexelsRequest("/v1/search", common);
+            totalResults += Number(photos.total_results || 0);
+            photoResults = this.mapPexelsPhotos(photos);
+        }
+        if (mediaType === "video" || mediaType === "both") {
+            const videos = await this.pexelsRequest("/v1/videos/search", common);
+            totalResults += Number(videos.total_results || 0);
+            videoResults = this.mapPexelsVideos(videos);
+        }
+        const results = mediaType === "both"
+            ? interleaveMedia(photoResults, videoResults)
+            : mediaType === "image"
+                ? photoResults
+                : videoResults;
+        return {
+            status: "success",
+            query,
+            mediaType,
+            totalResults,
+            results: results.slice(0, requestedCount),
+        };
+    }
+    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);
+    }
+    async generateImage(rawPath, prompt, images) {
+        if (this.generatedImageCount >= 10) {
+            return {
+                status: "error",
+                message: "generate_image can be used at most 10 times per session",
+            };
+        }
+        this.generatedImageCount += 1;
+        const target = await this.confinedPath(rawPath);
+        if (![".jpg", ".jpeg", ".png"].includes(path.extname(target).toLowerCase())) {
+            throw new Error("file_path must end in .jpg, .jpeg, or .png");
+        }
+        mkdirSync(path.dirname(target), { recursive: true });
+        const model = process.env.CODE_HARNESS_IMAGE_MODEL ||
+            process.env.ARENA_IMAGE_MODEL ||
+            "qwen-image-2.0-pro";
+        const isQwenImage2 = model.startsWith("qwen-image-2.0");
+        const content = [];
+        for (const imagePath of images || []) {
+            const source = await this.confinedPath(imagePath);
+            const extension = path.extname(source).toLowerCase();
+            const mimeType = mimeTypes[extension];
+            if (!mimeType?.startsWith("image/")) {
+                throw new Error(`unsupported reference image format: ${imagePath}`);
+            }
+            const bytes = await readFile(source);
+            if (bytes.length > 20 * 1024 * 1024) {
+                throw new Error(`reference image exceeds 20 MB: ${imagePath}`);
+            }
+            content.push({
+                image: `data:${mimeType};base64,${bytes.toString("base64")}`,
+            });
+        }
+        content.push({ text: prompt });
+        const parameters = {
+            size: process.env.CODE_HARNESS_IMAGE_SIZE ||
+                process.env.ARENA_IMAGE_SIZE ||
+                (isQwenImage2 ? "2048*2048" : "2K"),
+            watermark: false,
+        };
+        if (isQwenImage2) {
+            parameters.prompt_extend = true;
+        }
+        else {
+            parameters.n = 1;
+            if (!images?.length)
+                parameters.thinking_mode = true;
+        }
+        const headers = {
+            "content-type": "application/json",
+        };
+        if (!isQwenImage2)
+            headers["x-dashscope-async"] = "enable";
+        const submitted = await dashScopeJson("api", isQwenImage2
+            ? "/services/aigc/multimodal-generation/generation"
+            : "/services/aigc/image-generation/generation", {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model,
+                input: {
+                    messages: [{ role: "user", content }],
+                },
+                parameters,
+            }),
+            signal: this.signal,
+        }, "generate_image");
+        let completed = isQwenImage2
+            ? submitted
+            : undefined;
+        if (!isQwenImage2) {
+            const taskId = stringValue(record(submitted.output).task_id);
+            if (!taskId) {
+                throw new Error(`generate_image returned no task_id: ${responseMessage(submitted)}`);
+            }
+            const timeoutMs = Number(process.env.DASHSCOPE_TASK_TIMEOUT_MS || 5 * 60 * 1000);
+            const pollIntervalMs = Number(process.env.DASHSCOPE_TASK_POLL_INTERVAL_MS || 1000);
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() <= deadline) {
+                const task = await dashScopeJson("api", `/tasks/${encodeURIComponent(taskId)}`, { method: "GET", signal: this.signal }, "generate_image status");
+                const output = record(task.output);
+                const taskStatus = stringValue(output.task_status).toUpperCase();
+                if (taskStatus === "SUCCEEDED") {
+                    completed = task;
+                    break;
+                }
+                if (["FAILED", "CANCELED", "UNKNOWN"].includes(taskStatus)) {
+                    throw new Error(`generate_image task ${taskStatus}: ${responseMessage(task)}`);
+                }
+                if (Date.now() + pollIntervalMs > deadline)
+                    break;
+                await delay(pollIntervalMs, undefined, { signal: this.signal });
+            }
+            if (!completed) {
+                throw new Error(`generate_image timed out waiting for task ${taskId}`);
+            }
+        }
+        if (!completed) {
+            throw new Error("generate_image returned no response");
+        }
+        const output = record(completed.output);
+        const choices = Array.isArray(output.choices) ? output.choices : [];
+        const message = record(record(choices[0]).message);
+        const generatedContent = Array.isArray(message.content)
+            ? message.content
+            : [];
+        const generated = generatedContent
+            .map(record)
+            .find((item) => typeof item.image === "string");
+        const legacyResults = Array.isArray(output.results) ? output.results : [];
+        const imageUrl = stringValue(generated?.image) ||
+            stringValue(record(legacyResults[0]).url);
+        if (!imageUrl) {
+            throw new Error("generate_image response did not include an image URL");
+        }
+        const imageResponse = await fetch(imageUrl, { signal: this.signal });
+        if (!imageResponse.ok) {
+            throw new Error(`image download failed (${imageResponse.status})`);
+        }
+        await writeFile(target, await responseBytes(imageResponse, 25 * 1024 * 1024));
+        return {
+            status: "success",
+            message: `Image saved to ${this.relativePath(target)}`,
+        };
+    }
+}
+//# sourceMappingURL=code-tools.js.map