neoagent 3.2.1-beta.2 → 3.2.1-beta.4

package/server/services/integrations/neoarchive/provider.js

@@ -13,9 +13,11 @@ const {
 const { getConnectionAccessMode } = require("../access");
 const { decryptValue } = require("../secrets");
 const { appendQuery, fetchJson } = require("../oauth_provider");
+const { fetchResponseText } = require("../http");
 const { resolvePublicBaseUrl } = require("../env");
 
 const KEY = "neoarchive";
+const MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
 const APP = Object.freeze({
   id: "archive",
   label: "Archive",
@@ -277,24 +279,25 @@ function snapshot(provider, rows, context) {
     connectionMethod: "oauth",
   };
 }
-async function bootstrap(baseUrl) {
+async function bootstrap(baseUrl, options = {}) {
   return fetchJson(
     `${baseUrl}/api/oauth/companion/neoagent/bootstrap`,
     {
       method: "POST",
       json: { redirectUri: callbackUrl(), appName: "NeoAgent" },
+      signal: options.signal,
     },
     { serviceName: "NeoArchive companion bootstrap" },
   );
 }
-async function token(baseUrl, form) {
+async function token(baseUrl, form, options = {}) {
   return fetchJson(
     `${baseUrl}/oauth/token`,
-    { method: "POST", form },
+    { method: "POST", form, signal: options.signal },
     { serviceName: "NeoArchive OAuth token" },
   );
 }
-async function access(connection) {
+async function access(connection, options = {}) {
   const saved = credentials(connection);
   const baseUrl = normalizeBaseUrl(saved.baseUrl);
   if (saved.access_token && Number(saved.expires_at_ms) > Date.now() + 60000)
@@ -307,7 +310,7 @@ async function access(connection) {
     grant_type: "refresh_token",
     client_id: saved.client_id,
     refresh_token: saved.refresh_token,
-  });
+  }, options);
   const next = {
     ...saved,
     access_token: text(refreshed.access_token),
@@ -319,13 +322,14 @@ async function access(connection) {
   return { baseUrl, accessToken: next.access_token, credentials: next };
 }
 async function request(connection, apiPath, options = {}) {
-  const auth = await access(connection);
+  const auth = await access(connection, options);
   const response = await fetchJson(
     `${auth.baseUrl}${apiPath}`,
     {
       method: options.method || "GET",
       headers: { Authorization: `Bearer ${auth.accessToken}` },
       ...(options.json === undefined ? {} : { json: options.json }),
+      signal: options.signal,
     },
     { serviceName: "NeoArchive API" },
   );
@@ -336,7 +340,7 @@ function required(value, name) {
   if (!normalized) throw new Error(`${name} is required.`);
   return normalized;
 }
-async function upload(connection, filePath) {
+async function upload(connection, filePath, options = {}) {
   const raw = text(filePath);
   if (!raw || raw.split(/[\\/]+/).includes(".."))
     throw new Error(
@@ -346,27 +350,40 @@ async function upload(connection, filePath) {
   const stats = await fs.promises.stat(resolved);
   if (!stats.isFile())
     throw new Error("file_path must point to a readable file.");
+  if (stats.size > MAX_UPLOAD_BYTES)
+    throw new Error(`file_path exceeds the ${MAX_UPLOAD_BYTES}-byte upload limit.`);
   await fs.promises.access(resolved, fs.constants.R_OK);
-  const auth = await access(connection);
+  const auth = await access(connection, options);
   const form = new FormData();
   form.append(
     "files",
-    new Blob([await fs.promises.readFile(resolved)]),
+    new Blob([await fs.promises.readFile(resolved, { signal: options.signal })]),
     path.basename(resolved),
   );
-  const response = await fetch(`${auth.baseUrl}/api/v1/documents`, {
-    method: "POST",
-    headers: { Authorization: `Bearer ${auth.accessToken}` },
-    body: form,
-  });
-  const result = await response.json().catch(() => null);
+  const { response, text: responseText } = await fetchResponseText(
+    `${auth.baseUrl}/api/v1/documents`,
+    {
+      method: "POST",
+      headers: { Authorization: `Bearer ${auth.accessToken}` },
+      body: form,
+      signal: options.signal,
+      timeoutMs: 120000,
+    },
+    { serviceName: "NeoArchive upload" },
+  );
+  let result = null;
+  try {
+    result = responseText ? JSON.parse(responseText) : null;
+  } catch {
+    result = null;
+  }
   if (!response.ok)
     throw new Error(
       `NeoArchive upload request failed: ${result?.error || response.statusText}`,
     );
   return { result, credentials: auth.credentials };
 }
-async function execute(toolName, args, connection) {
+async function execute(toolName, args, connection, options = {}) {
   let pathName;
   let method = "GET";
   let json;
@@ -401,7 +418,7 @@ async function execute(toolName, args, connection) {
       pathName = "/api/v1/document-types";
       break;
     case "neoarchive_upload_document":
-      return upload(connection, args.file_path);
+      return upload(connection, args.file_path, options);
     case "neoarchive_update_document":
       pathName = `/api/v1/documents/${encodeURIComponent(required(args.document_id, "document_id"))}`;
       method = "PATCH";
@@ -426,7 +443,11 @@ async function execute(toolName, args, connection) {
     default:
       throw new Error(`Unsupported NeoArchive tool: ${toolName}`);
   }
-  const result = await request(connection, pathName, { method, json });
+  const result = await request(connection, pathName, {
+    method,
+    json,
+    signal: options.signal,
+  });
   return { result: result.response, credentials: result.credentials };
 }
 
@@ -483,7 +504,7 @@ function createNeoArchiveProvider() {
           ? "NeoArchive: setup is ready, but no archive account is connected."
           : "NeoArchive: connected with document search, metadata, text, upload, archive, and reprocessing tools.";
     },
-    async beginOAuth({ state, codeVerifier, userId, agentId, appKey }) {
+    async beginOAuth({ state, codeVerifier, userId, agentId, appKey, signal }) {
       if (text(appKey) !== APP.id) throw new Error("Unknown NeoArchive app.");
       const stored = config(
         getProviderConfig(
@@ -493,7 +514,7 @@ function createNeoArchiveProvider() {
         ),
       );
       const baseUrl = normalizeBaseUrl(stored.baseUrl);
-      const boot = await bootstrap(baseUrl);
+      const boot = await bootstrap(baseUrl, { signal });
       const challenge = crypto
         .createHash("sha256")
         .update(String(codeVerifier))
@@ -515,7 +536,7 @@ function createNeoArchiveProvider() {
         ),
       };
     },
-    async finishOAuth({ userId, agentId, code, codeVerifier }) {
+    async finishOAuth({ userId, agentId, code, codeVerifier, signal }) {
       const stored = config(
         getProviderConfig(
           Number(userId),
@@ -524,21 +545,24 @@ function createNeoArchiveProvider() {
         ),
       );
       const baseUrl = normalizeBaseUrl(stored.baseUrl);
-      const boot = await bootstrap(baseUrl);
+      const boot = await bootstrap(baseUrl, { signal });
       const issued = await token(baseUrl, {
         grant_type: "authorization_code",
         client_id: boot.clientId,
         code: text(code),
         redirect_uri: text(boot.redirectUri) || callbackUrl(),
         code_verifier: text(codeVerifier),
-      });
+      }, { signal });
       const accessToken = text(issued.access_token);
       const refreshToken = text(issued.refresh_token);
       if (!accessToken || !refreshToken)
         throw new Error("NeoArchive did not return durable OAuth credentials.");
       const info = await fetchJson(
         `${baseUrl}/oauth/userinfo`,
-        { headers: { Authorization: `Bearer ${accessToken}` } },
+        {
+          headers: { Authorization: `Bearer ${accessToken}` },
+          signal,
+        },
         { serviceName: "NeoArchive userinfo" },
       );
       const host = new URL(baseUrl).host;
@@ -565,8 +589,10 @@ function createNeoArchiveProvider() {
         },
       };
     },
-    async executeTool(toolName, args, connection) {
-      return execute(toolName, args || {}, connection);
+    async executeTool(toolName, args, connection, executionOptions = {}) {
+      return execute(toolName, args || {}, connection, {
+        signal: executionOptions.signal || null,
+      });
     },
     getUserConfig({ userId, agentId }) {
       const scoped = resolveAgentId(Number(userId), agentId);
@@ -584,17 +610,17 @@ function createNeoArchiveProvider() {
         hasConnectedAccount: accountCount > 0,
       };
     },
-    async saveUserConfig({ userId, agentId, config: input }) {
+    async saveUserConfig({ userId, agentId, config: input, signal }) {
       const scoped = resolveAgentId(Number(userId), agentId);
       const existing = config(getProviderConfig(Number(userId), KEY, scoped));
       const parsed = config(input, existing);
       const baseUrl = normalizeBaseUrl(parsed.baseUrl);
       await fetchJson(
         `${baseUrl}/api/v1/health`,
-        { method: "GET" },
+        { method: "GET", signal },
         { serviceName: "NeoArchive health check" },
       );
-      await bootstrap(baseUrl);
+      await bootstrap(baseUrl, { signal });
       setProviderConfig(Number(userId), KEY, { baseUrl }, scoped);
       if (existing.baseUrl && existing.baseUrl !== baseUrl)
         db.prepare(

package/server/services/integrations/neorecall/client.js

@@ -29,17 +29,22 @@ function normalizeBaseUrl(value) {
   return url.toString().replace(/\/+$/, '');
 }
 
-async function bootstrap(baseUrl, callbackUrl) {
+async function bootstrap(baseUrl, callbackUrl, options = {}) {
   return fetchJson(`${baseUrl}/api/oauth/companion/neoagent/bootstrap`, {
     method: 'POST', json: { redirectUri: callbackUrl, appName: 'NeoAgent' },
+    signal: options.signal,
   }, { serviceName: 'NeoRecall companion bootstrap' });
 }
 
-async function token(baseUrl, form) {
-  return fetchJson(`${baseUrl}/oauth/token`, { method: 'POST', form }, { serviceName: 'NeoRecall OAuth token' });
+async function token(baseUrl, form, options = {}) {
+  return fetchJson(
+    `${baseUrl}/oauth/token`,
+    { method: 'POST', form, signal: options.signal },
+    { serviceName: 'NeoRecall OAuth token' },
+  );
 }
 
-async function revoke(credentials) {
+async function revoke(credentials, options = {}) {
   const saved = credentials && typeof credentials === 'object' ? credentials : {};
   const baseUrl = normalizeBaseUrl(saved.baseUrl);
   const clientId = text(saved.client_id);
@@ -47,12 +52,13 @@ async function revoke(credentials) {
   const tokens = [saved.refresh_token, saved.access_token].map(text).filter(Boolean);
   const outcomes = await Promise.allSettled(tokens.map((value) => fetchJson(`${baseUrl}/oauth/revoke`, {
     method: 'POST', form: { client_id: clientId, token: value },
+    signal: options.signal,
   }, { serviceName: 'NeoRecall OAuth revocation' })));
   const failed = outcomes.find((outcome) => outcome.status === 'rejected');
   if (failed) throw failed.reason;
 }
 
-async function authenticated(credentials) {
+async function authenticated(credentials, options = {}) {
   const saved = credentials && typeof credentials === 'object' ? credentials : {};
   const baseUrl = normalizeBaseUrl(saved.baseUrl);
   if (text(saved.access_token) && Number(saved.expires_at_ms) > Date.now() + 60_000) {
@@ -63,7 +69,7 @@ async function authenticated(credentials) {
   }
   const refreshed = await token(baseUrl, {
     grant_type: 'refresh_token', client_id: saved.client_id, refresh_token: saved.refresh_token,
-  });
+  }, options);
   const next = {
     ...saved,
     access_token: text(refreshed.access_token),
@@ -97,15 +103,16 @@ function appendApiQuery(path, query) {
   return encoded ? `${path}?${encoded}` : path;
 }
 
-async function request(credentials, apiPath) {
-  const authorization = await authenticated(credentials);
+async function request(credentials, apiPath, options = {}) {
+  const authorization = await authenticated(credentials, options);
   const response = await fetchJson(`${authorization.baseUrl}${apiPath}`, {
     headers: { Authorization: `Bearer ${authorization.accessToken}` },
+    signal: options.signal,
   }, { serviceName: 'NeoRecall API' });
   return { result: response, credentials: authorization.credentials };
 }
 
-async function executeTool(toolName, args, credentials) {
+async function executeTool(toolName, args, credentials, options = {}) {
   let apiPath;
   switch (toolName) {
     case 'neorecall_search': {
@@ -134,7 +141,7 @@ async function executeTool(toolName, args, credentials) {
     default:
       throw new Error(`Unsupported NeoRecall tool: ${toolName}`);
   }
-  return request(credentials, apiPath);
+  return request(credentials, apiPath, options);
 }
 
 module.exports = { bootstrap, executeTool, normalizeBaseUrl, revoke, text, token };

package/server/services/integrations/neorecall/provider.js

@@ -71,9 +71,9 @@ function createNeoRecallProvider() {
     connectionMethod: 'user_config',
     requiresRefreshToken: true,
     getEnvStatus: envStatus,
-    async beginOAuth({ state, codeVerifier, userId, agentId }) {
+    async beginOAuth({ state, codeVerifier, userId, agentId, signal }) {
       const baseUrl = normalizeBaseUrl(storedConfig(userId, resolveAgentId(userId, agentId)).baseUrl);
-      const boot = await bootstrap(baseUrl, callbackUrl());
+      const boot = await bootstrap(baseUrl, callbackUrl(), { signal });
       const challenge = crypto.createHash('sha256').update(String(codeVerifier)).digest('base64url');
       return {
         url: appendQuery(text(boot.authorizationEndpoint) || `${baseUrl}/oauth/authorize`, {
@@ -83,18 +83,19 @@ function createNeoRecallProvider() {
         }),
       };
     },
-    async finishOAuth({ userId, agentId, code, codeVerifier }) {
+    async finishOAuth({ userId, agentId, code, codeVerifier, signal }) {
       const baseUrl = normalizeBaseUrl(storedConfig(userId, resolveAgentId(userId, agentId)).baseUrl);
-      const boot = await bootstrap(baseUrl, callbackUrl());
+      const boot = await bootstrap(baseUrl, callbackUrl(), { signal });
       const issued = await token(baseUrl, {
         grant_type: 'authorization_code', client_id: boot.clientId, code: text(code),
         redirect_uri: text(boot.redirectUri) || callbackUrl(), code_verifier: text(codeVerifier),
-      });
+      }, { signal });
       const accessToken = text(issued.access_token);
       const refreshToken = text(issued.refresh_token);
       if (!accessToken || !refreshToken) throw new Error('NeoRecall did not return durable OAuth credentials.');
       const info = await fetchJson(`${baseUrl}/oauth/userinfo`, {
         headers: { Authorization: `Bearer ${accessToken}` },
+        signal,
       }, { serviceName: 'NeoRecall userinfo' });
       const host = new URL(baseUrl).host;
       const accountEmail = text(info.email) || text(info.preferred_username) || `neorecall:${text(info.sub) || host}`;
@@ -109,10 +110,14 @@ function createNeoRecallProvider() {
       };
     },
     executeTool(toolName, args, context) {
-      return executeTool(toolName, args || {}, context.credentials);
+      return executeTool(toolName, args || {}, context.credentials, {
+        signal: context.signal,
+      });
     },
-    disconnect(connection) {
-      return revoke(connectionCredentials(connection));
+    disconnect(connection, executionOptions = {}) {
+      return revoke(connectionCredentials(connection), {
+        signal: executionOptions.signal || null,
+      });
     },
   });
 
@@ -122,16 +127,20 @@ function createNeoRecallProvider() {
     const accountCount = connectedAccountCount(Number(userId), scoped);
     return { baseUrl: stored.baseUrl, configured: Boolean(stored.baseUrl), accountCount, hasConnectedAccount: accountCount > 0 };
   };
-  provider.saveUserConfig = async ({ userId, agentId, config }) => {
+  provider.saveUserConfig = async ({ userId, agentId, config, signal }) => {
     const normalizedUserId = Number(userId);
     const scoped = resolveAgentId(normalizedUserId, agentId);
     const existing = storedConfig(normalizedUserId, scoped);
     const baseUrl = normalizeBaseUrl(parseConfig(config, existing).baseUrl);
-    const health = await fetchJson(`${baseUrl}/health`, { method: 'GET' }, { serviceName: 'NeoRecall health check' });
+    const health = await fetchJson(
+      `${baseUrl}/health`,
+      { method: 'GET', signal },
+      { serviceName: 'NeoRecall health check' },
+    );
     if (text(health?.status) !== 'ok' || text(health?.process) !== 'http') {
       throw new Error('The configured endpoint did not identify itself as a healthy NeoRecall HTTP service.');
     }
-    const boot = await bootstrap(baseUrl, callbackUrl());
+    const boot = await bootstrap(baseUrl, callbackUrl(), { signal });
     if (text(boot?.companion) !== 'neoagent' || !text(boot?.clientId)) {
       throw new Error('The NeoRecall server does not expose the NeoAgent companion OAuth contract.');
     }

package/server/services/integrations/notion/provider.js

@@ -187,7 +187,8 @@ function notionUrl(path, query) {
   return url.toString();
 }
 
-async function notionRequest(credentials, { method = 'GET', path, query, body }) {
+async function notionRequest(context, { method = 'GET', path, query, body }) {
+  const { credentials, signal } = context;
   return fetchJson(
     notionUrl(path, query),
     {
@@ -197,16 +198,17 @@ async function notionRequest(credentials, { method = 'GET', path, query, body })
         'Notion-Version': NOTION_VERSION,
       },
       ...(body === undefined ? {} : { json: body }),
+      signal,
     },
     { serviceName: 'Notion' },
   );
 }
 
-async function executeNotionTool(toolName, args, { credentials }) {
+async function executeNotionTool(toolName, args, context) {
   switch (toolName) {
     case 'notion_search':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           method: 'POST',
           path: '/v1/search',
           body: {
@@ -218,13 +220,13 @@ async function executeNotionTool(toolName, args, { credentials }) {
       };
     case 'notion_get_page':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           path: `/v1/pages/${encodeURIComponent(requireText(args.page_id, 'page_id'))}`,
         }),
       };
     case 'notion_create_page':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           method: 'POST',
           path: '/v1/pages',
           body: {
@@ -236,7 +238,7 @@ async function executeNotionTool(toolName, args, { credentials }) {
       };
     case 'notion_update_page':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           method: 'PATCH',
           path: `/v1/pages/${encodeURIComponent(requireText(args.page_id, 'page_id'))}`,
           body: {
@@ -249,7 +251,7 @@ async function executeNotionTool(toolName, args, { credentials }) {
       };
     case 'notion_query_database':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           method: 'POST',
           path: `/v1/databases/${encodeURIComponent(requireText(args.database_id, 'database_id'))}/query`,
           body: {
@@ -261,14 +263,14 @@ async function executeNotionTool(toolName, args, { credentials }) {
       };
     case 'notion_get_block_children':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           path: `/v1/blocks/${encodeURIComponent(requireText(args.block_id, 'block_id'))}/children`,
           query: { page_size: Math.max(1, Math.min(Number(args.page_size) || 25, 100)) },
         }),
       };
     case 'notion_append_block_children':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           method: 'PATCH',
           path: `/v1/blocks/${encodeURIComponent(requireText(args.block_id, 'block_id'))}/children`,
           body: { children: Array.isArray(args.children) ? args.children : [] },
@@ -276,7 +278,7 @@ async function executeNotionTool(toolName, args, { credentials }) {
       };
     case 'notion_update_block':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           method: 'PATCH',
           path: `/v1/blocks/${encodeURIComponent(requireText(args.block_id, 'block_id'))}`,
           body: args.body || {},
@@ -284,14 +286,14 @@ async function executeNotionTool(toolName, args, { credentials }) {
       };
     case 'notion_delete_block':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           method: 'DELETE',
           path: `/v1/blocks/${encodeURIComponent(requireText(args.block_id, 'block_id'))}`,
         }),
       };
     case 'notion_api_request':
       return {
-        result: await notionRequest(credentials, {
+        result: await notionRequest(context, {
           method: args.method,
           path: requireText(args.path, 'path'),
           query: args.query,
@@ -332,7 +334,7 @@ function createNotionProvider() {
         appId: app.id,
       };
     },
-    async finishOAuth({ code, app }) {
+    async finishOAuth({ code, app, signal }) {
       const config = resolveNotionOAuthConfig();
       const basic = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString(
         'base64',
@@ -349,6 +351,7 @@ function createNotionProvider() {
             code,
             redirect_uri: config.redirectUri,
           },
+          signal,
         },
         { serviceName: 'Notion' },
       );