@yeaft/webchat-agent 0.0.233 → 0.0.235

package/workbench/file-ops.js

@@ -0,0 +1,436 @@
+import { readFile, writeFile, readdir, stat, unlink, rename, mkdir, rm, copyFile, cp } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, basename, dirname, extname } from 'path';
+import { platform } from 'os';
+import ctx from '../context.js';
+import { resolveAndValidatePath, BINARY_EXTENSIONS } from './utils.js';
+
+export async function handleReadFile(msg) {
+  const { conversationId, filePath, _requestUserId } = msg;
+  console.log('[Agent] handleReadFile received:', { filePath, conversationId, workDir: msg.workDir });
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+
+  try {
+    const resolved = resolveAndValidatePath(filePath, workDir);
+    const ext = extname(resolved).toLowerCase();
+    const mimeType = BINARY_EXTENSIONS[ext];
+
+    if (mimeType) {
+      // Binary file: read as Buffer, send base64
+      const buffer = await readFile(resolved);
+      console.log('[Agent] Sending binary file_content:', { filePath: resolved, size: buffer.length, mimeType, conversationId });
+      ctx.sendToServer({
+        type: 'file_content',
+        conversationId,
+        _requestUserId,
+        filePath: resolved,
+        content: buffer.toString('base64'),
+        binary: true,
+        mimeType
+      });
+    } else {
+      // Text file: read as utf-8
+      const content = await readFile(resolved, 'utf-8');
+
+      // 检测语言
+      const langMap = {
+        '.js': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
+        '.ts': 'javascript', '.tsx': 'javascript', '.jsx': 'javascript',
+        '.py': 'python', '.pyw': 'python',
+        '.html': 'htmlmixed', '.htm': 'htmlmixed',
+        '.css': 'css', '.scss': 'css', '.less': 'css',
+        '.json': 'javascript',
+        '.md': 'markdown',
+        '.sh': 'shell', '.bash': 'shell', '.zsh': 'shell',
+        '.cs': 'text/x-csharp', '.java': 'text/x-java',
+        '.cpp': 'text/x-c++src', '.c': 'text/x-csrc', '.h': 'text/x-csrc',
+        '.xml': 'xml', '.svg': 'xml',
+        '.yaml': 'yaml', '.yml': 'yaml',
+        '.sql': 'sql',
+        '.go': 'go', '.rs': 'rust', '.rb': 'ruby',
+        '.php': 'php', '.swift': 'swift'
+      };
+
+      console.log('[Agent] Sending file_content:', { filePath: resolved, contentLen: content.length, conversationId });
+      ctx.sendToServer({
+        type: 'file_content',
+        conversationId,
+        _requestUserId,
+        filePath: resolved,
+        content,
+        language: langMap[ext] || null
+      });
+    }
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'file_content',
+      conversationId,
+      _requestUserId,
+      filePath,
+      content: '',
+      error: e.message
+    });
+  }
+}
+
+export async function handleWriteFile(msg) {
+  const { conversationId, filePath, content, _requestUserId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+
+  try {
+    const resolved = resolveAndValidatePath(filePath, workDir);
+    await writeFile(resolved, content, 'utf-8');
+
+    ctx.sendToServer({
+      type: 'file_saved',
+      conversationId,
+      _requestUserId,
+      filePath: resolved,
+      success: true
+    });
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'file_saved',
+      conversationId,
+      _requestUserId,
+      filePath,
+      success: false,
+      error: e.message
+    });
+  }
+}
+
+export async function handleListDirectory(msg) {
+  const { conversationId, dirPath, _requestUserId, _requestClientId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+
+  // 空路径：列出驱动器（Windows）或根目录（Unix）
+  if (!dirPath || dirPath === '') {
+    try {
+      if (platform() === 'win32') {
+        const drives = [];
+        for (const letter of 'CDEFGHIJKLMNOPQRSTUVWXYZ'.split('')) {
+          const drivePath = letter + ':\\';
+          if (existsSync(drivePath)) {
+            drives.push({ name: letter + ':', type: 'directory', size: 0 });
+          }
+        }
+        ctx.sendToServer({
+          type: 'directory_listing',
+          conversationId,
+          _requestUserId,
+          _requestClientId,
+          dirPath: '',
+          entries: drives
+        });
+      } else {
+        // Unix: 列出根目录
+        const entries = await readdir('/', { withFileTypes: true });
+        const result = entries
+          .filter(e => !e.name.startsWith('.'))
+          .map(e => ({ name: e.name, type: e.isDirectory() ? 'directory' : 'file', size: 0 }))
+          .sort((a, b) => a.name.localeCompare(b.name));
+        ctx.sendToServer({
+          type: 'directory_listing',
+          conversationId,
+          _requestUserId,
+          _requestClientId,
+          dirPath: '/',
+          entries: result
+        });
+      }
+    } catch (e) {
+      ctx.sendToServer({
+        type: 'directory_listing',
+        conversationId,
+        _requestUserId,
+        _requestClientId,
+        dirPath: '',
+        entries: [],
+        error: e.message
+      });
+    }
+    return;
+  }
+
+  try {
+    const resolved = resolveAndValidatePath(dirPath, workDir);
+    const entries = await readdir(resolved, { withFileTypes: true });
+    const result = [];
+
+    for (const entry of entries) {
+      // 跳过隐藏文件和 node_modules
+      if (entry.name.startsWith('.') && entry.name !== '..') continue;
+      if (entry.name === 'node_modules') continue;
+
+      try {
+        const fullPath = join(resolved, entry.name);
+        const s = await stat(fullPath);
+        result.push({
+          name: entry.name,
+          type: entry.isDirectory() ? 'directory' : 'file',
+          size: s.size
+        });
+      } catch {
+        result.push({
+          name: entry.name,
+          type: entry.isDirectory() ? 'directory' : 'file',
+          size: 0
+        });
+      }
+    }
+
+    // 排序：目录在前，文件在后，各自按名称排序
+    result.sort((a, b) => {
+      if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    ctx.sendToServer({
+      type: 'directory_listing',
+      conversationId,
+      _requestUserId,
+      _requestClientId,
+      dirPath: resolved,
+      entries: result
+    });
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'directory_listing',
+      conversationId,
+      _requestUserId,
+      _requestClientId,
+      dirPath: dirPath || workDir,
+      entries: [],
+      error: e.message
+    });
+  }
+}
+
+export async function handleCreateFile(msg) {
+  const { conversationId, filePath, isDirectory, _requestUserId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+
+  try {
+    const resolved = resolveAndValidatePath(filePath, workDir);
+    if (isDirectory) {
+      await mkdir(resolved, { recursive: true });
+    } else {
+      // Ensure parent directory exists
+      const parentDir = dirname(resolved);
+      await mkdir(parentDir, { recursive: true });
+      // Create file only if it doesn't exist
+      if (existsSync(resolved)) {
+        throw new Error('File already exists: ' + resolved);
+      }
+      await writeFile(resolved, '', 'utf-8');
+    }
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'create', success: true,
+      message: (isDirectory ? 'Directory' : 'File') + ' created: ' + basename(resolved)
+    });
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'create', success: false, error: e.message
+    });
+  }
+}
+
+export async function handleDeleteFiles(msg) {
+  const { conversationId, paths, _requestUserId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+
+  try {
+    if (!paths || paths.length === 0) throw new Error('No paths specified');
+    const deleted = [];
+    const errors = [];
+
+    for (const p of paths) {
+      try {
+        const resolved = resolveAndValidatePath(p, workDir);
+        const s = await stat(resolved);
+        if (s.isDirectory()) {
+          await rm(resolved, { recursive: true, force: true });
+        } else {
+          await unlink(resolved);
+        }
+        deleted.push(basename(resolved));
+      } catch (e) {
+        errors.push(basename(p) + ': ' + e.message);
+      }
+    }
+
+    const message = deleted.length > 0
+      ? 'Deleted: ' + deleted.join(', ') + (errors.length > 0 ? '; Errors: ' + errors.join(', ') : '')
+      : 'Failed: ' + errors.join(', ');
+
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'delete', success: deleted.length > 0,
+      message, deletedCount: deleted.length, errorCount: errors.length
+    });
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'delete', success: false, error: e.message
+    });
+  }
+}
+
+export async function handleMoveFiles(msg) {
+  const { conversationId, paths, destination, newName, _requestUserId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+
+  try {
+    if (!paths || paths.length === 0) throw new Error('No paths specified');
+    if (!destination) throw new Error('No destination specified');
+
+    const destResolved = resolveAndValidatePath(destination, workDir);
+    // Ensure destination directory exists
+    await mkdir(destResolved, { recursive: true });
+
+    const moved = [];
+    const errors = [];
+
+    for (const p of paths) {
+      try {
+        const srcResolved = resolveAndValidatePath(p, workDir);
+        const name = (newName && paths.length === 1) ? newName : basename(srcResolved);
+        const destPath = join(destResolved, name);
+        if (existsSync(destPath)) {
+          throw new Error('Target already exists: ' + name);
+        }
+        await rename(srcResolved, destPath);
+        moved.push(name);
+      } catch (e) {
+        errors.push(basename(p) + ': ' + e.message);
+      }
+    }
+
+    const message = moved.length > 0
+      ? 'Moved: ' + moved.join(', ') + ' → ' + basename(destResolved) + (errors.length > 0 ? '; Errors: ' + errors.join(', ') : '')
+      : 'Failed: ' + errors.join(', ');
+
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'move', success: moved.length > 0,
+      message, movedCount: moved.length, errorCount: errors.length
+    });
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'move', success: false, error: e.message
+    });
+  }
+}
+
+export async function handleCopyFiles(msg) {
+  const { conversationId, paths, destination, _requestUserId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+
+  try {
+    if (!paths || paths.length === 0) throw new Error('No paths specified');
+    if (!destination) throw new Error('No destination specified');
+
+    const destResolved = resolveAndValidatePath(destination, workDir);
+    await mkdir(destResolved, { recursive: true });
+
+    const copied = [];
+    const errors = [];
+
+    for (const p of paths) {
+      try {
+        const srcResolved = resolveAndValidatePath(p, workDir);
+        const name = basename(srcResolved);
+        let destPath = join(destResolved, name);
+
+        // If copying to same directory, generate a unique name
+        if (destPath === srcResolved) {
+          const ext = extname(name);
+          const base = basename(name, ext);
+          let counter = 1;
+          do {
+            destPath = join(destResolved, `${base} (copy${counter > 1 ? ' ' + counter : ''})${ext}`);
+            counter++;
+          } while (existsSync(destPath));
+        }
+
+        const srcStat = await stat(srcResolved);
+        if (srcStat.isDirectory()) {
+          await cp(srcResolved, destPath, { recursive: true });
+        } else {
+          await copyFile(srcResolved, destPath);
+        }
+        copied.push(basename(destPath));
+      } catch (e) {
+        errors.push(basename(p) + ': ' + e.message);
+      }
+    }
+
+    const message = copied.length > 0
+      ? 'Copied: ' + copied.join(', ') + (errors.length > 0 ? '; Errors: ' + errors.join(', ') : '')
+      : 'Failed: ' + errors.join(', ');
+
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'copy', success: copied.length > 0,
+      message, copiedCount: copied.length, errorCount: errors.length
+    });
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'copy', success: false, error: e.message
+    });
+  }
+}
+
+export async function handleUploadToDir(msg) {
+  const { conversationId, files, dirPath, _requestUserId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+
+  try {
+    if (!files || files.length === 0) throw new Error('No files specified');
+
+    const targetDir = resolveAndValidatePath(dirPath || workDir, workDir);
+    await mkdir(targetDir, { recursive: true });
+
+    const saved = [];
+    const errors = [];
+
+    for (const file of files) {
+      try {
+        const dest = join(targetDir, file.name);
+        const buffer = Buffer.from(file.data, 'base64');
+        await writeFile(dest, buffer);
+        saved.push(file.name);
+      } catch (e) {
+        errors.push(file.name + ': ' + e.message);
+      }
+    }
+
+    const message = saved.length > 0
+      ? 'Uploaded: ' + saved.join(', ') + (errors.length > 0 ? '; Errors: ' + errors.join(', ') : '')
+      : 'Failed: ' + errors.join(', ');
+
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'upload', success: saved.length > 0,
+      message, uploadedCount: saved.length, errorCount: errors.length
+    });
+  } catch (e) {
+    ctx.sendToServer({
+      type: 'file_op_result', conversationId, _requestUserId,
+      operation: 'upload', success: false, error: e.message
+    });
+  }
+}

package/workbench/file-search.js

@@ -0,0 +1,66 @@
+import { readdir, stat } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+import ctx from '../context.js';
+
+export async function handleFileSearch(msg) {
+  const { conversationId, query, _requestUserId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+  const searchRoot = msg.dirPath || workDir;
+
+  try {
+    if (!query || query.trim().length === 0) {
+      ctx.sendToServer({ type: 'file_search_result', conversationId, _requestUserId, query, results: [] });
+      return;
+    }
+
+    const resolved = resolve(searchRoot);
+    const results = [];
+    const MAX_RESULTS = 100;
+    const lowerQuery = query.toLowerCase();
+    const skipDirs = new Set(['.git', 'node_modules', '__pycache__', '.next', '.nuxt', 'dist', 'build', '.cache', 'bin', 'obj']);
+
+    async function walk(dir, depth) {
+      if (depth > 10 || results.length >= MAX_RESULTS) return;
+      try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (results.length >= MAX_RESULTS) return;
+          if (entry.name.startsWith('.') && depth > 0) continue;
+          if (skipDirs.has(entry.name) && entry.isDirectory()) continue;
+
+          const fullPath = join(dir, entry.name);
+
+          if (entry.name.toLowerCase().includes(lowerQuery)) {
+            let size = 0;
+            try { const s = await stat(fullPath); size = s.size; } catch {}
+            results.push({
+              name: entry.name,
+              path: relative(resolved, fullPath).replace(/\\/g, '/'),
+              fullPath: fullPath.replace(/\\/g, '/'),
+              type: entry.isDirectory() ? 'directory' : 'file',
+              size
+            });
+          }
+
+          if (entry.isDirectory()) {
+            await walk(fullPath, depth + 1);
+          }
+        }
+      } catch {}
+    }
+
+    await walk(resolved, 0);
+
+    ctx.sendToServer({
+      type: 'file_search_result',
+      conversationId,
+      _requestUserId,
+      query,
+      results,
+      truncated: results.length >= MAX_RESULTS
+    });
+  } catch (e) {
+    ctx.sendToServer({ type: 'file_search_result', conversationId, _requestUserId, query, results: [], error: e.message });
+  }
+}