@yeaft/webchat-agent 1.0.300 → 1.0.302

package/yeaft/tools/index.js

@@ -37,6 +37,7 @@ import fileEdit from './file-edit.js';
 import globTool from './glob.js';
 import grepTool from './grep.js';
 import listDir from './list-dir.js';
+import diskUsage from './disk-usage.js';
 import applyPatch from './apply-patch.js';
 import listTasks from './list-tasks.js';
 import readTaskLog from './read-task-log.js';
@@ -102,6 +103,7 @@ export const allTools = [
   globTool,
   grepTool,
   listDir,
+  diskUsage,
   applyPatch,
   listTasks,
   readTaskLog,

package/yeaft/tools/process-runner.js

@@ -0,0 +1,211 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+
+const DEFAULT_MAX_BYTES = 512 * 1024;
+const DEFAULT_KILL_GRACE_MS = 250;
+const DEFAULT_FORCE_SETTLE_MS = 1000;
+
+function abortError(signal) {
+  if (signal?.reason instanceof Error && signal.reason.name === 'AbortError') return signal.reason;
+  const error = new Error(
+    signal?.reason instanceof Error ? signal.reason.message : 'The operation was aborted',
+  );
+  error.name = 'AbortError';
+  return error;
+}
+
+function killProcessTree(proc, signal, platform, spawnProcessSync) {
+  if (!proc.pid) return false;
+  if (platform === 'win32') {
+    try {
+      const result = spawnProcessSync('taskkill', ['/pid', String(proc.pid), '/t', '/f'], {
+        stdio: 'ignore',
+        windowsHide: true,
+        timeout: 5000,
+      });
+      if (!result.error && result.status === 0) return true;
+    } catch {}
+    try { return proc.kill(signal) !== false; } catch { return false; }
+  }
+  try {
+    process.kill(-proc.pid, signal);
+    return true;
+  } catch {
+    try { return proc.kill(signal) !== false; } catch { return false; }
+  }
+}
+
+/**
+ * Execute a binary directly without a shell and keep captured output bounded.
+ *
+ * @param {string} command
+ * @param {string[]} args
+ * @param {{ cwd?: string, signal?: AbortSignal, timeoutMs?: number, maxBytes?: number, env?: NodeJS.ProcessEnv, preserveCarriageReturns?: boolean, killGraceMs?: number, forceSettleMs?: number, platform?: NodeJS.Platform, spawnProcess?: typeof spawn, spawnProcessSync?: typeof spawnSync }} [options]
+ */
+export function runProcess(command, args, options = {}) {
+  if (options.signal?.aborted) return Promise.reject(abortError(options.signal));
+
+  return new Promise((resolve, reject) => {
+    const platform = options.platform || process.platform;
+    const spawnProcess = options.spawnProcess || spawn;
+    const spawnProcessSync = options.spawnProcessSync || spawnSync;
+    const maxBytes = Number.isFinite(options.maxBytes)
+      ? Math.max(0, options.maxBytes)
+      : DEFAULT_MAX_BYTES;
+    const killGraceMs = Number.isFinite(options.killGraceMs)
+      ? Math.max(0, options.killGraceMs)
+      : DEFAULT_KILL_GRACE_MS;
+    const forceSettleMs = Number.isFinite(options.forceSettleMs)
+      ? Math.max(1, options.forceSettleMs)
+      : DEFAULT_FORCE_SETTLE_MS;
+    const proc = spawnProcess(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+      detached: platform !== 'win32',
+    });
+    const stdout = [];
+    const stderr = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    let truncated = false;
+    let settled = false;
+    let timedOut = false;
+    let aborted = false;
+    let stopRequested = false;
+    let forceRequested = false;
+    let timer = null;
+    let forceTimer = null;
+    let forceSettleTimer = null;
+
+    let onStdout;
+    let onStderr;
+    let onError;
+    let onClose;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
+      if (forceSettleTimer) clearTimeout(forceSettleTimer);
+      timer = null;
+      forceTimer = null;
+      forceSettleTimer = null;
+      options.signal?.removeEventListener('abort', onAbort);
+      if (onStdout) proc.stdout?.off('data', onStdout);
+      if (onStderr) proc.stderr?.off('data', onStderr);
+      if (onError) proc.off('error', onError);
+      if (onClose) proc.off('close', onClose);
+    };
+    const decode = (chunks, wasTruncated, preserveCarriageReturns = false) => {
+      const decoder = new StringDecoder('utf8');
+      let value = decoder.write(Buffer.concat(chunks));
+      if (!wasTruncated) value += decoder.end();
+      return preserveCarriageReturns ? value : value.replace(/\r/g, '');
+    };
+    const finish = code => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (aborted) {
+        reject(abortError(options.signal));
+        return;
+      }
+      resolve({
+        code: timedOut ? 124 : (code ?? 1),
+        stdout: decode(stdout, stdoutTruncated, options.preserveCarriageReturns),
+        stderr: decode(stderr, stderrTruncated),
+        truncated,
+        timedOut,
+      });
+    };
+    const forceStop = () => {
+      if (settled || forceRequested) return;
+      forceRequested = true;
+      killProcessTree(proc, 'SIGKILL', platform, spawnProcessSync);
+      forceSettleTimer = setTimeout(() => finish(null), forceSettleMs);
+      forceSettleTimer.unref?.();
+    };
+    const stop = () => {
+      if (settled || stopRequested) return;
+      stopRequested = true;
+      if (platform === 'win32') {
+        // taskkill must run while the parent PID still identifies the tree.
+        // It is already forceful, so do not wait for the direct child to exit.
+        forceRequested = true;
+        killProcessTree(proc, 'SIGKILL', platform, spawnProcessSync);
+        if (!settled) {
+          forceSettleTimer = setTimeout(() => finish(null), forceSettleMs);
+          forceSettleTimer.unref?.();
+        }
+        return;
+      }
+      killProcessTree(proc, 'SIGTERM', platform, spawnProcessSync);
+      forceTimer = setTimeout(forceStop, killGraceMs);
+      forceTimer.unref?.();
+    };
+    const onAbort = () => {
+      aborted = true;
+      stop();
+    };
+    const capture = (target, chunk, isStdout) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const current = isStdout ? stdoutBytes : stderrBytes;
+      const remaining = maxBytes - current;
+      if (remaining <= 0) {
+        truncated = true;
+        if (isStdout) stdoutTruncated = true;
+        else stderrTruncated = true;
+        stop();
+        return;
+      }
+      const bounded = buffer.length > remaining ? buffer.subarray(0, remaining) : buffer;
+      target.push(bounded);
+      if (isStdout) stdoutBytes += bounded.length;
+      else stderrBytes += bounded.length;
+      if (bounded.length !== buffer.length) {
+        truncated = true;
+        if (isStdout) stdoutTruncated = true;
+        else stderrTruncated = true;
+        stop();
+      }
+    };
+
+    onStdout = chunk => capture(stdout, chunk, true);
+    onStderr = chunk => capture(stderr, chunk, false);
+    onError = error => {
+      if (settled) return;
+      if (stopRequested) {
+        finish(null);
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    onClose = code => {
+      if (stopRequested && !forceRequested) {
+        // The direct child is gone. Kill any process that remained in its
+        // detached group before releasing the tool call.
+        forceRequested = true;
+        killProcessTree(proc, 'SIGKILL', platform, spawnProcessSync);
+      }
+      finish(code);
+    };
+    proc.stdout.on('data', onStdout);
+    proc.stderr.on('data', onStderr);
+    proc.on('error', onError);
+    proc.on('close', onClose);
+
+    if (Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        stop();
+      }, options.timeoutMs);
+      timer.unref?.();
+    }
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options.signal?.aborted) onAbort();
+  });
+}

package/yeaft/tools/search-paths.js

@@ -0,0 +1,108 @@
+import { extname } from 'node:path';
+
+export const SEARCH_SKIP_DIRS = new Set([
+  'node_modules', '.git', '__pycache__', '.next', '.nuxt',
+  'dist', 'build', '.cache', '.venv', 'venv', '.tox',
+  'vendor', 'target', '.gradle', '.idea', '.vscode',
+]);
+
+export const SEARCH_SKIP_GLOBS = Object.freeze([
+  ...[...SEARCH_SKIP_DIRS].flatMap(name => [`!${name}/**`, `!**/${name}/**`]),
+  '!.yeaft/worktrees/**',
+  '!**/.yeaft/worktrees/**',
+]);
+
+const TYPE_EXTENSIONS = {
+  js: ['.js', '.jsx', '.mjs', '.cjs'], ts: ['.ts', '.tsx', '.mts', '.cts'],
+  py: ['.py'], rust: ['.rs'], go: ['.go'], java: ['.java'],
+  json: ['.json'], yaml: ['.yaml', '.yml'], markdown: ['.md', '.markdown'],
+  html: ['.html', '.htm'], css: ['.css'], shell: ['.sh', '.bash', '.zsh'],
+};
+
+export function isSkippedSearchDirectory(relativePath, name) {
+  const normalized = String(relativePath || '').replace(/\\/g, '/');
+  return SEARCH_SKIP_DIRS.has(name)
+    || normalized === '.yeaft/worktrees'
+    || normalized.endsWith('/.yeaft/worktrees');
+}
+
+function expandBraces(pattern) {
+  const match = pattern.match(/\{([^{}]+)\}/);
+  if (!match) return [pattern];
+  return match[1].split(',').flatMap(part => expandBraces(
+    pattern.slice(0, match.index) + part + pattern.slice(match.index + match[0].length),
+  ));
+}
+
+function globToRegExp(pattern) {
+  let source = '';
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === '*' && pattern[index + 1] === '*') {
+      index += 1;
+      if (pattern[index + 1] === '/') {
+        index += 1;
+        source += '(?:.*/)?';
+      } else {
+        source += '.*';
+      }
+    } else if (char === '*') {
+      source += '[^/]*';
+    } else if (char === '?') {
+      source += '[^/]';
+    } else {
+      source += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+export function createSearchPathMatcher({ glob, type } = {}) {
+  const normalizedGlob = String(glob || '').replace(/\\/g, '/');
+  const globMatchers = normalizedGlob
+    ? expandBraces(normalizedGlob).map(globToRegExp)
+    : [];
+  const matchBase = normalizedGlob && !normalizedGlob.includes('/');
+  const extensions = type ? TYPE_EXTENSIONS[type] : null;
+
+  return path => {
+    const normalized = String(path || '').replace(/\\/g, '/');
+    const candidate = matchBase ? normalized.split('/').pop() : normalized;
+    if (globMatchers.length && !globMatchers.some(matcher => matcher.test(candidate))) return false;
+    if (type && !extensions?.includes(extname(normalized).toLowerCase())) return false;
+    return true;
+  };
+}
+
+export function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  if (signal.reason instanceof Error && signal.reason.name === 'AbortError') {
+    throw signal.reason;
+  }
+  const error = new Error(
+    signal.reason instanceof Error ? signal.reason.message : 'The operation was aborted',
+  );
+  error.name = 'AbortError';
+  throw error;
+}
+
+export function isAbortError(error) {
+  return error?.name === 'AbortError';
+}
+
+export function waitForAbortable(promise, signal) {
+  throwIfAborted(signal);
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      try { throwIfAborted(signal); } catch (error) { reject(error); }
+    };
+    const cleanup = () => signal.removeEventListener('abort', onAbort);
+    signal.addEventListener('abort', onAbort, { once: true });
+    Promise.resolve(promise).then(
+      value => { cleanup(); resolve(value); },
+      error => { cleanup(); reject(error); },
+    );
+  });
+}

package/yeaft/tools/types.js

@@ -14,6 +14,7 @@
  * @typedef {Object} ToolContext
  * @property {AbortSignal} [signal] — cancellation signal
  * @property {string} [yeaftDir] — Yeaft data directory
+ * @property {Promise<Array> & {toolReady?: Record<string, Promise<object>>}} [managedCliReady] — resolves after optional managed CLI setup; toolReady exposes per-command readiness
  * @property {ReturnType<import('../runtime-platform.js').getRuntimePlatformInfo>} [runtimePlatform]
  *   — runtime OS/shell facts for platform-aware tools
  * @property {string} [cwd] — working directory

package/yeaft/web-bridge.js

@@ -1779,6 +1779,7 @@ function getOrCreateVpEngine(sessionId, vpId, threadId = 'main') {
     skillManager: session.skillManager,
     mcpManager: session.mcpManager,
     yeaftDir: session.yeaftDir,
+    managedCliReady: session.managedCliReady || null,
     // Share the session-shared ToolUsageStats so per-VP tool calls land
     // in the same on-disk snapshot the `yeaft_fetch_tool_stats` handler
     // reads. Without this, engine's record-on-tool-exec guard
@@ -4836,6 +4837,7 @@ export async function ensureSessionLoaded(opts = {}) {
       skipMCP: true,
       skipSkills: true,
       serverMode: true,
+      managedCliReady: ctx.managedCliReady,
     });
     claimRuntimeOwnership(session);
 
@@ -7112,6 +7114,7 @@ export async function resetYeaftSession() {
       skipMCP: true,
       skipSkills: true,
       serverMode: true,
+      managedCliReady: ctx.managedCliReady,
     });
     claimRuntimeOwnership(session);
     installYeaftRuntimeBridge(session);