neoagent 2.5.2-beta.2 → 2.5.2-beta.21

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',
@@ -717,7 +694,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 +705,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',
@@ -739,7 +728,7 @@ const githubToolDefinitions = [
           description: 'Optional JSON request body.',
         },
       },
-      required: ['method', 'path'],
+      required: ['method'],
     },
   },
 ];
@@ -749,6 +738,14 @@ 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 '';
+}
+
 async function executeGithubTool(toolName, args, auth) {
   switch (toolName) {
     case 'github_get_auth_user': {
@@ -961,10 +958,15 @@ async function executeGithubTool(toolName, args, auth) {
       const { owner, repo } = parseOwnerRepo(args.owner_repo);
       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': {
@@ -1085,7 +1087,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,6 +1108,11 @@ async function executeGithubTool(toolName, args, auth) {
           ...parsedQuery,
           ...(args.query && typeof args.query === 'object' ? args.query : {}),
         };
+      } else if (args.owner_repo && !path.startsWith('/repos/') && !path.startsWith('/user') && !path.startsWith('/orgs/') && !path.startsWith('/search/')) {
+        // Convenience: prepend /repos/{owner}/{repo} for relative paths
+        const { owner, repo } = parseOwnerRepo(args.owner_repo);
+        const relativePath = path.startsWith('/') ? path : `/${path}`;
+        path = `/repos/${owner}/${repo}${relativePath}`;
       }
       return await githubApiRequest(auth, {
         method: args.method || 'GET',
@@ -1121,4 +1131,4 @@ async function executeGithubTool(toolName, args, auth) {
 module.exports = {
   executeGithubTool,
   githubToolDefinitions,
-};
+};

package/server/services/messaging/manager.js

@@ -515,6 +515,13 @@ class MessagingManager extends EventEmitter {
     }
 
     const result = await platform.sendMessage(to, normalizedContent, sendOptions);
+    if (result?.success === false) {
+      const reason = result.error || result.reason || 'platform rejected the message';
+      const error = new Error(`Platform ${platformName} delivery failed: ${reason}`);
+      error.code = 'MESSAGING_DELIVERY_FAILED';
+      error.deliveryResult = result;
+      throw error;
+    }
 
     db.prepare('INSERT INTO messages (user_id, agent_id, run_id, role, content, platform, platform_chat_id, media_path, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
       .run(userId, agentId, runId, 'assistant', normalizedContent, platformName, to, mediaPath, metadata ? JSON.stringify(metadata) : null);

package/server/services/runtime/backends/local-vm.js

@@ -250,8 +250,8 @@ class VmBrowserProvider {
   async typeText(text, options = {}) { return this.#materialize(await this.client.request('POST', '/browser/type-text', { text, ...options })); }
   async pressKey(key, screenshot = true) { return this.#materialize(await this.client.request('POST', '/browser/press-key', { key, screenshot })); }
   async scroll(deltaX, deltaY, screenshot = true) { return this.#materialize(await this.client.request('POST', '/browser/scroll', { deltaX, deltaY, screenshot })); }
-  extract(selector, attribute, all = false) { return this.client.request('POST', '/browser/extract', { selector, attribute, all }); }
-  evaluate(script) { return this.client.request('POST', '/browser/execute', { code: script }); }
+  async extract(selector, attribute, all = false) { return this.client.request('POST', '/browser/extract', { selector, attribute, all }); }
+  async evaluate(script) { return this.client.request('POST', '/browser/execute', { code: script }); }
   async screenshot(options = {}) { return this.#materialize(await this.client.request('POST', '/browser/screenshot', options)); }
   async screenshotJpeg(quality = 80, options = {}) {
     const result = await this.client.request('POST', '/browser/screenshot-jpeg', { ...options, quality });
@@ -259,11 +259,11 @@ class VmBrowserProvider {
     if (!content) throw new Error('VM browser screenshot-jpeg returned no data.');
     return Buffer.from(content, 'base64');
   }
-  launch(options = {}) { return this.client.request('POST', '/browser/launch', options); }
-  closeBrowser() { return this.client.request('POST', '/browser/close'); }
-  fill(selector, value) { return this.type(selector, value); }
-  extractContent(options = {}) { return this.client.request('POST', '/browser/extract', options); }
-  executeJS(code) { return this.evaluate(code); }
+  async launch(options = {}) { return this.client.request('POST', '/browser/launch', options); }
+  async closeBrowser() { return this.client.request('POST', '/browser/close'); }
+  async fill(selector, value) { return this.type(selector, value); }
+  async extractContent(options = {}) { return this.client.request('POST', '/browser/extract', options); }
+  async executeJS(code) { return this.evaluate(code); }
   async getPageInfo() {
     const status = await this.client.request('GET', '/browser/status');
     this.headless = status?.headless !== false;

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

@@ -414,4 +414,5 @@ class WorkspaceManager {
 
 module.exports = {
   WorkspaceManager,
+  sanitizeWorkspaceKey,
 };