neoagent 2.5.2-beta.9 → 3.0.1-beta.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/manager.js

@@ -571,6 +571,22 @@ async function startServices(app, io) {
 async function stopServices(app) {
   const tasks = [];
   console.log('[Services] Stopping services');
+  if (app.locals.approvalGateService && typeof app.locals.approvalGateService.shutdown === 'function') {
+    try {
+      app.locals.approvalGateService.shutdown();
+      logServiceReady('Pending approvals expired');
+    } catch (err) {
+      console.error('[ApprovalGate] Shutdown error:', getErrorMessage(err));
+    }
+  }
+  if (app.locals.agentEngine && typeof app.locals.agentEngine.interruptAllActiveRuns === 'function') {
+    try {
+      app.locals.agentEngine.interruptAllActiveRuns();
+      logServiceReady('Active runs marked interrupted');
+    } catch (err) {
+      console.error('[AgentEngine] Interrupt error:', getErrorMessage(err));
+    }
+  }
   if (app.locals.memoryManager) {
     app.locals.memoryManager.stopEmbeddingIndexBackfill();
   }

package/server/services/memory/manager.js

@@ -309,6 +309,34 @@ class MemoryManager {
     return resolveAgentId(userId, options?.agentId || options?.agent_id || null);
   }
 
+  _findExactMemory(userId, agentId, memoryHash, scope) {
+    return db.prepare(
+      `SELECT id FROM memories
+       WHERE user_id = ? AND agent_id = ? AND archived = 0
+         AND memory_hash = ?
+         AND COALESCE(scope_type, 'agent') = ?
+         AND COALESCE(scope_id, '') = COALESCE(?, '')
+       LIMIT 1`
+    ).get(userId, agentId, memoryHash, scope.scopeType, scope.scopeId);
+  }
+
+  _reinforceExactMemory(memoryId, importance) {
+    db.prepare(
+      `UPDATE memories
+       SET importance = MAX(importance, ?),
+           confidence = MIN(1, confidence + 0.03),
+           updated_at = datetime('now')
+       WHERE id = ?`
+    ).run(importance, memoryId);
+    db.prepare(
+      `UPDATE memory_facts
+       SET confidence = MIN(1, confidence + 0.03),
+           updated_at = datetime('now')
+       WHERE memory_id = ? AND status = 'active'`
+    ).run(memoryId);
+    return memoryId;
+  }
+
   _backfillMemoryIntelligence(limit = 1000) {
     try {
       const rows = db.prepare(
@@ -1602,29 +1630,9 @@ class MemoryManager {
     );
     const embedding = embeddingResult?.vector || null;
 
-    const exact = db.prepare(
-      `SELECT id FROM memories
-       WHERE user_id = ? AND agent_id = ? AND archived = 0
-         AND memory_hash = ?
-         AND COALESCE(scope_type, 'agent') = ?
-         AND COALESCE(scope_id, '') = COALESCE(?, '')
-       LIMIT 1`
-    ).get(userId, agentId, memoryHash, scope.scopeType, scope.scopeId);
+    const exact = this._findExactMemory(userId, agentId, memoryHash, scope);
     if (exact?.id) {
-      db.prepare(
-        `UPDATE memories
-         SET importance = MAX(importance, ?),
-             confidence = MIN(1, confidence + 0.03),
-             updated_at = datetime('now')
-         WHERE id = ?`
-      ).run(importance, exact.id);
-      db.prepare(
-        `UPDATE memory_facts
-         SET confidence = MIN(1, confidence + 0.03),
-             updated_at = datetime('now')
-         WHERE memory_id = ? AND status = 'active'`
-      ).run(exact.id);
-      return exact.id;
+      return this._reinforceExactMemory(exact.id, importance);
     }
 
     const duplicateCandidateIds = embedding
@@ -1717,8 +1725,8 @@ class MemoryManager {
 
     // Save new
     const id = uuidv4();
-    db.prepare(
-      `INSERT INTO memories (
+    const insertResult = db.prepare(
+      `INSERT OR IGNORE INTO memories (
         id, user_id, agent_id, category, scope_type, scope_id, source_type, source_id, source_label,
         stale_after_days, metadata_json, content, summary, importance, confidence, memory_hash, embedding,
         embedding_provider, embedding_model, embedding_dimensions, embedded_at
@@ -1747,6 +1755,13 @@ class MemoryManager {
       embeddingResult?.dimensions || null,
       embedding ? new Date().toISOString() : null,
     );
+    if (insertResult.changes === 0) {
+      const existingExact = this._findExactMemory(userId, agentId, memoryHash, scope);
+      if (existingExact?.id) {
+        return this._reinforceExactMemory(existingExact.id, importance);
+      }
+      throw new Error('Memory insert was ignored but no matching memory row was found');
+    }
 
     this._upsertMemoryIntelligence(userId, agentId, id, {
       content,

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/runtime/manager.js

@@ -161,9 +161,13 @@ class RuntimeManager {
   }
 
   async shutdown() {
-    await Promise.allSettled([
+    const tasks = [
       this.browserBackend?.shutdown?.(),
-    ]);
+    ];
+    if (typeof this.shellWorkerPool?.shutdown === 'function') {
+      tasks.push(Promise.resolve().then(() => this.shellWorkerPool.shutdown()));
+    }
+    await Promise.allSettled(tasks);
   }
 }