neoagent 2.3.1-beta.6 → 2.3.1-beta.61

package/server/services/wearable/protocol.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const WEARABLE_WS_PATH = '/api/wearable/ws';
+
+const CLIENT_MESSAGE_TYPES = new Set([
+  'wearable:hello',
+  'voice:session_open',
+  'voice:input_start',
+  'voice:audio_chunk',
+  'voice:input_commit',
+  'voice:interrupt',
+  'voice:session_close',
+]);
+
+function parseWearableMessage(data) {
+  const text = Buffer.isBuffer(data) ? data.toString('utf8') : String(data || '');
+  const parsed = JSON.parse(text);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('Wearable message must be a JSON object.');
+  }
+  const type = String(parsed.type || '').trim();
+  if (!type) {
+    throw new Error('Wearable message type is required.');
+  }
+  return {
+    ...parsed,
+    type,
+  };
+}
+
+function isWearableHello(message) {
+  return message?.type === 'wearable:hello';
+}
+
+function isSupportedClientMessageType(type) {
+  return CLIENT_MESSAGE_TYPES.has(String(type || '').trim());
+}
+
+module.exports = {
+  CLIENT_MESSAGE_TYPES,
+  WEARABLE_WS_PATH,
+  isSupportedClientMessageType,
+  isWearableHello,
+  parseWearableMessage,
+};

package/server/services/wearable/service.js

@@ -0,0 +1,240 @@
+'use strict';
+
+const { getVersionInfo } = require('../../utils/version');
+const { clientIpFromRequest, lookupIpLocation } = require('../account/geoip');
+const { WEARABLE_WS_PATH } = require('./protocol');
+const {
+  resolveFirmwareManifest,
+  normalizeChannel,
+} = require('./firmware_manifest');
+
+function toTrimmedString(value, maxLength = 512) {
+  return String(value || '').trim().slice(0, maxLength);
+}
+
+function parseOptionalJson(value, fallback = null) {
+  if (!value) return fallback;
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed
+      : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function publicBaseUrlForRequest(req) {
+  const configured = req.app?.locals?.httpRuntimeConfig?.publicUrl || process.env.PUBLIC_URL || '';
+  if (configured) {
+    return String(configured).replace(/\/+$/, '');
+  }
+  const forwardedProto = String(req.get?.('x-forwarded-proto') || '').trim();
+  const protocol = forwardedProto || req.protocol || 'http';
+  return `${protocol}://${req.get('host')}`;
+}
+
+function websocketUrlForBase(baseUrl) {
+  const parsed = new URL(baseUrl);
+  parsed.protocol = parsed.protocol === 'https:' ? 'wss:' : 'ws:';
+  parsed.pathname = WEARABLE_WS_PATH;
+  parsed.search = '';
+  parsed.hash = '';
+  return parsed.toString();
+}
+
+function parseTimeZoneOffsetLabel(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+  if (raw === 'GMT' || raw === 'UTC') return 0;
+  const match = raw.match(/^(?:GMT|UTC)([+-])(\d{1,2})(?::?(\d{2}))?$/i);
+  if (!match) return null;
+  const sign = match[1] === '-' ? -1 : 1;
+  const hours = Number(match[2] || 0);
+  const minutes = Number(match[3] || 0);
+  if (!Number.isFinite(hours) || !Number.isFinite(minutes)) return null;
+  return sign * ((hours * 60 * 60) + (minutes * 60));
+}
+
+function utcOffsetSecondsForTimeZone(timeZone, now = new Date()) {
+  const normalized = String(timeZone || '').trim();
+  if (!normalized) return null;
+  try {
+    const formatter = new Intl.DateTimeFormat('en-US', {
+      timeZone: normalized,
+      timeZoneName: 'shortOffset',
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+    });
+    const zonePart = formatter.formatToParts(now).find((part) => part.type === 'timeZoneName');
+    return parseTimeZoneOffsetLabel(zonePart?.value || '');
+  } catch {
+    return null;
+  }
+}
+
+class WearableService {
+  constructor({ app }) {
+    this.app = app;
+    this.connectionsByUser = new Map();
+  }
+
+  async buildBootstrap(req) {
+    const baseUrl = publicBaseUrlForRequest(req);
+    const version = getVersionInfo();
+    return {
+      server: {
+        baseUrl,
+        websocketUrl: websocketUrlForBase(baseUrl),
+        serverTime: new Date().toISOString(),
+      },
+      auth: {
+        qrLoginChallengePath: '/api/auth/qr-login/challenge',
+        qrLoginStatusPathTemplate: '/api/auth/qr-login/challenge/{challengeId}/status',
+        qrLoginClaimPathTemplate: '/api/auth/qr-login/challenge/{challengeId}/claim',
+        qrLoginResolvePath: '/api/account/qr-login/resolve',
+        qrLoginApprovePath: '/api/account/qr-login/approve',
+      },
+      widgets: {
+        snapshotsPath: '/api/widgets/snapshots',
+      },
+      voice: {
+        websocketPath: WEARABLE_WS_PATH,
+        supportsAudioStreaming: true,
+        events: [
+          'voice:session_ready',
+          'voice:assistant_state',
+          'voice:transcript_partial',
+          'voice:transcript_final',
+          'voice:assistant_text',
+          'voice:audio_chunk',
+          'voice:audio_done',
+          'voice:error',
+        ],
+      },
+      recordings: {
+        basePath: '/api/recordings',
+        voiceAssistantRespondPath: '/api/voice-assistant/respond',
+      },
+      firmware: await this.buildFirmwareManifest(req),
+      version,
+      user: {
+        id: req.session.userId,
+        username: req.session.username || null,
+      },
+      features: {
+        qrPairing: true,
+        widgets: true,
+        voice: true,
+        recordings: true,
+        otaManifest: true,
+      },
+    };
+  }
+
+  async buildFirmwareManifest(req) {
+    const baseUrl = publicBaseUrlForRequest(req);
+    const channel = normalizeChannel(req?.query?.channel || process.env.NEOAGENT_WEARABLE_FIRMWARE_CHANNEL || 'stable');
+    const version = getVersionInfo();
+    const manifest = await resolveFirmwareManifest({
+      channel,
+      repositoryOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_GITHUB_REPOSITORY, 256),
+      assetNameOverride: toTrimmedString(process.env.NEOAGENT_WEARABLE_FIRMWARE_ASSET_NAME, 128),
+    });
+    return {
+      ...manifest,
+      websocketUrl: websocketUrlForBase(baseUrl),
+      minimumServerVersion: manifest.minimumServerVersion || version.version,
+      rollout: parseOptionalJson(process.env.NEOAGENT_WEARABLE_FIRMWARE_ROLLOUT_JSON, null),
+    };
+  }
+
+  buildTimeConfig(req) {
+    const now = new Date();
+    const clientIp = req ? clientIpFromRequest(req) : null;
+    const detectedTimeZone = String(lookupIpLocation(clientIp).data?.timezone || '').trim();
+    const fallbackTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    const timeZone = detectedTimeZone || fallbackTimeZone;
+    const offsetSeconds =
+      utcOffsetSecondsForTimeZone(timeZone, now)
+      ?? utcOffsetSecondsForTimeZone(fallbackTimeZone, now)
+      ?? (-now.getTimezoneOffset() * 60);
+    return {
+      timezone: timeZone,
+      utcOffsetSeconds: offsetSeconds,
+      serverTime: now.toISOString(),
+      source: detectedTimeZone ? 'client_ip_geoip' : 'server_fallback',
+      ipAddress: clientIp || null,
+    };
+  }
+
+  registerConnection({
+    userId,
+    ws,
+    remoteAddress = null,
+    userAgent = null,
+    hello = {},
+  }) {
+    const key = Number(userId);
+    const userSet = this.connectionsByUser.get(key) || new Map();
+    const deviceId = [
+      toTrimmedString(hello.device?.deviceId, 160),
+      toTrimmedString(hello.device?.macAddress, 64),
+      toTrimmedString(ws?._socket?.remoteAddress, 120),
+    ].find(Boolean) || `wearable-${Date.now()}`;
+    const connection = {
+      deviceId,
+      ws,
+      connectedAt: new Date().toISOString(),
+      remoteAddress: toTrimmedString(remoteAddress, 120) || null,
+      userAgent: toTrimmedString(userAgent, 500) || null,
+      hello: {
+        platform: toTrimmedString(hello.device?.platform, 40) || 'esp32s3',
+        firmwareVersion: toTrimmedString(hello.device?.firmwareVersion, 120) || null,
+        deviceLabel: toTrimmedString(hello.device?.deviceLabel, 120) || null,
+      },
+      lastSeenAt: new Date().toISOString(),
+    };
+    userSet.set(deviceId, connection);
+    this.connectionsByUser.set(key, userSet);
+    return connection;
+  }
+
+  touchConnection(userId, deviceId) {
+    const userSet = this.connectionsByUser.get(Number(userId));
+    const connection = userSet?.get(String(deviceId || '').trim());
+    if (connection) {
+      connection.lastSeenAt = new Date().toISOString();
+    }
+  }
+
+  unregisterConnection(userId, deviceId) {
+    const userSet = this.connectionsByUser.get(Number(userId));
+    if (!userSet) return;
+    userSet.delete(String(deviceId || '').trim());
+    if (userSet.size === 0) {
+      this.connectionsByUser.delete(Number(userId));
+    }
+  }
+
+  listConnections(userId) {
+    const userSet = this.connectionsByUser.get(Number(userId));
+    if (!userSet) return [];
+    return Array.from(userSet.values()).map((entry) => ({
+      deviceId: entry.deviceId,
+      connectedAt: entry.connectedAt,
+      lastSeenAt: entry.lastSeenAt,
+      remoteAddress: entry.remoteAddress,
+      userAgent: entry.userAgent,
+      hello: entry.hello,
+    }));
+  }
+}
+
+module.exports = {
+  WEARABLE_WS_PATH,
+  WearableService,
+  publicBaseUrlForRequest,
+  websocketUrlForBase,
+};

package/server/services/widgets/service.js

@@ -540,11 +540,14 @@ class WidgetService {
       '',
       'You are updating a structured product widget. Keep the layout fixed. Refresh only the content snapshot.',
       'Use fresh tools for time-sensitive claims. Do not rely on stale memory for live data such as weather, markets, incidents, or schedules.',
+      'The refresh run has a hard limit of 30 tool-call iterations. Call save_widget_snapshot as early as you have enough accurate data; do not keep exploring after saving.',
       'After gathering the latest information, call save_widget_snapshot exactly once with a payload matching this schema:',
       '{"title":"","kicker":"","subtitle":"","body":"","metric":"","metricLabel":"","secondaryMetric":"","secondaryLabel":"","tertiaryMetric":"","tertiaryLabel":"","trend":{"label":"","direction":"flat"},"progress":{"value":0,"max":100,"label":""},"rows":[{"label":"","value":""}],"chips":[""],"iconToken":"","accentToken":"","backgroundToken":"","surfaceColor":"","updatedAt":"","deepLink":""}',
       'Rules:',
       '- Do not change the template or layout variant.',
+      '- The run is only complete after save_widget_snapshot succeeds. A plain text reply without saving is a failed refresh.',
       '- Once you have enough accurate data, call save_widget_snapshot exactly once and stop. Do not keep exploring after saving.',
+      '- Do not repeat the same tool call with identical arguments unless the previous attempt clearly failed or returned empty/incomplete data.',
       '- Keep rows to at most 3 and chips to at most 3.',
       '- Prefer concrete data over generic prose. Use metric + supporting fields whenever live data exists.',
       '- Make the widget immediately useful at a glance. Avoid filler copy, duplicated labels, or repeating the widget name unless it helps identify the subject.',

package/server/utils/local_secrets.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const crypto = require('crypto');
+const { getSessionSecret } = require('../services/account/session_secret');
+
+const LOCAL_SECRET_PREFIX = 'enc:local:v1:';
+
+function getLocalSecretMaterial() {
+  const configured = String(process.env.NEOAGENT_DATA_ENCRYPTION_KEY || '').trim();
+  if (configured) return configured;
+  return getSessionSecret();
+}
+
+function deriveKey() {
+  return crypto.createHash('sha256').update(getLocalSecretMaterial()).digest();
+}
+
+function isLocalEncryptedValue(value) {
+  return String(value || '').startsWith(LOCAL_SECRET_PREFIX);
+}
+
+function encryptLocalValue(value) {
+  const text = String(value || '');
+  if (!text) return '';
+  if (isLocalEncryptedValue(text)) return text;
+
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', deriveKey(), iv);
+  const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `${LOCAL_SECRET_PREFIX}${Buffer.concat([iv, tag, encrypted]).toString('base64')}`;
+}
+
+function decryptLocalValue(value) {
+  const text = String(value || '');
+  if (!text) return '';
+  if (!isLocalEncryptedValue(text)) return text;
+
+  try {
+    const payload = Buffer.from(text.slice(LOCAL_SECRET_PREFIX.length), 'base64');
+    const iv = payload.subarray(0, 12);
+    const tag = payload.subarray(12, 28);
+    const ciphertext = payload.subarray(28);
+    const decipher = crypto.createDecipheriv('aes-256-gcm', deriveKey(), iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8');
+  } catch {
+    return '';
+  }
+}
+
+module.exports = {
+  decryptLocalValue,
+  encryptLocalValue,
+  isLocalEncryptedValue,
+};

package/server/utils/logger.js

@@ -1,14 +1,36 @@
 'use strict';
 
+const SENSITIVE_KEY_RE = /(?:^|_|-)(?:token|secret|password|api[_-]?key|authorization|cookie|session(?:id)?|sid)(?:$|_|-)/i;
+
+function redactSecrets(input) {
+    let text = String(input || '');
+    if (!text) return text;
+
+    text = text
+        .replace(/\b(Bearer\s+)[A-Za-z0-9._~+\/-]+=*/gi, '$1[redacted]')
+        .replace(/([?&](?:token|access_token|refresh_token|api[_-]?key|secret|password|authorization|cookie|session|sid)=)([^&#\s]+)/gi, '$1[redacted]')
+        .replace(/\b(token|access_token|refresh_token|authorization|api[_-]?key|secret|password|cookie|session(?:id)?|sid)\b\s*[:=]\s*("[^"]*"|'[^']*'|[^,\s;]+)/gi, '$1=[redacted]');
+
+    return text;
+}
+
+function sanitizeUrl(value) {
+    return redactSecrets(String(value || ''));
+}
+
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_RE.test(String(key || ''));
+}
+
 function serializeValue(value, seen = new WeakSet()) {
     if (value instanceof Error) {
         return JSON.stringify({
             name: value.name,
-            message: value.message,
-            stack: value.stack,
+            message: redactSecrets(value.message),
+            stack: redactSecrets(value.stack),
             code: value.code,
             cause: value.cause instanceof Error
-                ? { name: value.cause.name, message: value.cause.message, stack: value.cause.stack }
+                ? { name: value.cause.name, message: redactSecrets(value.cause.message), stack: redactSecrets(value.cause.stack) }
                 : value.cause
         });
     }
@@ -22,7 +44,7 @@ function serializeValue(value, seen = new WeakSet()) {
     }
 
     if (!value || typeof value !== 'object') {
-        return String(value);
+        return redactSecrets(String(value));
     }
 
     if (seen.has(value)) {
@@ -33,21 +55,27 @@ function serializeValue(value, seen = new WeakSet()) {
 
     try {
         return JSON.stringify(value, (key, nestedValue) => {
+            if (isSensitiveKey(key)) {
+                return '[redacted]';
+            }
             if (nestedValue instanceof Error) {
                 return {
                     name: nestedValue.name,
-                    message: nestedValue.message,
-                    stack: nestedValue.stack,
+                    message: redactSecrets(nestedValue.message),
+                    stack: redactSecrets(nestedValue.stack),
                     code: nestedValue.code
                 };
             }
             if (typeof nestedValue === 'bigint') {
                 return nestedValue.toString();
             }
+            if (typeof nestedValue === 'string') {
+                return redactSecrets(nestedValue);
+            }
             return nestedValue;
         });
     } catch (err) {
-        return `[Unserializable object: ${err.message}]`;
+        return `[Unserializable object: ${redactSecrets(err.message)}]`;
     } finally {
         seen.delete(value);
     }
@@ -58,14 +86,14 @@ function formatLogArgs(args) {
 }
 
 function logRequestSummary(level, req, message, extra = null) {
-    const prefix = `[HTTP] ${req.method} ${req.originalUrl || req.url}`;
+    const prefix = `[HTTP] ${req.method} ${sanitizeUrl(req.originalUrl || req.url)}`;
     const summary = {
         ip: req.ip,
         userId: req.session?.userId || null,
         userAgent: req.get?.('user-agent') || null,
         ...extra
     };
-    console[level](`${prefix} ${message}`, summary);
+    console[level](redactSecrets(`${prefix} ${message}`), summary);
 }
 
 /**