@yeaft/webchat-agent 1.0.317 → 1.0.320

package/package.json

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

package/yeaft/tools/disk-usage.js

@@ -4,12 +4,18 @@ import { basename, join, relative, resolve } from 'node:path';
 import { defineTool } from './types.js';
 import { managedCliToolReady, resolveManagedCliCommand } from '../managed-cli.js';
 import { runProcess } from './process-runner.js';
-import { isAbortError, throwIfAborted, waitForAbortable } from './search-paths.js';
+import {
+  isAbortError,
+  SearchBackendLimitError,
+  throwIfAborted,
+  waitForAbortable,
+} from './search-paths.js';
 
 const FALLBACK_CONCURRENCY = 16;
 const MAX_LIMIT = 200;
 const MAX_DEPTH = 10;
 const MAX_OUTPUT_BYTES = 512 * 1024;
+const DUST_RESULT_ROWS = MAX_LIMIT;
 
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes}B`;
@@ -40,10 +46,16 @@ function flattenDustTree(root, baseDir, depth, limit) {
   return [total, ...rows.slice(0, Math.max(0, limit - 1))].filter(Boolean);
 }
 
-async function runDust(command, baseDir, { depth, limit, signal }) {
-  const result = await runProcess(command, [
+export async function runDust(
+  command,
+  baseDir,
+  { depth, limit, signal },
+  processRunner = runProcess,
+) {
+  const result = await processRunner(command, [
     '--output-json',
     '--depth', String(depth),
+    '--number-of-lines', String(DUST_RESULT_ROWS),
     '--apparent-size',
     '--only-dir',
     '--no-progress',
@@ -56,8 +68,10 @@ async function runDust(command, baseDir, { depth, limit, signal }) {
     maxBytes: MAX_OUTPUT_BYTES,
     env: { ...process.env, NO_COLOR: '1' },
   });
-  if (result.timedOut) throw new Error('dust timed out');
-  if (result.truncated) throw new Error('dust output exceeded the tool limit');
+  if (result.timedOut) throw new SearchBackendLimitError('dust timed out');
+  if (result.truncated) {
+    throw new SearchBackendLimitError('dust output exceeded the tool limit');
+  }
   if (result.code !== 0) throw new Error(result.stderr.trim() || `dust exited with code ${result.code}`);
   return flattenDustTree(JSON.parse(result.stdout), baseDir, depth, limit);
 }
@@ -229,7 +243,7 @@ symlink is scanned like dust; descendant symlinks are not followed.`,
         try {
           rows = await runDust(dustCommand, baseDir, { depth, limit, signal: ctx?.signal });
         } catch (error) {
-          if (isAbortError(error)) throw error;
+          if (isAbortError(error) || error instanceof SearchBackendLimitError) throw error;
           rows = null;
         }
       }

package/yeaft/tools/glob.js

@@ -12,9 +12,11 @@ import { resolve, join, relative } from 'path';
 import { managedCliToolReady, resolveManagedCliCommand } from '../managed-cli.js';
 import { runProcess } from './process-runner.js';
 import {
+  createFdPathRegex,
   createSearchPathMatcher,
   isAbortError,
   isSkippedSearchDirectory,
+  SearchBackendLimitError,
   SEARCH_SKIP_DIRS,
   throwIfAborted,
   waitForAbortable,
@@ -68,9 +70,16 @@ async function* walkDir(dir, baseDir, signal, maxDepth = 10, depth = 0) {
   }
 }
 
-async function listFilesWithFd(fdCommand, baseDir, signal) {
+export async function listFilesWithFd(
+  fdCommand,
+  baseDir,
+  pattern,
+  signal,
+  processRunner = runProcess,
+) {
   const args = [
-    '.', baseDir,
+    '--full-path',
+    '--case-sensitive',
     '--type', 'file',
     '--type', 'symlink',
     '--hidden',
@@ -81,15 +90,18 @@ async function listFilesWithFd(fdCommand, baseDir, signal) {
   ];
   for (const skipped of SEARCH_SKIP_DIRS) args.push('--exclude', skipped);
   args.push('--exclude', '.yeaft/worktrees', '--exclude', '**/.yeaft/worktrees/**');
-  const result = await runProcess(fdCommand, args, {
+  args.push('--', createFdPathRegex(pattern), '.');
+  const result = await processRunner(fdCommand, args, {
     cwd: baseDir,
     signal,
     timeoutMs: 120_000,
     maxBytes: 16 * 1024 * 1024,
     preserveCarriageReturns: true,
   });
-  if (result.timedOut) throw new Error('fd timed out');
-  if (result.truncated) throw new Error('fd output exceeded the tool limit');
+  if (result.timedOut) throw new SearchBackendLimitError('fd timed out');
+  if (result.truncated) {
+    throw new SearchBackendLimitError('fd output exceeded the tool limit');
+  }
   if (result.code !== 0) {
     throw new Error(result.stderr.trim() || `fd exited with code ${result.code}`);
   }
@@ -176,10 +188,10 @@ Guidelines:
       }
       if (fdCommand) {
         try {
-          paths = (await listFilesWithFd(fdCommand, baseDir, ctx?.signal))
+          paths = (await listFilesWithFd(fdCommand, baseDir, pattern, ctx?.signal))
             .filter(path => matchGlob(pattern, path));
         } catch (error) {
-          if (isAbortError(error)) throw error;
+          if (isAbortError(error) || error instanceof SearchBackendLimitError) throw error;
           paths = null;
         }
       }

package/yeaft/tools/grep.js

@@ -18,6 +18,7 @@ import {
   SEARCH_SKIP_GLOBS,
   isAbortError,
   isSkippedSearchDirectory,
+  SearchBackendLimitError,
   throwIfAborted,
   waitForAbortable,
 } from './search-paths.js';
@@ -348,7 +349,6 @@ export function runRipgrep(pattern, searchPath, options, spawnProcess = spawn, c
     if (options.after) args.push('-A', String(options.after));
     if (options.context || options.before || options.after) args.push('--no-context-separator');
     if (options.multiline) args.push('-U', '--multiline-dotall');
-    args.push('--sort', 'path');
     args.push('--', pattern);
     if (searchTarget) args.push(searchTarget);
 
@@ -517,7 +517,12 @@ export function runRipgrep(pattern, searchPath, options, spawnProcess = spawn, c
   });
 }
 
-async function listRipgrepCandidatePaths(command, searchPath, options) {
+export async function listRipgrepCandidatePaths(
+  command,
+  searchPath,
+  options,
+  processRunner = runProcess,
+) {
   throwIfAborted(options.signal);
   const searchStat = await lstat(searchPath);
   const baseDir = searchStat.isDirectory() ? searchPath : dirname(searchPath);
@@ -532,8 +537,8 @@ async function listRipgrepCandidatePaths(command, searchPath, options) {
   ];
   if (options.fixedStrings) args.push('-F');
   for (const skipGlob of SEARCH_SKIP_GLOBS) args.push('--glob', skipGlob);
-  args.push('--sort', 'path', '--', options.pattern, target);
-  const result = await runProcess(command, args, {
+  args.push('--max-filesize', String(MAX_TEXT_FILE_BYTES), '--', options.pattern, target);
+  const result = await processRunner(command, args, {
     cwd: baseDir,
     env: createRipgrepEnv(),
     signal: options.signal,
@@ -541,8 +546,10 @@ async function listRipgrepCandidatePaths(command, searchPath, options) {
     maxBytes: MAX_CANDIDATE_BYTES,
     preserveCarriageReturns: true,
   });
-  if (result.timedOut) throw new Error('rg timed out');
-  if (result.truncated) throw new Error('rg candidate output exceeded the tool limit');
+  if (result.timedOut) throw new SearchBackendLimitError('rg timed out');
+  if (result.truncated) {
+    throw new SearchBackendLimitError('rg candidate output exceeded the tool limit');
+  }
   if (result.code !== 0 && result.code !== 1) {
     throw new Error(result.stderr.trim() || `rg exited with code ${result.code}`);
   }
@@ -761,7 +768,23 @@ export async function nodeGrep(pattern, searchPath, options) {
   }
 
   throwIfAborted(options.signal);
-  if (rootStat.isDirectory()) await searchDir(searchPath);
+  if (candidatePaths) {
+    const orderedCandidates = [...candidatePaths]
+      .sort((left, right) => compareSearchPaths(
+        relative(searchBase, left).replace(/\\/g, '/'),
+        relative(searchBase, right).replace(/\\/g, '/'),
+      ));
+    for (let index = 0; index < orderedCandidates.length && !stopped; index += FALLBACK_CONCURRENCY) {
+      throwIfAborted(options.signal);
+      const batches = await Promise.all(
+        orderedCandidates.slice(index, index + FALLBACK_CONCURRENCY).map(collectFileRecords),
+      );
+      for (const batch of batches) {
+        addFileRecords(batch);
+        if (stopped) break;
+      }
+    }
+  } else if (rootStat.isDirectory()) await searchDir(searchPath);
   else addFileRecords(await collectFileRecords(searchPath));
   const result = output.toString();
   return options.structured
@@ -960,7 +983,7 @@ Guidelines:
           });
           result = await nodeGrep(pattern, absPath, { ...options, candidatePaths });
         } catch (error) {
-          if (isAbortError(error)) throw error;
+          if (isAbortError(error) || error instanceof SearchBackendLimitError) throw error;
           result = await nodeGrep(pattern, absPath, options);
         }
       } else {

package/yeaft/tools/search-paths.js

@@ -34,7 +34,7 @@ function expandBraces(pattern) {
   ));
 }
 
-function globToRegExp(pattern) {
+function globToRegExpSource(pattern, separator = '/') {
   let source = '';
   for (let index = 0; index < pattern.length; index += 1) {
     const char = pattern[index];
@@ -42,19 +42,33 @@ function globToRegExp(pattern) {
       index += 1;
       if (pattern[index + 1] === '/') {
         index += 1;
-        source += '(?:.*/)?';
+        source += `(?:[\\s\\S]*${separator})?`;
       } else {
-        source += '.*';
+        source += '[\\s\\S]*';
       }
     } else if (char === '*') {
-      source += '[^/]*';
+      source += separator === '/' ? '[^/]*' : '[^\\\\/]*';
     } else if (char === '?') {
-      source += '[^/]';
+      source += separator === '/' ? '[^/]' : '[^\\\\/]';
+    } else if (char === '/') {
+      source += separator;
     } else {
       source += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
     }
   }
-  return new RegExp(`^${source}$`);
+  return source;
+}
+
+function globToRegExp(pattern) {
+  return new RegExp(`^${globToRegExpSource(pattern)}$`);
+}
+
+/** Compile the public glob dialect for fd --full-path on POSIX and Windows. */
+export function createFdPathRegex(glob) {
+  const normalizedGlob = String(glob || '').replace(/\\/g, '/');
+  const alternatives = expandBraces(normalizedGlob || '**/*')
+    .map(pattern => globToRegExpSource(pattern, '[\\\\/]'));
+  return `(?:^|[\\\\/])(?:${alternatives.join('|')})$`;
 }
 
 export function createSearchPathMatcher({ glob, type } = {}) {
@@ -106,3 +120,10 @@ export function waitForAbortable(promise, signal) {
     );
   });
 }
+
+export class SearchBackendLimitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'SearchBackendLimitError';
+  }
+}

package/yeaft/web-bridge.js

@@ -86,7 +86,8 @@ import { listMcpServers, upsertMcpServer, removeMcpServer } from './config-api.j
 import { buildMcpFlattenedTools } from './tools/mcp-tools.js';
 import { getAgentRegistry, agentBelongsToScope } from './tools/agent.js';
 import { enqueueSubAgentPrompt } from './sub-agent/prompt-queue.js';
-import { isPromptableAgentStatus } from './sub-agent/status.js';
+import { isPromptableAgentStatus, isTerminalAgentStatus, STATUS } from './sub-agent/status.js';
+import { consumeNotificationForAgent } from './sub-agent/notifications.js';
 import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
 import { recordAgentSessionCreated, recordAgentTurn } from '../metrics.js';
 import { TASK_RESULT_DELIVERY, isTerminalTaskStatus, taskResultDeliveryFor } from './tasks/store.js';
@@ -6577,6 +6578,38 @@ export function handleYeaftTaskCancel(msg) {
     return;
   }
 
+  const existingTask = session.taskManager.getTask?.(sessionId, taskId) || null;
+  if (existingTask?.kind === 'sub_agent' && existingTask.status === 'running') {
+    const subAgentId = existingTask.runtime?.subAgentId || '';
+    const agent = subAgentId ? getAgentRegistry().get(subAgentId) : null;
+    const scope = {
+      sessionId,
+      parentVpId: existingTask.ownerVpId || null,
+      parentThreadId: existingTask.source?.threadId || 'main',
+    };
+    if (!agent || !agentBelongsToScope(agent, scope)) {
+      fail('sub-agent not found', existingTask);
+      return;
+    }
+    if (!isTerminalAgentStatus(agent.status)) {
+      agent.status = STATUS.CLOSED;
+      if (agent.abortController && !agent.abortController.signal.aborted) {
+        try { agent.abortController.abort('stopped_by_user'); } catch { /* best effort */ }
+      }
+    }
+    try { consumeNotificationForAgent(agent.id); } catch { /* best effort */ }
+    const task = session.taskManager.completeTask(sessionId, taskId, { status: 'cancelled' });
+    sendSessionEvent({
+      type: 'yeaft_task_cancel_result',
+      success: true,
+      taskId,
+      clientRequestId: clientRequestId || null,
+      pending: false,
+      task,
+    }, { sessionId, vpId: task?.ownerVpId || null, threadId: task?.source?.threadId || null });
+    return;
+  }
+
   let result;
   try {
     result = session.taskManager.cancelTask(sessionId, taskId);