neoagent 2.5.2-beta.9 → 3.0.0

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

@@ -490,29 +490,6 @@ const githubToolDefinitions = [
       required: ['owner_repo'],
     },
   },
-  {
-    name: 'github_get_content',
-    access: 'read',
-    description: 'Get file or directory contents from a repository.',
-    parameters: {
-      type: 'object',
-      properties: {
-        owner_repo: {
-          type: 'string',
-          description: 'Repository in format "owner/repo".',
-        },
-        path: {
-          type: 'string',
-          description: 'File or directory path.',
-        },
-        ref: {
-          type: 'string',
-          description: 'Git ref (branch, tag, or SHA).',
-        },
-      },
-      required: ['owner_repo', 'path'],
-    },
-  },
   {
     name: 'github_create_or_update_file',
     access: 'write',
@@ -534,7 +511,12 @@ const githubToolDefinitions = [
         },
         content: {
           type: 'string',
-          description: 'Base64-encoded file content.',
+          description: 'File content as normal UTF-8 text by default. The tool handles the GitHub Contents API encoding.',
+        },
+        encoding: {
+          type: 'string',
+          enum: ['utf-8', 'base64'],
+          description: 'Input encoding for content. Default utf-8. Use base64 only for already-encoded binary content.',
         },
         sha: {
           type: 'string',
@@ -717,7 +699,7 @@ const githubToolDefinitions = [
   {
     name: 'github_api_request',
     access: 'dynamic_http_method',
-    description: 'Make an authenticated GitHub API request for advanced operations not covered by dedicated tools.',
+    description: 'Make an authenticated GitHub API request for advanced operations not covered by dedicated tools. Path must be the FULL API path starting with /repos/{owner}/{repo}/... — e.g. /repos/NeoLabs-Systems/NeoAgent/git/trees/main?recursive=1. Alternatively, supply owner_repo and a relative path like /git/trees/main and the prefix is prepended automatically.',
     parameters: {
       type: 'object',
       properties: {
@@ -728,7 +710,19 @@ const githubToolDefinitions = [
         },
         path: {
           type: 'string',
-          description: 'API path or full URL.',
+          description: 'Full API path (e.g. /repos/owner/repo/git/trees/main) or a relative path like /git/trees/main when owner_repo is also provided.',
+        },
+        owner_repo: {
+          type: 'string',
+          description: 'Repository in "owner/repo" format. When provided together with a relative path, the /repos/{owner}/{repo} prefix is automatically prepended.',
+        },
+        endpoint: {
+          type: 'string',
+          description: 'Alias for path.',
+        },
+        url: {
+          type: 'string',
+          description: 'Full GitHub API URL (https://api.github.com/...).',
         },
         query: {
           type: 'object',
@@ -738,8 +732,12 @@ const githubToolDefinitions = [
           type: 'object',
           description: 'Optional JSON request body.',
         },
+        payload: {
+          type: 'object',
+          description: 'Alias for body.',
+        },
       },
-      required: ['method', 'path'],
+      required: ['method'],
     },
   },
 ];
@@ -749,6 +747,63 @@ function parseCommaSeparatedList(value) {
   return String(value).split(',').map((s) => s.trim()).filter(Boolean);
 }
 
+function resolveApiRequestPath(args = {}) {
+  for (const key of ['path', 'endpoint', 'url']) {
+    const value = args?.[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return '';
+}
+
+function hasOwnerRepoArg(args = {}) {
+  if (typeof args.owner_repo === 'string' && args.owner_repo.trim()) return true;
+  return Boolean(String(args.owner || '').trim() && String(args.repo || '').trim());
+}
+
+function parseOwnerRepoArg(args = {}) {
+  if (typeof args.owner_repo === 'string' && args.owner_repo.trim()) {
+    return parseOwnerRepo(args.owner_repo);
+  }
+  const owner = String(args.owner || '').trim();
+  const repo = String(args.repo || '').trim();
+  if (owner && repo) {
+    return parseOwnerRepo(`${owner}/${repo}`);
+  }
+  return parseOwnerRepo(args.owner_repo);
+}
+
+function encodeGithubFileContent(args = {}) {
+  const content = String(args.content ?? '');
+  const encoding = String(args.encoding || args.content_encoding || 'utf-8').toLowerCase();
+  if (encoding === 'base64') {
+    return content.replace(/\s/g, '');
+  }
+  return Buffer.from(content, 'utf8').toString('base64');
+}
+
+function resolveApiRequestBody(args = {}) {
+  if (args.body && typeof args.body === 'object') return args.body;
+  if (args.payload && typeof args.payload === 'object') return args.payload;
+  return null;
+}
+
+for (const definition of githubToolDefinitions) {
+  const parameters = definition.parameters;
+  const properties = parameters?.properties;
+  if (!properties?.owner_repo) continue;
+  properties.owner = {
+    type: 'string',
+    description: 'Repository owner alias. Use together with repo when owner_repo is not supplied.',
+  };
+  properties.repo = {
+    type: 'string',
+    description: 'Repository name alias. Use together with owner when owner_repo is not supplied.',
+  };
+  if (Array.isArray(parameters.required) && parameters.required.includes('owner_repo')) {
+    parameters.required = parameters.required.filter((item) => item !== 'owner_repo');
+  }
+}
+
 async function executeGithubTool(toolName, args, auth) {
   switch (toolName) {
     case 'github_get_auth_user': {
@@ -768,14 +823,14 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_get_repo': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         path: `/repos/${owner}/${repo}`,
       });
     }
 
     case 'github_list_issues': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       const query = { per_page: Math.min(Number(args.max_results) || 30, 100) };
       if (args.state) query.state = args.state;
       if (args.labels) query.labels = args.labels;
@@ -789,14 +844,14 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_get_issue': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         path: `/repos/${owner}/${repo}/issues/${Number(args.issue_number)}`,
       });
     }
 
     case 'github_create_issue': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         method: 'POST',
         path: `/repos/${owner}/${repo}/issues`,
@@ -810,7 +865,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_update_issue': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       const body = {};
       if (args.title) body.title = String(args.title);
       if (args.body !== undefined) body.body = String(args.body);
@@ -825,7 +880,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_add_issue_labels': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         method: 'POST',
         path: `/repos/${owner}/${repo}/issues/${Number(args.issue_number)}/labels`,
@@ -836,7 +891,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_add_issue_assignees': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         method: 'POST',
         path: `/repos/${owner}/${repo}/issues/${Number(args.issue_number)}/assignees`,
@@ -847,7 +902,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_list_prs': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       const query = { per_page: Math.min(Number(args.max_results) || 30, 100) };
       if (args.state) query.state = args.state;
       if (args.sort) query.sort = args.sort;
@@ -859,14 +914,14 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_get_pr': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         path: `/repos/${owner}/${repo}/pulls/${Number(args.pr_number)}`,
       });
     }
 
     case 'github_create_pr': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         method: 'POST',
         path: `/repos/${owner}/${repo}/pulls`,
@@ -882,7 +937,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_update_pr': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       const body = {};
       if (args.title) body.title = String(args.title);
       if (args.body !== undefined) body.body = String(args.body);
@@ -895,7 +950,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_merge_pr': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         method: 'PUT',
         path: `/repos/${owner}/${repo}/pulls/${Number(args.pr_number)}/merge`,
@@ -908,7 +963,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_list_commits': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       const query = { per_page: Math.min(Number(args.max_results) || 30, 100) };
       if (args.sha) query.sha = String(args.sha);
       if (args.path) query.path = String(args.path);
@@ -919,7 +974,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_list_branches': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         path: `/repos/${owner}/${repo}/branches`,
         query: buildPaginationParams({ per_page: args.max_results }),
@@ -927,7 +982,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_get_branch': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       const branch = encodeURIComponent(String(args.branch || ''));
       return await githubApiRequest(auth, {
         path: `/repos/${owner}/${repo}/branches/${branch}`,
@@ -935,7 +990,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_list_collaborators': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       const maxResults = parsePositiveInt(args.max_results, 30);
       const perPage = Math.min(100, maxResults);
       const query = {
@@ -958,23 +1013,28 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_get_content': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       const query = {};
       if (args.ref) query.ref = String(args.ref);
-      return await githubApiRequest(auth, {
+      const result = await githubApiRequest(auth, {
         path: `/repos/${owner}/${repo}/contents/${String(args.path || '')}`,
         query,
       });
+      if (result && result.encoding === 'base64' && typeof result.content === 'string') {
+        result.content = Buffer.from(result.content.replace(/\n/g, ''), 'base64').toString('utf8');
+        result.encoding = 'utf8';
+      }
+      return result;
     }
 
     case 'github_create_or_update_file': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         method: 'PUT',
         path: `/repos/${owner}/${repo}/contents/${String(args.path || '')}`,
         body: {
           message: String(args.message || ''),
-          content: String(args.content || ''),
+          content: encodeGithubFileContent(args),
           sha: args.sha ? String(args.sha) : undefined,
           branch: args.branch ? String(args.branch) : undefined,
         },
@@ -982,7 +1042,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_delete_file': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         method: 'DELETE',
         path: `/repos/${owner}/${repo}/contents/${String(args.path || '')}`,
@@ -995,7 +1055,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_list_workflow_runs': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       let path = `/repos/${owner}/${repo}/actions/runs`;
       if (args.workflow_id) {
         path = `/repos/${owner}/${repo}/actions/workflows/${String(args.workflow_id)}/runs`;
@@ -1024,14 +1084,14 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_get_workflow_run': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         path: `/repos/${owner}/${repo}/actions/runs/${Number(args.run_id)}`,
       });
     }
 
     case 'github_trigger_workflow': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       let inputs = {};
       if (args.inputs) {
         try {
@@ -1051,7 +1111,7 @@ async function executeGithubTool(toolName, args, auth) {
     }
 
     case 'github_list_workflows': {
-      const { owner, repo } = parseOwnerRepo(args.owner_repo);
+      const { owner, repo } = parseOwnerRepoArg(args);
       return await githubApiRequest(auth, {
         path: `/repos/${owner}/${repo}/actions/workflows`,
       });
@@ -1085,7 +1145,10 @@ async function executeGithubTool(toolName, args, auth) {
 
     case 'github_api_request': {
       let baseUrl = 'https://api.github.com';
-      let path = String(args.path || '');
+      let path = resolveApiRequestPath(args);
+      if (!path) {
+        throw new Error('github_api_request requires path, endpoint, or url.');
+      }
       let query = args.query || null;
       if (path.startsWith('http')) {
         const url = new URL(path);
@@ -1103,12 +1166,17 @@ async function executeGithubTool(toolName, args, auth) {
           ...parsedQuery,
           ...(args.query && typeof args.query === 'object' ? args.query : {}),
         };
+      } else if (hasOwnerRepoArg(args) && !path.startsWith('/repos/') && !path.startsWith('/user') && !path.startsWith('/orgs/') && !path.startsWith('/search/')) {
+        // Convenience: prepend /repos/{owner}/{repo} for relative paths
+        const { owner, repo } = parseOwnerRepoArg(args);
+        const relativePath = path.startsWith('/') ? path : `/${path}`;
+        path = `/repos/${owner}/${repo}${relativePath}`;
       }
       return await githubApiRequest(auth, {
         method: args.method || 'GET',
         path,
         query,
-        body: args.body || null,
+        body: resolveApiRequestBody(args),
         baseUrl,
       });
     }
@@ -1121,4 +1189,4 @@ async function executeGithubTool(toolName, args, auth) {
 module.exports = {
   executeGithubTool,
   githubToolDefinitions,
-};
+};

package/server/services/runtime/docker-vm-manager.js

@@ -1,11 +1,25 @@
 'use strict';
 
 const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
 const http = require('http');
 const net = require('net');
+const { AGENT_DATA_DIR } = require('../../../runtime/paths');
+const { sanitizeWorkspaceKey } = require('../workspace/manager');
 
 const CONTAINER_IMAGE = 'mcr.microsoft.com/playwright:v1.44.0-focal';
 const CONTAINER_LABEL = 'neoagent.managed=1';
+// The per-user host workspace is bind-mounted here so the shell (execute_command)
+// and the workspace file tools (read_file/write_file/list_directory/search_files)
+// operate on the SAME files. The guest agent defaults its shell cwd to this path.
+const GUEST_WORKSPACE = '/workspace';
+
+// Host path of a user's workspace — must match WorkspaceManager's layout exactly
+// (AGENT_DATA_DIR/workspaces/<sanitized key>) so both sides see one directory.
+function hostWorkspaceDir(key) {
+  return path.join(AGENT_DATA_DIR, 'workspaces', sanitizeWorkspaceKey(key));
+}
 
 // ─── Guest agent ─────────────────────────────────────────────────────────────
 // Injected into every container. Pure Node.js — only built-in modules + playwright
@@ -104,7 +118,7 @@ const server = http.createServer(async (req, res) => {
     if (req.method === 'POST' && url === '/exec') {
       const timeoutMs = Math.min(Number(b.timeout) || 15 * 60 * 1000, 20 * 60 * 1000);
       const child = spawn('sh', ['-c', b.command || 'true'], {
-        cwd: b.cwd || '/tmp',
+        cwd: b.cwd || '/workspace',
         env: { ...process.env, ...b.env },
       });
       const pid = child.pid;
@@ -325,6 +339,10 @@ class DockerVMManager {
     const port = await findAvailablePort();
     console.log(`[DockerVM:${this.profile}] Starting container for user ${key} on port ${port}`);
 
+    // Bind-mount the user's host workspace so shell and file tools share one place.
+    const workspaceDir = hostWorkspaceDir(key);
+    try { fs.mkdirSync(workspaceDir, { recursive: true }); } catch { /* best effort */ }
+
     const containerId = docker([
       'run', '-d',
       '--memory', `${this.memoryMb}m`,
@@ -334,6 +352,8 @@ class DockerVMManager {
       ...(this.guestToken ? ['-e', `NEOAGENT_VM_GUEST_TOKEN=${this.guestToken}`] : []),
       '--shm-size=2g',
       '--security-opt', 'no-new-privileges',
+      '-v', `${workspaceDir}:${GUEST_WORKSPACE}`,
+      '-w', GUEST_WORKSPACE,
       '--label', CONTAINER_LABEL,
       '--label', `neoagent.profile=${this.profile}`,
       '--label', `neoagent.user=${key}`,

package/server/services/workspace/manager.js

@@ -294,6 +294,61 @@ class WorkspaceManager {
     }
   }
 
+  replaceFileRange(userId, options = {}) {
+    let filePath;
+    try {
+      filePath = this.resolvePath(userId, options.path || '', 'path');
+      if (!fs.existsSync(filePath)) {
+        return { success: false, error: `File not found: ${filePath}`, path: filePath };
+      }
+
+      const start = Number(options.start_line ?? options.startLine);
+      const end = Number(options.end_line ?? options.endLine ?? start);
+      if (!Number.isInteger(start) || start < 1) {
+        return { success: false, error: 'start_line must be a positive integer', path: filePath };
+      }
+      if (!Number.isInteger(end) || end < 1) {
+        return { success: false, error: 'end_line must be a positive integer', path: filePath };
+      }
+      if (start > end) {
+        return { success: false, error: 'start_line must be less than or equal to end_line', path: filePath };
+      }
+
+      const original = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+      const hadFinalNewline = original.endsWith('\n');
+      const lines = original.split('\n');
+      if (hadFinalNewline) lines.pop();
+      const totalLines = Math.max(lines.length, 1);
+      if (start > totalLines || end > totalLines) {
+        return {
+          success: false,
+          error: `line range ${start}-${end} is outside file with ${totalLines} lines`,
+          path: filePath,
+          totalLines,
+        };
+      }
+
+      const replacementText = String(options.content ?? '').replace(/\r\n/g, '\n');
+      const replacementLines = replacementText === ''
+        ? []
+        : replacementText.replace(/\n$/, '').split('\n');
+      lines.splice(start - 1, end - start + 1, ...replacementLines);
+      const next = `${lines.join('\n')}${hadFinalNewline ? '\n' : ''}`;
+      fs.writeFileSync(filePath, next, 'utf8');
+      return {
+        success: true,
+        path: filePath,
+        startLine: start,
+        endLine: end,
+        replacedLines: end - start + 1,
+        insertedLines: replacementLines.length,
+        totalLines: lines.length,
+      };
+    } catch (err) {
+      return { success: false, path: filePath || null, error: err.message };
+    }
+  }
+
   listDirectory(userId, options = {}) {
     const dirPath = this.resolvePath(userId, options.path || '.', 'path');
     const depthValue = options.depth != null ? Number(options.depth) : (options.recursive ? 3 : 1);
@@ -414,4 +469,5 @@ class WorkspaceManager {
 
 module.exports = {
   WorkspaceManager,
+  sanitizeWorkspaceKey,
 };