neoagent 2.5.2-beta.9 → 3.0.1-beta.0

package/server/services/ai/tools.js

@@ -881,16 +881,57 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'read_file',
-            description: 'Read a file from the filesystem. Supports reading specific line ranges for large files.',
+            description: 'Read one workspace file. Supports line ranges for large files. Use workspace file tools for code inspection whenever the files are in the shared workspace.',
             parameters: {
                 type: 'object',
                 properties: {
-                    path: { type: 'string', description: 'Absolute or relative file path' },
+                    path: { type: 'string', description: 'Absolute or relative path inside the per-user workspace' },
+                    file_path: { type: 'string', description: 'Alias for path; accepted for compatibility with model tool calls' },
                     start_line: { type: 'number', description: 'Starting line number (1-indexed, inclusive)' },
                     end_line: { type: 'number', description: 'Ending line number (1-indexed, inclusive)' },
+                    line_start: { type: 'number', description: 'Alias for start_line; accepted for compatibility with model tool calls' },
+                    line_count: { type: 'number', description: 'Number of lines to read starting at start_line/line_start' },
                     encoding: { type: 'string', description: 'File encoding (default utf-8)' }
                 },
-                required: ['path']
+                required: []
+            }
+        },
+        {
+            name: 'read_files',
+            description: 'Read multiple workspace files or line ranges in one call. Prefer this over repeated single-file reads or shell snippets when inspecting related files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    files: {
+                        type: 'array',
+                        description: 'Files to read. Each item may be a path string or an object with path/file_path plus optional start_line/end_line or line_start/line_count.',
+                        items: {
+                            oneOf: [
+                                { type: 'string', description: 'Path inside the per-user workspace' },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        path: { type: 'string', description: 'Absolute or relative path inside the per-user workspace' },
+                                        file_path: { type: 'string', description: 'Alias for path' },
+                                        start_line: { type: 'number', description: 'Starting line number (1-indexed, inclusive)' },
+                                        end_line: { type: 'number', description: 'Ending line number (1-indexed, inclusive)' },
+                                        line_start: { type: 'number', description: 'Alias for start_line' },
+                                        line_count: { type: 'number', description: 'Number of lines to read from start_line/line_start' },
+                                        encoding: { type: 'string', description: 'File encoding (default utf-8)' }
+                                    },
+                                    required: []
+                                }
+                            ]
+                        }
+                    },
+                    paths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Convenience alias for reading whole files by path.'
+                    },
+                    encoding: { type: 'string', description: 'Default file encoding for items without encoding (default utf-8)' }
+                },
+                required: []
             }
         },
         {
@@ -900,10 +941,11 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     path: { type: 'string', description: 'File path' },
+                    file_path: { type: 'string', description: 'Alias for path; accepted for compatibility with model tool calls' },
                     content: { type: 'string', description: 'Content to write' },
                     mode: { type: 'string', enum: ['write', 'append'], description: 'Write mode (default write)' }
                 },
-                required: ['path', 'content']
+                required: ['content']
             }
         },
         {
@@ -913,46 +955,68 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     path: { type: 'string', description: 'File path' },
+                    file_path: { type: 'string', description: 'Alias for path; accepted for compatibility with model tool calls' },
                     edits: {
                         type: 'array',
                         items: {
                             type: 'object',
                             properties: {
                                 oldText: { type: 'string', description: 'The exact text to replace.' },
-                                newText: { type: 'string', description: 'The replacement text.' }
+                                newText: { type: 'string', description: 'The replacement text.' },
+                                old_text: { type: 'string', description: 'Alias for oldText' },
+                                new_text: { type: 'string', description: 'Alias for newText' }
                             },
-                            required: ['oldText', 'newText']
+                            required: []
                         },
                         description: 'List of text replacements to apply.'
                     }
                 },
-                required: ['path', 'edits']
+                required: ['edits']
+            }
+        },
+        {
+            name: 'replace_file_range',
+            description: 'Replace a 1-indexed inclusive line range in a workspace file. Use this when you know line numbers and exact-text edit_file would be brittle. Read the target range first, then replace only the intended lines.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path inside the per-user workspace' },
+                    file_path: { type: 'string', description: 'Alias for path; accepted for compatibility with model tool calls' },
+                    start_line: { type: 'number', description: 'Starting line number (1-indexed, inclusive)' },
+                    end_line: { type: 'number', description: 'Ending line number (1-indexed, inclusive)' },
+                    startLine: { type: 'number', description: 'Alias for start_line' },
+                    endLine: { type: 'number', description: 'Alias for end_line' },
+                    content: { type: 'string', description: 'Replacement content for the range. Empty string deletes the range.' }
+                },
+                required: ['content']
             }
         },
         {
             name: 'list_directory',
-            description: 'List files and directories with metadata (size, modified time).',
+            description: 'List workspace files and directories with metadata. Omit path to list the workspace root.',
             parameters: {
                 type: 'object',
                 properties: {
-                    path: { type: 'string', description: 'Directory path' },
+                    path: { type: 'string', description: 'Directory path inside the workspace (default ".")' },
                     recursive: { type: 'boolean', description: 'List recursively' },
                     depth: { type: 'number', description: 'Maximum recursion depth (default 1, max 5)' }
                 },
-                required: ['path']
+                required: []
             }
         },
         {
             name: 'search_files',
-            description: 'Search for text patterns across files in a directory (recursive).',
+            description: 'Search for text across workspace files recursively. Omit path to search the workspace root.',
             parameters: {
                 type: 'object',
                 properties: {
-                    path: { type: 'string', description: 'Directory to search in' },
+                    path: { type: 'string', description: 'Directory to search in (default ".")' },
                     query: { type: 'string', description: 'Text or regex pattern to search for' },
-                    include: { type: 'string', description: 'Glob pattern for files to include (e.g. "*.js")' }
+                    include: { type: 'string', description: 'Glob pattern for files to include (e.g. "*.js")' },
+                    maxDepth: { type: 'number', description: 'Maximum directory depth (default 5, max 10)' },
+                    maxFileSize: { type: 'number', description: 'Maximum file size in bytes to scan (default 1048576)' }
                 },
-                required: ['path', 'query']
+                required: ['query']
             }
         },
         {
@@ -1141,7 +1205,7 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'create_task',
-            description: 'Create a background task with a named trigger and self-contained prompt.',
+            description: 'Create a future, recurring, monitored, or background automation with a named trigger and self-contained prompt. Do not use for immediate short answers.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -1160,12 +1224,12 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'list_tasks',
-            description: 'List all tasks for this user and agent.',
+            description: 'List saved background/scheduled tasks for this user and agent. Do not use for ordinary immediate replies.',
             parameters: { type: 'object', properties: {} }
         },
         {
             name: 'delete_task',
-            description: 'Delete a task by its ID.',
+            description: 'Delete a saved background/scheduled task by its ID.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -1176,7 +1240,7 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'update_task',
-            description: 'Update an existing task, including its trigger, prompt, or enabled state.',
+            description: 'Update an existing saved background/scheduled task, including its trigger, prompt, or enabled state.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -1500,6 +1564,33 @@ function getAvailableTools(app, options = {}) {
     return compacted;
 }
 
+function firstStringArg(args = {}, names = []) {
+    for (const name of names) {
+        const value = args?.[name];
+        if (typeof value === 'string' && value.trim()) return value;
+    }
+    return '';
+}
+
+function normalizeReadFileArgs(args = {}) {
+    const startLine = args.start_line ?? args.line_start ?? args.startLine ?? args.lineStart;
+    let endLine = args.end_line ?? args.line_end ?? args.endLine ?? args.lineEnd;
+    const lineCount = args.line_count ?? args.lineCount;
+    if (endLine == null && startLine != null && lineCount != null) {
+        const start = Number(startLine);
+        const count = Number(lineCount);
+        if (Number.isInteger(start) && Number.isInteger(count) && count > 0) {
+            endLine = start + count - 1;
+        }
+    }
+    return {
+        path: firstStringArg(args, ['path', 'file_path', 'filePath', 'filename']),
+        encoding: args.encoding || 'utf-8',
+        start_line: startLine,
+        end_line: endLine,
+    };
+}
+
 /**
  * Executes a tool by name.
  * @param {string} toolName - Name of the tool.
@@ -2297,12 +2388,58 @@ async function executeTool(toolName, args, context, engine) {
             try {
                 const workspace = wc();
                 if (!workspace) return { error: 'Workspace service is unavailable.' };
-                return workspace.readFile(userId, {
-                    path: args.path,
-                    encoding: args.encoding || 'utf-8',
-                    start_line: args.start_line,
-                    end_line: args.end_line,
+                const normalizedArgs = normalizeReadFileArgs(args);
+                if (!normalizedArgs.path) {
+                    return {
+                        error: 'read_file requires path or file_path. Keep source files in the workspace; for repository work clone or move the checkout into the workspace before using file tools.',
+                    };
+                }
+                return workspace.readFile(userId, normalizedArgs);
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
+        case 'read_files': {
+            try {
+                const workspace = wc();
+                if (!workspace) return { error: 'Workspace service is unavailable.' };
+                const entries = Array.isArray(args.files)
+                    ? args.files
+                    : (Array.isArray(args.paths) ? args.paths : []);
+                if (!entries.length) {
+                    return { error: 'read_files requires a non-empty files or paths array.' };
+                }
+                const maxFiles = 8;
+                const results = entries.slice(0, maxFiles).map((entry, index) => {
+                    const fileArgs = typeof entry === 'string'
+                        ? { path: entry }
+                        : (entry && typeof entry === 'object' ? entry : {});
+                    const normalizedArgs = normalizeReadFileArgs({
+                        ...fileArgs,
+                        encoding: fileArgs.encoding || args.encoding || 'utf-8',
+                    });
+                    if (!normalizedArgs.path) {
+                        return {
+                            index,
+                            success: false,
+                            error: 'Each read_files item requires path or file_path.',
+                        };
+                    }
+                    const result = workspace.readFile(userId, normalizedArgs);
+                    return {
+                        index,
+                        requestedPath: normalizedArgs.path,
+                        success: !result?.error,
+                        ...result,
+                    };
                 });
+                return {
+                    success: results.every((result) => result.success !== false && !result.error),
+                    count: results.length,
+                    truncated: entries.length > maxFiles,
+                    results,
+                };
             } catch (err) {
                 return { error: err.message };
             }
@@ -2312,8 +2449,10 @@ async function executeTool(toolName, args, context, engine) {
             try {
                 const workspace = wc();
                 if (!workspace) return { error: 'Workspace service is unavailable.' };
+                const targetPath = args.path || args.file_path;
+                if (!targetPath) return { success: false, error: 'write_file requires path or file_path.' };
                 return workspace.writeFile(userId, {
-                    path: args.path,
+                    path: targetPath,
                     content: args.content,
                     mode: args.mode,
                 });
@@ -2326,9 +2465,38 @@ async function executeTool(toolName, args, context, engine) {
             try {
                 const workspace = wc();
                 if (!workspace) return { error: 'Workspace service is unavailable.' };
+                const targetPath = args.path || args.file_path;
+                if (!targetPath) return { success: false, error: 'edit_file requires path or file_path.' };
+                const edits = Array.isArray(args.edits)
+                    ? args.edits.map((edit) => ({
+                        ...edit,
+                        oldText: edit?.oldText ?? edit?.old_text,
+                        newText: edit?.newText ?? edit?.new_text,
+                    }))
+                    : [];
                 return workspace.editFile(userId, {
-                    path: args.path,
-                    edits: args.edits,
+                    path: targetPath,
+                    edits,
+                });
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
+        case 'replace_file_range': {
+            try {
+                const workspace = wc();
+                if (!workspace) return { error: 'Workspace service is unavailable.' };
+                if (typeof workspace.replaceFileRange !== 'function') {
+                    return { error: 'Workspace service does not support replace_file_range.' };
+                }
+                const targetPath = args.path || args.file_path;
+                if (!targetPath) return { success: false, error: 'replace_file_range requires path or file_path.' };
+                return workspace.replaceFileRange(userId, {
+                    path: targetPath,
+                    start_line: args.start_line ?? args.startLine,
+                    end_line: args.end_line ?? args.endLine,
+                    content: args.content,
                 });
             } catch (err) {
                 return { error: err.message };
@@ -2357,6 +2525,8 @@ async function executeTool(toolName, args, context, engine) {
                     path: args.path,
                     query: args.query,
                     include: args.include,
+                    maxDepth: args.maxDepth ?? args.max_depth,
+                    maxFileSize: args.maxFileSize ?? args.max_file_size,
                 });
             } catch (err) {
                 return { error: err.message };
@@ -2418,25 +2588,25 @@ async function executeTool(toolName, args, context, engine) {
             const { SkillRunner } = require('./toolRunner');
             const sharedRunner = sk();
             if (sharedRunner) {
-                const result = sharedRunner.createSkill(args.name, args.description, args.instructions, args.metadata);
+                const result = sharedRunner.createSkill(userId, args.name, args.description, args.instructions, args.metadata);
                 return result;
             }
             const runner = new SkillRunner();
             await runner.loadSkills();
-            return runner.createSkill(args.name, args.description, args.instructions, args.metadata);
+            return runner.createSkill(userId, args.name, args.description, args.instructions, args.metadata);
         }
 
         case 'list_skills': {
             const skillRunner = sk();
             if (!skillRunner) return { error: 'Skill runner not available' };
-            const all = skillRunner.getAll();
+            const all = skillRunner.getAll(userId);
             return { skills: all, count: all.length };
         }
 
         case 'update_skill': {
             const skillRunner = sk();
             if (!skillRunner) return { error: 'Skill runner not available' };
-            return skillRunner.updateSkill(args.name, {
+            return skillRunner.updateSkill(userId, args.name, {
                 description: args.description,
                 instructions: args.instructions,
                 metadata: args.metadata
@@ -2446,7 +2616,7 @@ async function executeTool(toolName, args, context, engine) {
         case 'delete_skill': {
             const skillRunner = sk();
             if (!skillRunner) return { error: 'Skill runner not available' };
-            return skillRunner.deleteSkill(args.name);
+            return skillRunner.deleteSkill(userId, args.name);
         }
 
         case 'think': {

package/server/services/cli/shell_worker_pool.js

@@ -5,6 +5,60 @@ const { randomUUID } = require('crypto');
 const path = require('path');
 
 const WORKER_SCRIPT = path.resolve(__dirname, 'shell_worker.js');
+const DEFAULT_WORKER_ENV_KEYS = Object.freeze([
+  'HOME',
+  'PATH',
+  'SHELL',
+  'TMPDIR',
+  'TMP',
+  'TEMP',
+  'TERM',
+  'LANG',
+  'LC_ALL',
+  'LC_CTYPE',
+  'USER',
+  'LOGNAME',
+  'COLORTERM',
+  'SystemRoot',
+  'ComSpec',
+  'PATHEXT',
+  'WINDIR',
+]);
+
+function normalizeExtraEnvKeys(extraEnvKeys = process.env.NEOAGENT_SHELL_WORKER_ENV_ALLOWLIST || '') {
+  if (Array.isArray(extraEnvKeys)) {
+    return extraEnvKeys.map((key) => String(key || '').trim()).filter(Boolean);
+  }
+  return String(extraEnvKeys || '')
+    .split(',')
+    .map((key) => key.trim())
+    .filter(Boolean);
+}
+
+function buildWorkerEnv(baseEnv = process.env, extraEnvKeys) {
+  const allowedKeys = new Set([
+    ...DEFAULT_WORKER_ENV_KEYS,
+    ...normalizeExtraEnvKeys(extraEnvKeys),
+  ]);
+  const workerEnv = {};
+  for (const key of allowedKeys) {
+    if (Object.prototype.hasOwnProperty.call(baseEnv, key) && baseEnv[key] != null) {
+      workerEnv[key] = String(baseEnv[key]);
+    }
+  }
+  return workerEnv;
+}
+
+function createShutdownResult(message, killed = false) {
+  return {
+    exitCode: -1,
+    stdout: '',
+    stderr: message,
+    killed,
+    timedOut: false,
+    durationMs: 0,
+  };
+}
 
 class ShellWorkerPool {
   /**
@@ -21,6 +75,7 @@ class ShellWorkerPool {
     this._queue = [];
     /** @type {Map<string, Function>} requestId → resolve */
     this._pending = new Map();
+    this._shuttingDown = false;
 
     for (let i = 0; i < this._size; i++) {
       this._spawnWorker();
@@ -31,7 +86,7 @@ class ShellWorkerPool {
     const proc = fork(this._workerScript, [], {
       detached: false,
       stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-      env: { ...process.env },
+      env: buildWorkerEnv(process.env),
     });
 
     const workerEntry = { proc, busy: false, pendingRequestId: null };
@@ -52,7 +107,6 @@ class ShellWorkerPool {
     });
 
     proc.on('exit', (code) => {
-      console.warn(`[ShellWorkerPool] Worker exited (code=${code}), respawning`);
       const idx = this._workers.indexOf(workerEntry);
       if (idx !== -1) this._workers.splice(idx, 1);
 
@@ -61,10 +115,14 @@ class ShellWorkerPool {
         const resolve = this._pending.get(workerEntry.pendingRequestId);
         if (resolve) {
           this._pending.delete(workerEntry.pendingRequestId);
-          resolve({ exitCode: -1, stdout: '', stderr: 'Worker process crashed', killed: true, timedOut: false });
+          const message = this._shuttingDown ? 'Server shutting down' : 'Worker process crashed';
+          resolve(createShutdownResult(message, true));
         }
       }
 
+      if (this._shuttingDown) return;
+
+      console.warn(`[ShellWorkerPool] Worker exited (code=${code}), respawning`);
       this._spawnWorker();
     });
 
@@ -113,13 +171,37 @@ class ShellWorkerPool {
 
   /** Gracefully terminate all workers. */
   shutdown() {
+    if (this._shuttingDown) return;
+    this._shuttingDown = true;
+
+    const shutdownResult = createShutdownResult('Server shutting down', true);
+    for (const job of this._queue) {
+      job.resolve(shutdownResult);
+    }
+    this._queue = [];
+
+    for (const w of this._workers) {
+      if (w.pendingRequestId) {
+        const resolve = this._pending.get(w.pendingRequestId);
+        if (resolve) {
+          this._pending.delete(w.pendingRequestId);
+          resolve(shutdownResult);
+        }
+        w.pendingRequestId = null;
+        w.busy = false;
+      }
+    }
+
     for (const w of this._workers) {
       try { w.proc.kill(); } catch {}
     }
     this._workers = [];
-    this._queue = [];
     this._pending.clear();
   }
 }
 
-module.exports = { ShellWorkerPool };
+module.exports = {
+  ShellWorkerPool,
+  DEFAULT_WORKER_ENV_KEYS,
+  buildWorkerEnv,
+};

package/server/services/integrations/github/common.js

@@ -42,7 +42,7 @@ async function githubApiRequest(auth, options = {}) {
     'X-GitHub-Api-Version': '2022-11-28',
   };
 
-  if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+  if (body) {
     headers['Content-Type'] = 'application/json';
   }
 
@@ -103,4 +103,4 @@ module.exports = {
   buildPaginationParams,
   githubApiRequest,
   parseOwnerRepo,
-};
+};