@cjhyy/code-shell-core 0.7.0 → 0.8.0

package/dist/tool-system/builtin/generate-video.js

@@ -21,7 +21,7 @@ import { notificationQueue } from "./agent-notifications.js";
 import { backgroundJobRegistry } from "./background-jobs.js";
 import { logger } from "../../logging/logger.js";
 import { getVideoProvider, DEFAULT_VIDEO_MODEL, } from "./video-providers.js";
-import { getImageUploader, isHttpUrl } from "./image-uploader.js";
+import { getImageUploader, isHttpUrl, } from "./image-uploader.js";
 import { effectiveApiKey } from "./generate-image.js";
 import { getMergedCatalog, findCatalogEntry } from "../../model-catalog/index.js";
 import { genInstancesFromConnections } from "../../model-catalog/gen-connections.js";
@@ -55,7 +55,14 @@ export async function __normalizeImagesForTests(images, image, uploader, creds,
 const VIDEO_PROVIDER_KINDS = ["fal"];
 const DEFAULT_POLL_INTERVAL_MS = 5_000;
 /** Safety cap so a stuck job's background loop can't poll forever. */
-const MAX_POLL_MS = 15 * 60 * 1000;
+const DEFAULT_MAX_POLL_MS = 15 * 60 * 1000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+let maxPollMs = DEFAULT_MAX_POLL_MS;
+let requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
+export function __setVideoPollingLimitsForTests(limits) {
+    maxPollMs = limits?.maxPollMs ?? DEFAULT_MAX_POLL_MS;
+    requestTimeoutMs = limits?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+}
 export const generateVideoToolDef = {
     name: "GenerateVideo",
     description: "Generate a video from a text prompt. The job runs in the background (video generation is " +
@@ -71,7 +78,10 @@ export const generateVideoToolDef = {
                 description: "Video provider kind to use. Defaults to the first configured video provider.",
             },
             model: { type: "string", description: "Video model id. Defaults to the provider's default." },
-            image: { type: "string", description: "Image URL (http/https) for image-to-video. When set, an image-to-video model is used." },
+            image: {
+                type: "string",
+                description: "Image URL (http/https) for image-to-video. When set, an image-to-video model is used.",
+            },
             images: {
                 type: "array",
                 items: { type: "string" },
@@ -80,7 +90,7 @@ export const generateVideoToolDef = {
             videos: {
                 type: "array",
                 items: { type: "string" },
-                description: "Reference/continuation video URLs (http/https only — NOT local paths) for video extension. Forces reference-to-video (Seedance model required). Up to 3. Refer to them in prompt as @Video1, @Video2 (e.g. \"continue from @Video1\").",
+                description: 'Reference/continuation video URLs (http/https only — NOT local paths) for video extension. Forces reference-to-video (Seedance model required). Up to 3. Refer to them in prompt as @Video1, @Video2 (e.g. "continue from @Video1").',
             },
         },
         required: ["prompt"],
@@ -177,7 +187,10 @@ function resolveVideoProvider(cwd, preferKind) {
         const list = genInstancesFromConnections(conns, (Array.isArray(creds) ? creds : []), getMergedCatalog(), "video");
         const def = settings.defaults?.video;
         const usable = (p) => !!p.apiKey && getVideoProvider(p.kind) !== null;
-        const credsOf = (p) => ({ baseUrl: p.baseUrl, apiKey: p.apiKey });
+        const credsOf = (p) => ({
+            baseUrl: p.baseUrl,
+            apiKey: p.apiKey,
+        });
         if (preferKind) {
             const chosen = list.find((p) => (p.id === preferKind || p.kind === preferKind) && usable(p));
             if (chosen)
@@ -195,7 +208,10 @@ function resolveVideoProvider(cwd, preferKind) {
     if (videoGen?.providers?.length) {
         const list = videoGen.providers;
         const usable = (p) => !!effectiveApiKey(p, list) && getVideoProvider(p.kind) !== null;
-        const credsOf = (p) => ({ baseUrl: p.baseUrl, apiKey: effectiveApiKey(p, list) });
+        const credsOf = (p) => ({
+            baseUrl: p.baseUrl,
+            apiKey: effectiveApiKey(p, list),
+        });
         if (preferKind) {
             const chosen = list.find((p) => (p.id === preferKind || p.kind === preferKind) && usable(p));
             if (chosen)
@@ -213,7 +229,8 @@ function resolveVideoProvider(cwd, preferKind) {
     // Back-compat: scan legacy LLM providers[] for a video-capable kind. The
     // field was dropped from the schema; un-migrated settings.json still carry it
     // via .passthrough(), so read it through an inline cast.
-    const legacyProviders = settings.providers ?? [];
+    const legacyProviders = settings
+        .providers ?? [];
     const kinds = preferKind ? [preferKind] : VIDEO_PROVIDER_KINDS;
     for (const kind of kinds) {
         const provider = legacyProviders.find((p) => p.kind === kind);
@@ -283,7 +300,15 @@ export async function generateVideoTool(args, ctx) {
     const norm = await __normalizeImagesForTests(imagesArg, image, uploader, { baseUrl: creds.baseUrl, apiKey: creds.apiKey }, ctx?.signal);
     if (!norm.ok)
         return `Error: ${norm.error}`;
-    const submit = await adapter.submit({ prompt, model, image: undefined, images: norm.urls, videos: videosArg, creds, signal: ctx?.signal });
+    const submit = await adapter.submit({
+        prompt,
+        model,
+        image: undefined,
+        images: norm.urls,
+        videos: videosArg,
+        creds,
+        signal: ctx?.signal,
+    });
     if (!submit.ok) {
         return `Error submitting video job: ${submit.error}`;
     }
@@ -297,10 +322,36 @@ export async function generateVideoTool(args, ctx) {
     // two providers can't collide.
     const jobKey = `video-${jobId}`;
     const promptPreview = prompt.length > 80 ? `${prompt.slice(0, 80)}…` : prompt;
-    backgroundJobRegistry.start(jobKey, sessionId ?? "", `生成视频中:${promptPreview}`);
-    void pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, pollIntervalMs)
+    const controller = new AbortController();
+    let abortKind;
+    const abortTask = (kind) => {
+        if (controller.signal.aborted)
+            return;
+        abortKind = kind;
+        controller.abort();
+    };
+    const onTurnAbort = () => abortTask("cancelled");
+    if (ctx?.signal?.aborted)
+        onTurnAbort();
+    else
+        ctx?.signal?.addEventListener("abort", onTurnAbort, { once: true });
+    const totalTimer = setTimeout(() => abortTask("timeout"), maxPollMs);
+    const polling = pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, pollIntervalMs, controller.signal, () => abortKind, maxPollMs, requestTimeoutMs);
+    backgroundJobRegistry.start(jobKey, sessionId ?? "", `生成视频中:${promptPreview}`, {
+        kind: "video",
+        abort: async () => {
+            abortTask("cancelled");
+            return await polling;
+        },
+    });
+    void polling
         .then((outcome) => backgroundJobRegistry.finish(jobKey, outcome))
-        .catch((err) => backgroundJobRegistry.finish(jobKey, { status: "failed", finalText: err.message }));
+        .catch((err) => backgroundJobRegistry.finish(jobKey, { status: "failed", finalText: err.message }))
+        .finally(() => {
+        clearTimeout(totalTimer);
+        ctx?.signal?.removeEventListener("abort", onTurnAbort);
+    });
+    ctx?.runYield?.request("background_notification");
     return [
         `Video generation started in the background.`,
         `job_id: ${jobId} (internal — do not show to user)`,
@@ -310,16 +361,36 @@ export async function generateVideoTool(args, ctx) {
         `If you have no other work right now, END YOUR TURN — the system wakes you when the video is ready. NEVER run \`sleep\` or poll the provider yourself.`,
     ].join("\n");
 }
-async function pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, pollIntervalMs) {
-    const started = Date.now();
+async function pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, pollIntervalMs, signal, getAbortKind, totalTimeoutMs, perRequestTimeoutMs) {
+    let knownVideoUrl;
+    const retainedUrlOutcome = () => {
+        if (!knownVideoUrl)
+            return undefined;
+        const msg = `Video rendered successfully, but the local download did not finish. Download it from ${knownVideoUrl}`;
+        notifyVideo(sessionId, "completed", prompt, undefined, undefined, knownVideoUrl);
+        return { status: "completed", finalText: msg };
+    };
+    const abortOutcome = () => {
+        const retained = retainedUrlOutcome();
+        if (retained) {
+            return retained;
+        }
+        if (getAbortKind() === "timeout") {
+            const msg = `video job ${jobId} timed out after ${Math.round(totalTimeoutMs / 1000)}s`;
+            notifyVideo(sessionId, "failed", prompt, undefined, msg);
+            return { status: "failed", finalText: msg };
+        }
+        const msg = "Local waiting stopped; the remote service may still be rendering the video.";
+        notifyVideo(sessionId, "cancelled", prompt, undefined, msg);
+        return { status: "cancelled", finalText: msg };
+    };
     try {
         for (;;) {
-            if (Date.now() - started > MAX_POLL_MS) {
-                const msg = `video job ${jobId} timed out after ${Math.round(MAX_POLL_MS / 1000)}s`;
-                notifyVideo(sessionId, "failed", prompt, undefined, msg);
-                return { status: "failed", finalText: msg };
-            }
-            const res = await adapter.poll({ jobId, creds });
+            if (signal.aborted)
+                return abortOutcome();
+            const res = await runVideoRequest((requestSignal) => adapter.poll({ jobId, creds, signal: requestSignal }), signal, perRequestTimeoutMs);
+            if (signal.aborted)
+                return abortOutcome();
             if (!res.ok) {
                 notifyVideo(sessionId, "failed", prompt, undefined, res.error);
                 return { status: "failed", finalText: res.error };
@@ -328,27 +399,84 @@ async function pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, p
                 notifyVideo(sessionId, "failed", prompt, undefined, res.error);
                 return { status: "failed", finalText: res.error };
             }
-            if (res.status === "succeeded")
+            if (res.status === "succeeded") {
+                knownVideoUrl = res.url;
                 break;
-            await new Promise((r) => setTimeout(r, pollIntervalMs));
+            }
+            await abortableDelay(pollIntervalMs, signal);
         }
-        const dl = await adapter.download({ jobId, creds });
+        const dl = await runVideoRequest((requestSignal) => adapter.download({
+            jobId,
+            creds,
+            signal: requestSignal,
+            onUrl: (url) => {
+                knownVideoUrl = url;
+            },
+        }), signal, perRequestTimeoutMs);
+        if (signal.aborted)
+            return abortOutcome();
         if (!dl.ok) {
+            const retained = retainedUrlOutcome();
+            if (retained)
+                return retained;
             notifyVideo(sessionId, "failed", prompt, undefined, dl.error);
             return { status: "failed", finalText: dl.error };
         }
+        knownVideoUrl = dl.url ?? knownVideoUrl;
         const dir = join(cwd, ".code-shell", "generated_videos");
         await mkdir(dir, { recursive: true });
+        if (signal.aborted)
+            return abortOutcome();
         const path = join(dir, `${Date.now()}.${dl.ext || "mp4"}`);
-        await writeFile(path, dl.bytes);
-        notifyVideo(sessionId, "completed", prompt, path, undefined, dl.url);
+        await writeFile(path, dl.bytes, { signal });
+        notifyVideo(sessionId, "completed", prompt, path, undefined, knownVideoUrl);
         return { status: "completed", finalText: path };
     }
     catch (err) {
+        const retained = retainedUrlOutcome();
+        if (retained)
+            return retained;
+        if (signal.aborted)
+            return abortOutcome();
         notifyVideo(sessionId, "failed", prompt, undefined, err.message);
         return { status: "failed", finalText: err.message };
     }
 }
+async function runVideoRequest(request, taskSignal, timeoutMs) {
+    const requestSignal = AbortSignal.any([taskSignal, AbortSignal.timeout(timeoutMs)]);
+    const promise = request(requestSignal);
+    if (requestSignal.aborted)
+        throw requestSignal.reason;
+    return await new Promise((resolve, reject) => {
+        const onAbort = () => reject(requestSignal.reason);
+        const cleanup = () => requestSignal.removeEventListener("abort", onAbort);
+        requestSignal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
+async function abortableDelay(ms, signal) {
+    if (signal.aborted)
+        throw signal.reason;
+    await new Promise((resolve, reject) => {
+        const cleanup = () => signal.removeEventListener("abort", onAbort);
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            cleanup();
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
 function notifyVideo(sessionId, status, prompt, path, error, url) {
     if (!sessionId) {
         logger.warn("video_completion_without_session", { status });
@@ -363,11 +491,19 @@ function notifyVideo(sessionId, status, prompt, path, error, url) {
         agentId: `video-${Date.now()}`,
         name: "video generation",
         description: status === "completed"
-            ? `Video generated: ${path} (prompt: ${prompt})`
-            : `Video generation failed (prompt: ${prompt})`,
+            ? path
+                ? `Video generated: ${path} (prompt: ${prompt})`
+                : `Video rendered: ${url} (local download stopped; prompt: ${prompt})`
+            : status === "cancelled"
+                ? `Stopped waiting for video generation (prompt: ${prompt})`
+                : `Video generation failed (prompt: ${prompt})`,
         status,
-        finalText: status === "completed" ? `Video saved to ${path}.${extendHint}` : undefined,
-        error: status === "failed" ? error : undefined,
+        finalText: status === "completed"
+            ? path
+                ? `Video saved to ${path}.${extendHint}`
+                : `Video rendered successfully. Download it from ${url}.${extendHint}`
+            : undefined,
+        error: status === "failed" || status === "cancelled" ? error : undefined,
         enqueuedAt: Date.now(),
     }, sessionId);
 }

package/dist/tool-system/builtin/glob.d.ts

@@ -3,5 +3,6 @@
  */
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
+import type { ToolFailure } from "./index.js";
 export declare const globToolDef: ToolDefinition;
-export declare function globTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
+export declare function globTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string | ToolFailure>;

package/dist/tool-system/builtin/glob.js

@@ -1,9 +1,10 @@
 /**
  * Built-in Glob file search tool.
  */
-import { glob } from "glob";
+import { Glob } from "glob";
 import { stat } from "node:fs/promises";
 import * as path from "node:path";
+import { classifyPath } from "../path-policy.js";
 export const globToolDef = {
     name: "Glob",
     description: "Fast file pattern matching. Returns matching file paths sorted by modification time. " +
@@ -32,13 +33,37 @@ export async function globTool(args, ctx) {
             : path.resolve(baseDir, argPath)
         : baseDir;
     try {
-        const matches = await glob(pattern, {
+        const matcher = new Glob(pattern, {
             cwd,
             absolute: true,
             nodir: true,
             dot: false,
+            follow: false,
             ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.next/**", "**/coverage/**"],
         });
+        for (const parsedPattern of matcher.patterns) {
+            const expandedPattern = parsedPattern.globString();
+            if (parsedPattern.isAbsolute() ||
+                path.posix.isAbsolute(expandedPattern) ||
+                path.win32.isAbsolute(expandedPattern)) {
+                return "Error: Glob pattern must be relative to the search path.";
+            }
+            if (expandedPattern.split(/[\\/]/).includes("..")) {
+                return "Error: Glob pattern cannot contain a '..' path segment.";
+            }
+        }
+        const searchRoot = classifyPath(cwd, { workspaceRoot: cwd, operation: "read" }).resolvedPath;
+        const matches = (await matcher.walk()).filter((filePath) => {
+            const resolved = classifyPath(filePath, {
+                workspaceRoot: cwd,
+                operation: "read",
+            }).resolvedPath;
+            const relativeToRoot = path.relative(searchRoot, resolved);
+            return (relativeToRoot === "" ||
+                (relativeToRoot !== ".." &&
+                    !relativeToRoot.startsWith(`..${path.sep}`) &&
+                    !path.isAbsolute(relativeToRoot)));
+        });
         if (matches.length === 0) {
             return "No files matched the pattern.";
         }
@@ -71,6 +96,6 @@ export async function globTool(args, ctx) {
         return result;
     }
     catch (err) {
-        return `Error in glob: ${err.message}`;
+        return { ok: false, error: `Error in glob: ${err.message}` };
     }
 }

package/dist/tool-system/builtin/grep.d.ts

@@ -6,6 +6,7 @@ import type { ToolContext } from "../context.js";
 type ExecFileForGrep = (file: string, args: readonly string[], options: {
     maxBuffer: number;
     timeout: number;
+    signal?: AbortSignal;
 }) => Promise<{
     stdout: string;
     stderr: string;

package/dist/tool-system/builtin/grep.js

@@ -3,12 +3,56 @@
  */
 import { execFile } from "node:child_process";
 import { readdir, readFile, stat } from "node:fs/promises";
-import { promisify } from "node:util";
 import { basename, join, relative, resolve, sep, isAbsolute } from "node:path";
-const execFileAsync = promisify(execFile);
-let execFileForTest = execFileAsync;
+import { killChildTree } from "../../runtime/spawn-common.js";
+function abortError() {
+    return Object.assign(new Error("Search aborted"), { name: "AbortError" });
+}
+const execFileAbortable = (file, args, options) => new Promise((resolvePromise, reject) => {
+    if (options.signal?.aborted) {
+        reject(abortError());
+        return;
+    }
+    let settled = false;
+    const child = execFile(file, [...args], { encoding: "utf8", maxBuffer: options.maxBuffer }, (error, stdout, stderr) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        if (error) {
+            Object.assign(error, { stdout, stderr });
+            reject(error);
+        }
+        else {
+            resolvePromise({ stdout, stderr });
+        }
+    });
+    const finishWithKill = (error) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        killChildTree(child, 1000);
+        reject(error);
+    };
+    const onAbort = () => finishWithKill(abortError());
+    const timer = setTimeout(() => {
+        const error = Object.assign(new Error(`Search timed out after ${options.timeout}ms`), {
+            code: "ETIMEDOUT",
+        });
+        finishWithKill(error);
+    }, options.timeout);
+    const cleanup = () => {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted)
+        onAbort();
+});
+let execFileForTest = execFileAbortable;
 export function _setGrepExecFileForTest(fn) {
-    execFileForTest = fn ?? execFileAsync;
+    execFileForTest = fn ?? execFileAbortable;
 }
 /**
  * Strip the cwd prefix from each line so results display as relative
@@ -39,7 +83,10 @@ export const grepToolDef = {
             pattern: { type: "string", description: "Regular expression pattern to search for" },
             path: { type: "string", description: "File or directory to search in (default: cwd)" },
             glob: { type: "string", description: 'Glob pattern to filter files (e.g. "*.ts")' },
-            context: { type: "number", description: "Lines of context around matches (only with output_mode content)" },
+            context: {
+                type: "number",
+                description: "Lines of context around matches (only with output_mode content)",
+            },
             max_results: { type: "number", description: "Maximum number of results (default: 50)" },
             output_mode: {
                 type: "string",
@@ -69,29 +116,36 @@ export async function grepTool(args, ctx) {
     const outputMode = args.output_mode || "files_with_matches";
     const caseInsensitive = args.case_insensitive || false;
     try {
-        return await runRipgrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+        return await runRipgrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive, ctx?.signal);
     }
     catch (rgErr) {
+        if (isAbort(rgErr, ctx?.signal))
+            throw rgErr;
         // rg/grep exit code 1 = no matches (not an error)
         if (isNoMatchExit(rgErr))
             return "No matches found.";
         try {
-            return await runGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+            return await runGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive, ctx?.signal);
         }
         catch (grepErr) {
+            if (isAbort(grepErr, ctx?.signal))
+                throw grepErr;
             if (isNoMatchExit(grepErr))
                 return "No matches found.";
             if (isCommandNotFound(rgErr) || isCommandNotFound(grepErr)) {
-                return await runNodeGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+                return await runNodeGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive, ctx?.signal);
             }
-            return `Error in search: ${grepErr.message}`;
+            throw new Error(`Error in search: ${grepErr.message}`, { cause: grepErr });
         }
     }
 }
+function isAbort(error, signal) {
+    return signal?.aborted === true || error?.name === "AbortError";
+}
 function isCommandNotFound(err) {
     return err?.code === "ENOENT";
 }
-async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive, signal) {
     const args = ["--color=never"];
     if (caseInsensitive)
         args.push("-i");
@@ -116,6 +170,7 @@ async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMo
     const { stdout } = await execFileForTest("rg", args, {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 30_000,
+        signal,
     });
     const result = relativizeOutput(stdout, path).trim();
     if (!result)
@@ -127,7 +182,7 @@ async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMo
     }
     return result;
 }
-async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive, signal) {
     const args = ["-r", "--color=never"];
     if (caseInsensitive)
         args.push("-i");
@@ -153,6 +208,7 @@ async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode,
     const { stdout } = await execFileForTest("grep", args, {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 30_000,
+        signal,
     });
     const result = relativizeOutput(stdout, path).trim();
     if (!result)
@@ -164,16 +220,18 @@ async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode,
     return result;
 }
 const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "coverage"]);
-async function runNodeGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+async function runNodeGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive, signal) {
+    signal?.throwIfAborted();
     let regex;
     try {
         regex = new RegExp(pattern, caseInsensitive ? "i" : "");
     }
     catch (err) {
-        return `Error in search: ${err.message}`;
+        throw new Error(`Error in search: ${err.message}`, { cause: err });
     }
     const matches = [];
     await walkTextFiles(path, fileGlob, async (file) => {
+        signal?.throwIfAborted();
         if (matches.length >= maxResults)
             return;
         let text;
@@ -214,15 +272,17 @@ async function runNodeGrep(pattern, path, fileGlob, context, maxResults, outputM
                 }
             }
         }
-    });
+    }, signal);
     if (matches.length === 0)
         return "No matches found.";
     if (matches.length > 200)
         return matches.slice(0, 200).join("\n") + `\n\n... ${matches.length - 200} more results`;
     return matches.join("\n");
 }
-async function walkTextFiles(root, fileGlob, visit) {
+async function walkTextFiles(root, fileGlob, visit, signal) {
+    signal?.throwIfAborted();
     const info = await stat(root).catch(() => null);
+    signal?.throwIfAborted();
     if (!info)
         return;
     if (info.isFile()) {
@@ -233,11 +293,13 @@ async function walkTextFiles(root, fileGlob, visit) {
     if (!info.isDirectory())
         return;
     const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    signal?.throwIfAborted();
     for (const entry of entries) {
+        signal?.throwIfAborted();
         if (entry.isDirectory()) {
             if (IGNORED_DIRS.has(entry.name))
                 continue;
-            await walkTextFiles(join(root, entry.name), fileGlob, visit);
+            await walkTextFiles(join(root, entry.name), fileGlob, visit, signal);
         }
         else if (entry.isFile()) {
             if (!fileGlob || matchesSimpleGlob(entry.name, fileGlob))
@@ -246,6 +308,9 @@ async function walkTextFiles(root, fileGlob, visit) {
     }
 }
 function matchesSimpleGlob(name, glob) {
-    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const escaped = glob
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
     return new RegExp(`^${escaped}$`).test(name);
 }

package/dist/tool-system/builtin/image-uploader.js

@@ -10,7 +10,13 @@ export function isHttpUrl(s) {
 }
 function mimeFromName(name) {
     const ext = name.toLowerCase().split(".").pop() ?? "";
-    const map = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp", gif: "image/gif" };
+    const map = {
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        webp: "image/webp",
+        gif: "image/gif",
+    };
     return map[ext] ?? "application/octet-stream";
 }
 export class FalStorageUploader {