neoagent 2.3.1-beta.113 → 2.3.1-beta.115

package/lib/manager.js

@@ -5,6 +5,7 @@ const net = require('net');
 const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
+const { CLAUDE_CODE_SCOPES } = require('../server/services/ai/providers/claudeCode');
 const {
   buildBundledWebClientIfPossible: buildWebClient,
   commandExists: sharedCommandExists,
@@ -815,7 +816,7 @@ async function cmdLoginClaudeCode() {
   const { URL: NodeURL } = require('url');
 
   const clientId = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
-  const SCOPES = 'user:inference user:profile org:create_api_key user:sessions:claude_code user:mcp_servers';
+  const SCOPES = CLAUDE_CODE_SCOPES;
 
   // The registered redirect URIs are http://localhost/callback and http://127.0.0.1/callback
   // (port 80). The OAuth server validates the URI exactly, so we must use port 80.
@@ -919,6 +920,7 @@ async function cmdLoginClaudeCode() {
       redirect_uri: redirectUri,
       client_id: clientId,
       code_verifier: codeVerifier,
+      scope: SCOPES,
       state,
     }),
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.3.1-beta.113",
+  "version": "2.3.1-beta.115",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/.last_build_id

@@ -1 +1 @@
-0c62ef7d28ad8b7fe9751b4f055e1afb
+1924fa6bc28b6ba8af56dfa6c7146c4b

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"42d3d75a56efe1a2e9902f52dc8006099c45d9
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "699610273" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "138973699" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/public/main.dart.js

@@ -129338,7 +129338,7 @@ r===$&&A.b()
 o.push(A.ii(p,A.iY(!1,new A.a3(B.tM,A.dT(new A.cI(B.he,new A.a5V(r,p),p),p,p),p),!1,B.I,!0),p,p,0,0,0,p))}r=!1
 if(!s.ay)if(!s.ch){r=s.e
 r===$&&A.b()
-r=B.b.t("mpb8ba09-f0b0778").length!==0&&r.b}if(r){r=s.d
+r=B.b.t("mpb9d6tg-0a6c4fd").length!==0&&r.b}if(r){r=s.d
 r===$&&A.b()
 r=r.ag&&!r.V?84:0
 q=s.e
@@ -134146,7 +134146,7 @@ $S:236}
 A.Ys.prototype={}
 A.Rr.prototype={
 mT(a){var s=this
-if(B.b.t("mpb8ba09-f0b0778").length===0||s.a!=null)return
+if(B.b.t("mpb9d6tg-0a6c4fd").length===0||s.a!=null)return
 s.A5()
 s.a=A.q1(B.PP,new A.b58(s))},
 A5(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -134164,7 +134164,7 @@ if(!t.f.b(k)){s=1
 break}i=J.Z(k,"buildId")
 h=i==null?null:B.b.t(J.r(i))
 j=h==null?"":h
-if(J.bm(j)===0||J.d(j,"mpb8ba09-f0b0778")){s=1
+if(J.bm(j)===0||J.d(j,"mpb9d6tg-0a6c4fd")){s=1
 break}n.b=!0
 n.D()
 p=2
@@ -134181,7 +134181,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$A5,r)},
 vb(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f,e,d,c,b,a,a0,a1
 var $async$vb=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.t("mpb8ba09-f0b0778").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.t("mpb9d6tg-0a6c4fd").length===0||n.c){s=1
 break}n.c=!0
 n.D()
 p=4

package/server/services/ai/providers/claudeCode.js

@@ -9,25 +9,40 @@ const CLAUDE_CODE_BASE_URL = 'https://api.anthropic.com';
 const CLAUDE_CODE_VERSION = process.env.CLAUDE_CODE_VERSION || '2.1.75';
 const CLAUDE_CODE_OAUTH_BETA = 'claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14';
 const CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude.";
+const CLAUDE_CODE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+const CLAUDE_CODE_TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
+const CLAUDE_CODE_SCOPES = 'user:inference user:profile org:create_api_key user:sessions:claude_code user:mcp_servers';
+
+function readTokenRecord(data) {
+  const tokens = data?.claudeAiOauthTokens || data?.claudeAiOauth || {};
+  const access = tokens.accessToken || tokens.access;
+  const refresh = tokens.refreshToken || tokens.refresh;
+  const expires = tokens.expiresAt || tokens.expires;
+  return {
+    access: typeof access === 'string' && access ? access : null,
+    refresh: typeof refresh === 'string' && refresh ? refresh : null,
+    expires: typeof expires === 'number' && Number.isFinite(expires) ? expires : null,
+  };
+}
 
 function readTokenValue(data) {
-  return data?.claudeAiOauthTokens?.accessToken
-    || data?.claudeAiOauth?.accessToken
-    || data?.claudeAiOauth?.access
-    || null;
+  return readTokenRecord(data).access;
 }
 
-function readClaudeCliToken() {
+function readClaudeCliTokenRecord() {
   try {
     const raw = fs.readFileSync(CLAUDE_CLI_CREDS_PATH, 'utf8');
     const data = JSON.parse(raw);
-    const token = readTokenValue(data);
-    return typeof token === 'string' && token ? token : null;
+    return readTokenRecord(data);
   } catch {
-    return null;
+    return { access: null, refresh: null, expires: null };
   }
 }
 
+function readClaudeCliToken() {
+  return readClaudeCliTokenRecord().access;
+}
+
 function mergeAnthropicBeta(existing) {
   if (!existing) return CLAUDE_CODE_OAUTH_BETA;
   const seen = new Set();
@@ -43,6 +58,110 @@ function mergeAnthropicBeta(existing) {
     .join(',');
 }
 
+function normalizeExpiresAt(data) {
+  if (typeof data.expires_at === 'number' && Number.isFinite(data.expires_at)) {
+    return data.expires_at > 10_000_000_000 ? data.expires_at : data.expires_at * 1000;
+  }
+  if (typeof data.expiresAt === 'number' && Number.isFinite(data.expiresAt)) {
+    return data.expiresAt > 10_000_000_000 ? data.expiresAt : data.expiresAt * 1000;
+  }
+  if (typeof data.expires_in === 'number' && Number.isFinite(data.expires_in)) {
+    return Date.now() + (data.expires_in * 1000);
+  }
+  return null;
+}
+
+function sanitizeEnvKey(key) {
+  return String(key).replace(/[\r\n]/g, '');
+}
+
+function sanitizeEnvValue(value) {
+  return String(value).replace(/[\r\n]/g, '');
+}
+
+function persistEnvValue(key, value) {
+  if (!value) return;
+  try {
+    const { ENV_FILE } = require('../../../../runtime/paths');
+    const safeKey = sanitizeEnvKey(key);
+    const safeValue = sanitizeEnvValue(value);
+    const raw = fs.existsSync(ENV_FILE) ? fs.readFileSync(ENV_FILE, 'utf8') : '';
+    const lines = raw ? raw.split('\n') : [];
+    let replaced = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith(`${safeKey}=`)) {
+        lines[i] = `${safeKey}=${safeValue}`;
+        replaced = true;
+        break;
+      }
+    }
+    if (!replaced) lines.push(`${safeKey}=${safeValue}`);
+    const output = lines.filter((_, idx, arr) => idx !== arr.length - 1 || arr[idx] !== '').join('\n') + '\n';
+    fs.mkdirSync(path.dirname(ENV_FILE), { recursive: true });
+    fs.writeFileSync(ENV_FILE, output, { mode: 0o600 });
+  } catch { }
+}
+
+async function refreshClaudeCodeAccessToken(refreshToken, fetchImpl = fetch) {
+  if (!refreshToken) return null;
+  const response = await fetchImpl(CLAUDE_CODE_TOKEN_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: CLAUDE_CODE_CLIENT_ID,
+      scope: CLAUDE_CODE_SCOPES,
+    }),
+  });
+
+  const text = await response.text();
+  let data = {};
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    data = {};
+  }
+
+  if (!response.ok) {
+    const detail = data?.error?.message || data?.error_description || data?.error || text || 'Unknown error';
+    throw new Error(`Claude Code OAuth refresh failed: HTTP ${response.status} ${detail}`);
+  }
+  if (!data.access_token) {
+    throw new Error('Claude Code OAuth refresh succeeded but no access_token was returned.');
+  }
+
+  return {
+    access: data.access_token,
+    refresh: data.refresh_token || refreshToken,
+    expires: normalizeExpiresAt(data),
+  };
+}
+
+function isAuthenticationError(err) {
+  return err?.status === 401 || err?.error?.type === 'authentication_error';
+}
+
+function isInferenceScopeError(err) {
+  const message = String(err?.error?.message || err?.message || '');
+  const type = String(err?.error?.type || err?.type || '');
+  return err?.status === 403
+    && (type === 'permission_error' || message.includes('"permission_error"'))
+    && message.includes('scope requirement')
+    && message.includes('user:inference');
+}
+
+function formatClaudeCodeCredentialError(err) {
+  if (isInferenceScopeError(err)) {
+    return new Error(`Claude Code OAuth token is missing inference scope. Re-run \`neoagent login claude-code\` to create a token with ${CLAUDE_CODE_SCOPES}.`);
+  }
+  return err;
+}
+
 class ClaudeCodeProvider extends AnthropicProvider {
   constructor(config = {}) {
     super(config);
@@ -58,12 +177,17 @@ class ClaudeCodeProvider extends AnthropicProvider {
       'claude-haiku-4-5-20251001': 200000,
     };
 
-    const authToken = config.apiKey || process.env.CLAUDE_CODE_OAUTH_TOKEN || readClaudeCliToken();
+    const cliTokenRecord = readClaudeCliTokenRecord();
+    const authToken = config.apiKey || process.env.CLAUDE_CODE_OAUTH_TOKEN || cliTokenRecord.access;
     if (!authToken) {
       console.warn('[ClaudeCode] No access token. Run `neoagent login claude-code` to authenticate.');
     }
 
-    const defaultHeaders = {
+    this.authToken = authToken || null;
+    this.refreshToken = config.refreshToken || process.env.CLAUDE_CODE_REFRESH_TOKEN || cliTokenRecord.refresh || null;
+    this.fetchImpl = config.fetch || fetch;
+    this.baseURL = config.baseUrl || CLAUDE_CODE_BASE_URL;
+    this.defaultHeaders = {
       ...(config.defaultHeaders || {}),
       accept: 'application/json',
       'anthropic-dangerous-direct-browser-access': 'true',
@@ -72,16 +196,35 @@ class ClaudeCodeProvider extends AnthropicProvider {
       'x-app': 'cli',
     };
 
+    this.client = this.createClient(this.authToken, config);
+  }
+
+  createClient(authToken, config = this.config) {
     // OAuth tokens use Authorization: Bearer. Claude Code subscription inference
     // also requires the Claude Code beta surface headers used by the official CLI.
-    this.client = new Anthropic({
+    return new Anthropic({
       authToken: authToken || undefined,
-      baseURL: config.baseUrl || CLAUDE_CODE_BASE_URL,
-      defaultHeaders: authToken ? defaultHeaders : config.defaultHeaders,
-      ...(config.fetch ? { fetch: config.fetch } : {}),
+      baseURL: this.baseURL,
+      defaultHeaders: authToken ? this.defaultHeaders : config.defaultHeaders,
+      ...(this.fetchImpl ? { fetch: this.fetchImpl } : {}),
     });
   }
 
+  async refreshClient() {
+    const refreshed = await refreshClaudeCodeAccessToken(this.refreshToken, this.fetchImpl);
+    if (!refreshed?.access) return false;
+    this.authToken = refreshed.access;
+    this.refreshToken = refreshed.refresh || this.refreshToken;
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = this.authToken;
+    persistEnvValue('CLAUDE_CODE_OAUTH_TOKEN', this.authToken);
+    if (this.refreshToken) {
+      process.env.CLAUDE_CODE_REFRESH_TOKEN = this.refreshToken;
+      persistEnvValue('CLAUDE_CODE_REFRESH_TOKEN', this.refreshToken);
+    }
+    this.client = this.createClient(this.authToken);
+    return true;
+  }
+
   convertMessages(messages) {
     const converted = super.convertMessages(messages);
     if (!converted.system) {
@@ -94,6 +237,38 @@ class ClaudeCodeProvider extends AnthropicProvider {
     ];
     return converted;
   }
+
+  async chat(messages, tools = [], options = {}) {
+    try {
+      return await super.chat(messages, tools, options);
+    } catch (err) {
+      if ((!isAuthenticationError(err) && !isInferenceScopeError(err)) || !this.refreshToken) {
+        throw formatClaudeCodeCredentialError(err);
+      }
+      await this.refreshClient();
+      try {
+        return await super.chat(messages, tools, options);
+      } catch (retryErr) {
+        throw formatClaudeCodeCredentialError(retryErr);
+      }
+    }
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    try {
+      yield* super.stream(messages, tools, options);
+    } catch (err) {
+      if ((!isAuthenticationError(err) && !isInferenceScopeError(err)) || !this.refreshToken) {
+        throw formatClaudeCodeCredentialError(err);
+      }
+      await this.refreshClient();
+      try {
+        yield* super.stream(messages, tools, options);
+      } catch (retryErr) {
+        throw formatClaudeCodeCredentialError(retryErr);
+      }
+    }
+  }
 }
 
-module.exports = { ClaudeCodeProvider, readClaudeCliToken };
+module.exports = { ClaudeCodeProvider, readClaudeCliToken, refreshClaudeCodeAccessToken, CLAUDE_CODE_SCOPES };

package/server/services/ai/providers/openaiCodex.js

@@ -79,33 +79,45 @@ function normalizeContent(content) {
   return String(content);
 }
 
-function normalizeInputContent(content) {
+function normalizeMessageContent(content, role = 'user') {
   if (content == null) return [];
+  const isAssistant = role === 'assistant';
+  const textType = isAssistant ? 'output_text' : 'input_text';
 
   if (typeof content === 'string') {
-    return [{ type: 'input_text', text: content }];
+    return [{ type: textType, text: content, ...(isAssistant ? { annotations: [] } : {}) }];
   }
 
   if (!Array.isArray(content)) {
     const text = String(content);
-    return text ? [{ type: 'input_text', text }] : [];
+    return text ? [{ type: textType, text, ...(isAssistant ? { annotations: [] } : {}) }] : [];
   }
 
   const parts = [];
   for (const part of content) {
     if (!part) continue;
     if (typeof part === 'string') {
-      if (part.trim()) parts.push({ type: 'input_text', text: part });
+      if (part.trim()) parts.push({ type: textType, text: part, ...(isAssistant ? { annotations: [] } : {}) });
       continue;
     }
     if (part.type === 'text' && typeof part.text === 'string') {
-      parts.push({ type: 'input_text', text: part.text });
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: [] } : {}) });
       continue;
     }
     if (part.type === 'input_text' && typeof part.text === 'string') {
-      parts.push({ type: 'input_text', text: part.text });
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: [] } : {}) });
       continue;
     }
+    if (part.type === 'output_text' && typeof part.text === 'string') {
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: part.annotations || [] } : {}) });
+      continue;
+    }
+    if (isAssistant && part.type === 'refusal') {
+      const refusal = typeof part.refusal === 'string' ? part.refusal : part.text;
+      if (typeof refusal === 'string') parts.push({ type: 'refusal', refusal });
+      continue;
+    }
+    if (isAssistant) continue;
     if (part.type === 'image_url') {
       const imageUrl = typeof part.image_url === 'string' ? part.image_url : part.image_url?.url;
       if (imageUrl) {
@@ -278,11 +290,12 @@ class OpenAICodexProvider extends BaseProvider {
         continue;
       }
 
-      const content = normalizeInputContent(msg.content);
+      const role = msg.role === 'assistant' ? 'assistant' : 'user';
+      const content = normalizeMessageContent(msg.content, role);
       if (content.length > 0) {
         input.push({
           type: 'message',
-          role: msg.role === 'assistant' ? 'assistant' : 'user',
+          role,
           content,
         });
       }