@clawchatsai/connector 0.0.87 → 0.0.88

package/dist/index.js

@@ -11,10 +11,10 @@
  */
 import * as fs from 'node:fs';
 import * as http from 'node:http';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import { SignalingClient } from './signaling-client.js';
 import { dispatchRpc } from './shim.js';
-import { checkForUpdates, performUpdate } from './updater.js';
 import { initAuth, handleAuthMessage, cleanupAuth } from './auth-handler.js';
 import { generateTotpSecret, verifyTotp, generateBackupCodes, buildOtpauthUri } from './totp.js';
 import { generateSessionSecret } from './session-token.js';
@@ -66,63 +66,58 @@ function saveConfig(config) {
 // ---------------------------------------------------------------------------
 // Service lifecycle
 // ---------------------------------------------------------------------------
+/**
+ * Detect musl libc (Alpine Linux) vs glibc.
+ * prebuildify/prebuild-install distinguishes linux vs linuxmusl.
+ */
+function detectLinuxLibc() {
+    try {
+        const ldd = fs.readFileSync('/usr/bin/ldd', 'utf8');
+        if (ldd.includes('musl'))
+            return 'musl';
+    }
+    catch { /* not found */ }
+    try {
+        if (fs.readdirSync('/lib').some((f) => f.startsWith('libc.musl')))
+            return 'musl';
+    }
+    catch { /* not found */ }
+    return 'glibc';
+}
+/**
+ * Returns the prebuild key for the current platform, matching the directory
+ * names we bundle under prebuilds/ (e.g. "linux-x64", "linuxmusl-arm64").
+ */
+function getPrebuildKey() {
+    const platform = process.platform;
+    const arch = process.arch;
+    if (platform === 'linux' && detectLinuxLibc() === 'musl')
+        return `linuxmusl-${arch}`;
+    return `${platform}-${arch}`;
+}
 async function ensureNativeModules(ctx) {
-    // OpenClaw installs plugins with --ignore-scripts, which skips native module compilation.
-    // Check if native modules are usable; if not, rebuild them automatically.
     const pluginDir = path.resolve(__dirname, '..');
-    const modules = [
-        { name: 'node-datachannel', binding: 'build/Release/node_datachannel.node', strategy: 'install-script' },
-    ];
-    const missing = modules.filter(m => !fs.existsSync(path.join(pluginDir, 'node_modules', m.name, m.binding)));
-    if (missing.length === 0)
-        return; // all built
-    ctx.logger.info(`Building native modules (first run): ${missing.map(m => m.name).join(', ')}...`);
-    const { execFileSync } = await import('node:child_process');
-    for (const mod of missing) {
-        try {
-            if (mod.strategy === 'install-script') {
-                // Packages using prebuild-install need their install script re-run (npm rebuild
-                // only triggers node-gyp, not prebuild-install). Run the install script directly
-                // from the package's directory.
-                const modDir = path.join(pluginDir, 'node_modules', mod.name);
-                const modPkg = JSON.parse(fs.readFileSync(path.join(modDir, 'package.json'), 'utf-8'));
-                const installCmd = modPkg.scripts?.install;
-                if (installCmd) {
-                    // Add local .bin dirs to PATH so prebuild-install and other local binaries resolve.
-                    // Check both the module's own node_modules/.bin (hoisted deps) and the plugin-level one.
-                    const localBin = [
-                        path.join(modDir, 'node_modules', '.bin'),
-                        path.join(pluginDir, 'node_modules', '.bin'),
-                    ].join(':');
-                    execFileSync('sh', ['-c', installCmd], {
-                        cwd: modDir,
-                        stdio: 'pipe',
-                        timeout: 120_000,
-                        env: { ...process.env, PATH: `${localBin}:${process.env.PATH ?? ''}`, npm_config_node_gyp: '' },
-                    });
-                }
-                else {
-                    // Fallback to rebuild if no install script found
-                    execFileSync('npm', ['rebuild', mod.name], {
-                        cwd: pluginDir,
-                        stdio: 'pipe',
-                        timeout: 120_000,
-                    });
-                }
-            }
-            else {
-                execFileSync('npm', ['rebuild', mod.name], {
-                    cwd: pluginDir,
-                    stdio: 'pipe',
-                    timeout: 120_000,
-                });
-            }
-            ctx.logger.info(`${mod.name} ready.`);
-        }
-        catch (e) {
-            ctx.logger.error(`Failed to build ${mod.name}: ${e.message}`);
-            ctx.logger.error(`Try manually: cd ~/.openclaw/extensions/connector && npm rebuild ${mod.name}`);
-        }
+    const targetPath = path.join(pluginDir, 'node_modules', 'node-datachannel', 'build', 'Release', 'node_datachannel.node');
+    // Already built — nothing to do.
+    if (fs.existsSync(targetPath))
+        return;
+    // Find the bundled prebuilt for this platform (shipped inside the npm package).
+    const prebuildKey = getPrebuildKey();
+    const prebuiltPath = path.join(pluginDir, 'prebuilds', prebuildKey, 'node_datachannel.node');
+    if (!fs.existsSync(prebuiltPath)) {
+        ctx.logger.error(`[clawchats] No prebuilt binary for ${prebuildKey}. ` +
+            `WebRTC will be unavailable. To fix manually: ` +
+            `cd ~/.openclaw/extensions/connector && npm rebuild node-datachannel`);
+        return;
+    }
+    ctx.logger.info(`[clawchats] Installing node-datachannel prebuilt for ${prebuildKey}...`);
+    try {
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.copyFileSync(prebuiltPath, targetPath);
+        ctx.logger.info('[clawchats] node-datachannel ready.');
+    }
+    catch (e) {
+        ctx.logger.error(`[clawchats] Failed to install prebuilt: ${e.message}`);
     }
 }
 const CLAWCHATS_MD_CONTENT = `# ClawChats — Inline File Delivery
@@ -171,23 +166,7 @@ async function startClawChats(ctx, api, mediaStash) {
             return;
         ctx.logger.info('Setup detected — connecting to ClawChats...');
     }
-    // 1. Check for updates
-    const update = await checkForUpdates();
-    if (update) {
-        ctx.logger.info(`Update available: ${update.current} → ${update.latest}`);
-        if (ctx._forceUpdate) {
-            try {
-                await performUpdate();
-                ctx.logger.info(`Updated to ${update.latest}. Requesting graceful restart...`);
-                api.runtime.requestRestart?.('clawchats update');
-                return; // will restart with new version
-            }
-            catch (e) {
-                ctx.logger.error(`Auto-update failed: ${e.message}`);
-            }
-        }
-    }
-    // 2. Resolve gateway token: runtime API → config file → error
+    // 1. Resolve gateway token: runtime API → config file → error
     const gwCfg = api.config;
     const gwAuth = gwCfg?.['gateway']?.['auth'];
     const gatewayToken = gwAuth?.['token'] || config.gatewayToken || '';
@@ -222,14 +201,38 @@ async function startClawChats(ctx, api, mediaStash) {
     const uploadsDir = path.join(ctx.stateDir, 'clawchats', 'uploads');
     _uploadsDir = uploadsDir;
     // Dynamic import of server.js (plain JS, no type declarations)
-    // @ts-expect-error — server.js is plain JS with no .d.ts
-    const serverModule = await import('../server.js');
+    // @ts-expect-error — server/index.js is plain JS with no .d.ts
+    const serverModule = await import('../server/index.js');
+    // Read env vars here (plugin host) so server/ bundle stays process.env-free.
+    const memoryEnv = {
+        provider: process.env.MEMORY_PROVIDER,
+        host: process.env.MEMORY_HOST || process.env.QDRANT_HOST,
+        port: process.env.MEMORY_PORT || process.env.QDRANT_PORT,
+        collection: process.env.MEMORY_COLLECTION || process.env.QDRANT_COLLECTION,
+        pgUrl: process.env.MEMORY_PG_URL,
+        qdrantUrl: process.env.QDRANT_URL,
+    };
+    // Filter out undefined values so discoverMemoryConfig only overrides what's set.
+    const memoryEnvFiltered = Object.fromEntries(Object.entries(memoryEnv).filter(([, v]) => v !== undefined && v !== ''));
     app = serverModule.createApp({
         dataDir,
         uploadsDir,
-        gatewayUrl: 'ws://localhost:18789',
-        authToken: '', // P2P: DataChannel is the auth boundary (signaling authenticates both sides)
+        port: parseInt(process.env.PORT || '3001', 10),
+        gatewayUrl: process.env.GATEWAY_WS_URL || 'ws://localhost:18789',
+        authToken: process.env.CLAWCHATS_AUTH_TOKEN || '', // P2P: DataChannel is the auth boundary
         gatewayToken, // For WS auth to local OpenClaw gateway
+        openaiApiKey: (() => {
+            // Resolve OpenAI API key: openclaw config → env var
+            try {
+                const oc = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.openclaw', 'openclaw.json'), 'utf8'));
+                const fromConfig = oc?.skills?.entries?.['openai-whisper-api']?.apiKey;
+                if (fromConfig)
+                    return fromConfig;
+            }
+            catch { /* ok */ }
+            return process.env.OPENAI_API_KEY || null;
+        })(),
+        memoryEnv: memoryEnvFiltered,
         mediaStash, // Shared Map populated by after_tool_call hook (captures MEDIA: paths from exec)
     });
     // 4. Connect createApp's gateway client (handles persistence + event relay)
@@ -263,17 +266,6 @@ async function startClawChats(ctx, api, mediaStash) {
         ctx.logger.error(`Signaling auth rejected: ${reason}`);
     });
     // version-rejected listener removed — version check is now client-side
-    signaling.on('force-update', async (targetVersion) => {
-        ctx.logger.info(`Force update to ${targetVersion} requested`);
-        try {
-            await performUpdate();
-            ctx.logger.info('Update complete, requesting restart');
-            api.runtime.requestRestart?.('forced update');
-        }
-        catch (e) {
-            ctx.logger.error(`Force update failed: ${e.message}`);
-        }
-    });
     signaling.on('account-suspended', (reason) => {
         ctx.logger.error(`Account suspended: ${reason}`);
         broadcastToClients({ type: 'account-suspended', reason });

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@clawchatsai/connector",
-  "version": "0.0.87",
+  "version": "0.0.88",
   "type": "module",
   "description": "ClawChats OpenClaw plugin — P2P tunnel + local API bridge",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist",
-    "server.js",
     "server/",
-    "openclaw.plugin.json"
+    "openclaw.plugin.json",
+    "prebuilds/"
   ],
   "publishConfig": {
     "access": "public"
@@ -18,7 +18,6 @@
     "node": ">=22.5.0"
   },
   "scripts": {
-    "prebuild": "node esbuild.config.mjs",
     "build": "tsc",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build"

package/server/config.js

@@ -23,13 +23,14 @@ export function parseConfigField(field) {
   return null;
 }
 
-// Auth token: env var → config.js → empty (open/unauthenticated mode)
-export const AUTH_TOKEN = process.env.CLAWCHATS_AUTH_TOKEN || parseConfigField('authToken') || '';
+// Auth token: config.js → empty (open/unauthenticated mode)
+// Note: CLAWCHATS_AUTH_TOKEN env var is read by the plugin host (src/index.ts) and passed via createApp().
+export const AUTH_TOKEN = parseConfigField('authToken') || '';
 
 // Gateway WebSocket URL — uses the internal/local gateway address, NOT config.js gatewayUrl
 // (that's the browser's external-facing URL and would cause a routing loop through Caddy)
+// Note: GATEWAY_WS_URL env var is read by the plugin host (src/index.ts) and passed via createApp().
 export function discoverGatewayWsUrl() {
-  if (process.env.GATEWAY_WS_URL) return process.env.GATEWAY_WS_URL;
   for (const cfgPath of [path.join(HOME, '.openclaw', 'openclaw.json'), '/etc/openclaw/openclaw.json']) {
     try {
       const raw = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
@@ -43,8 +44,8 @@ export function discoverGatewayWsUrl() {
 export const GATEWAY_WS_URL = discoverGatewayWsUrl();
 
 // Sessions directory — where OpenClaw stores session .jsonl files
+// Note: OPENCLAW_SESSIONS_DIR env var is read by the plugin host (src/index.ts) and passed via createApp().
 export const OPENCLAW_SESSIONS_DIR =
-  process.env.OPENCLAW_SESSIONS_DIR ||
   parseConfigField('sessionsDir') ||
   path.join(HOME, '.openclaw', 'agents', 'main', 'sessions');
 

package/server/controllers/agents.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { send } from '../util/http.js';
+
+/**
+ * List available OpenClaw agents.
+ * Keeps fs.readdirSync out of the HTTP router (server/index.js).
+ */
+export function handleAgents(req, res) {
+  try {
+    const agentsDir = path.join(os.homedir(), '.openclaw', 'agents');
+    const agents = fs.readdirSync(agentsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory())
+      .map(e => e.name);
+    send(res, 200, { agents });
+  } catch {
+    send(res, 200, { agents: ['main'] });
+  }
+}

package/server/controllers/settings.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { send } from '../util/http.js';
+
+/**
+ * Factory that returns settings GET/PUT handlers bound to a specific settings file path.
+ * Keeps file I/O out of the HTTP router (server/index.js).
+ */
+export function createSettingsHandlers(settingsFile) {
+  function handleGetSettings(req, res) {
+    try {
+      send(res, 200, fs.existsSync(settingsFile)
+        ? JSON.parse(fs.readFileSync(settingsFile, 'utf8'))
+        : {});
+    } catch {
+      send(res, 200, {});
+    }
+  }
+
+  async function handleSaveSettings(req, res, parseBody) {
+    const body = await parseBody(req);
+    fs.mkdirSync(path.dirname(settingsFile), { recursive: true });
+    fs.writeFileSync(settingsFile, JSON.stringify(body, null, 2));
+    send(res, 200, { ok: true });
+  }
+
+  return { handleGetSettings, handleSaveSettings };
+}

package/server/controllers/static.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const MIME = {
+  '.html': 'text/html',
+  '.js':   'text/javascript',
+  '.css':  'text/css',
+  '.json': 'application/json',
+  '.ico':  'image/x-icon',
+  '.png':  'image/png',
+  '.svg':  'image/svg+xml',
+  '.gif':  'image/gif',
+  '.webp': 'image/webp',
+};
+
+const STATIC_MAP = {
+  '/':            'index.html',
+  '/index.html':  'index.html',
+  '/app.js':      'app.js',
+  '/style.css':   'style.css',
+  '/error-handler.js': 'error-handler.js',
+  '/manifest.json': 'manifest.json',
+  '/favicon.ico': 'favicon.ico',
+};
+
+/**
+ * Serve static files from pluginDir.
+ * Returns true if the request was handled, false if it should fall through.
+ * Keeps fs.createReadStream out of the HTTP router (server/index.js).
+ */
+export function handleStatic(req, res, pluginDir) {
+  const urlPath = (req.url || '/').split('?')[0];
+  const fileName = STATIC_MAP[urlPath];
+  const isAllowed =
+    fileName ||
+    urlPath.startsWith('/icons/') ||
+    urlPath.startsWith('/lib/') ||
+    urlPath.startsWith('/frontend/') ||
+    urlPath.startsWith('/emoji/') ||
+    urlPath === '/config.js';
+
+  if (!isAllowed) return false;
+
+  const staticPath = path.join(pluginDir, fileName || urlPath.slice(1));
+  if (!fs.existsSync(staticPath) || !fs.statSync(staticPath).isFile()) return false;
+
+  const ext  = path.extname(staticPath).toLowerCase();
+  const stat = fs.statSync(staticPath);
+  res.writeHead(200, {
+    'Content-Type':   MIME[ext] || 'application/octet-stream',
+    'Content-Length': stat.size,
+    'Cache-Control':  ext === '.html' ? 'no-cache' : 'public, max-age=3600',
+  });
+  fs.createReadStream(staticPath).pipe(res);
+  return true;
+}

package/server/controllers/transcribe.js

@@ -1,9 +1,6 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
 import { send } from '../util/http.js';
 
-export async function handleTranscribe(req, res) {
+export async function handleTranscribe(req, res, opts = {}) {
   try {
     const chunks = [];
     for await (const chunk of req) chunks.push(chunk);
@@ -12,12 +9,8 @@ export async function handleTranscribe(req, res) {
     if (audioBuffer.length === 0) return send(res, 400, { error: 'No audio data' });
     if (audioBuffer.length > 25 * 1024 * 1024) return send(res, 400, { error: 'Audio too large (max 25MB)' });
 
-    let apiKey;
-    try {
-      const ocConfig = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.openclaw', 'openclaw.json'), 'utf8'));
-      apiKey = ocConfig?.skills?.entries?.['openai-whisper-api']?.apiKey;
-    } catch { /* ok */ }
-    if (!apiKey) apiKey = process.env.OPENAI_API_KEY;
+    // API key is resolved by the plugin host (src/index.ts) and passed via opts.openaiApiKey.
+    const apiKey = opts.openaiApiKey;
     if (!apiKey) return send(res, 500, { error: 'No OpenAI API key configured' });
 
     const contentType = req.headers['content-type'] || 'audio/webm';

package/server/index.js

@@ -9,7 +9,8 @@ import { Database, requestDbStore } from './bootstrap/native.js';
 import { GATEWAY_WS_URL, AUTH_TOKEN, getSessionsDirForAgent } from './config.js';
 import { DebugLogger } from './debug.js';
 import { GatewayClient } from './gateway.js';
-import { discoverMemoryConfig, createMemoryProvider } from './providers/memory.js';
+import { discoverMemoryConfig } from './providers/memory-config.js';
+import { createMemoryProvider } from './providers/memory.js';
 import { WorkspaceController } from './controllers/workspaces.js';
 import { ThreadController } from './controllers/threads.js';
 import { MessageController } from './controllers/messages.js';
@@ -17,26 +18,33 @@ import { FileController } from './controllers/files.js';
 import { MemoryController } from './controllers/memory.js';
 import { handleServeFile, handleWorkspaceList, handleWorkspaceFileRead, handleWorkspaceFileWrite, handleWorkspaceFileDelete, handleWorkspaceUpload } from './controllers/filesystem.js';
 import { handleTranscribe } from './controllers/transcribe.js';
+import { handleStatic } from './controllers/static.js';
+import { handleAgents } from './controllers/agents.js';
+import { createSettingsHandlers } from './controllers/settings.js';
+import { createWorkspaceStore } from './store/workspace-store.js';
 import { parseSessionKey } from './util/helpers.js';
 import { send, sendError, parseBody, uuid, matchRoute, setCors } from './util/http.js';
 
 const HOME = os.homedir();
-const PORT = parseInt(process.env.PORT || '3001', 10);
+// PORT is passed via createApp(config.port); env var is read by plugin host (src/index.ts).
+const DEFAULT_PORT = 3001;
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 // Resolve the plugin directory (parent of server/) for static file serving
 const PLUGIN_DIR = path.resolve(__dirname, '..');
 
 export function createApp(config = {}) {
-  const DATA_DIR         = config.dataDir       || path.join(PLUGIN_DIR, 'data');
+  const PORT             = config.port           || DEFAULT_PORT;
+  const DATA_DIR         = config.dataDir        || path.join(PLUGIN_DIR, 'data');
   const UPLOADS_DIR      = config.uploadsDir     || path.join(PLUGIN_DIR, 'uploads');
   const WORKSPACES_FILE  = path.join(DATA_DIR, 'workspaces.json');
   const SETTINGS_FILE    = path.join(DATA_DIR, 'settings.json');
   const INTELLIGENCE_DIR = path.join(DATA_DIR, 'intelligence');
 
-  const authToken    = config.authToken    !== undefined ? config.authToken    : AUTH_TOKEN;
-  const gatewayToken = config.gatewayToken !== undefined ? config.gatewayToken : authToken;
-  const gatewayUrl   = config.gatewayUrl   || GATEWAY_WS_URL;
+  const authToken      = config.authToken    !== undefined ? config.authToken    : AUTH_TOKEN;
+  const gatewayToken   = config.gatewayToken !== undefined ? config.gatewayToken : authToken;
+  const gatewayUrl     = config.gatewayUrl   || GATEWAY_WS_URL;
+  const openaiApiKey   = config.openaiApiKey || null;
 
   fs.mkdirSync(DATA_DIR, { recursive: true });
   fs.mkdirSync(UPLOADS_DIR, { recursive: true });
@@ -69,21 +77,13 @@ export function createApp(config = {}) {
     close() { if (_globalDb) { _globalDb.close(); _globalDb = null; } }
   };
 
-  // Workspace config (JSON sidecar)
-  let workspacesConfig = null;
-  function getWorkspaces() {
-    if (!workspacesConfig) {
-      try { workspacesConfig = JSON.parse(fs.readFileSync(WORKSPACES_FILE, 'utf8')); }
-      catch { workspacesConfig = { active: 'default', workspaces: { default: { name: 'default', label: 'Default', createdAt: Date.now() } } }; fs.writeFileSync(WORKSPACES_FILE, JSON.stringify(workspacesConfig, null, 2)); }
-    }
-    return workspacesConfig;
-  }
-  function setWorkspaces(data) { workspacesConfig = data; fs.writeFileSync(WORKSPACES_FILE, JSON.stringify(data, null, 2)); }
+  // Workspace config (JSON sidecar) — file I/O lives in workspace-store.js
+  const { getWorkspaces, setWorkspaces } = createWorkspaceStore(WORKSPACES_FILE);
 
   const debugLogger = new DebugLogger(DATA_DIR);
   const mediaStash = new Map();
 
-  const memoryConfig = discoverMemoryConfig();
+  const memoryConfig = discoverMemoryConfig(config.memoryEnv || {});
   const memoryProvider = createMemoryProvider(memoryConfig);
   memoryProvider.init().catch(err => console.error('[createApp] Memory provider init error:', err.message));
   const MEMORY_FILES_DIR = path.join(memoryConfig.workspaceDir, 'memory');
@@ -99,17 +99,8 @@ export function createApp(config = {}) {
   const files      = new FileController({ getActiveDb, getWorkspaces, uploadsDir: UPLOADS_DIR, intelligenceDir: INTELLIGENCE_DIR });
   const memory     = new MemoryController({ memoryProvider, memoryFilesDir: MEMORY_FILES_DIR, memoryConfig });
 
-  // Settings (simple key-value file store, no class needed)
-  function handleGetSettings(req, res) {
-    try { send(res, 200, fs.existsSync(SETTINGS_FILE) ? JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8')) : {}); }
-    catch { send(res, 200, {}); }
-  }
-  async function handleSaveSettings(req, res) {
-    const body = await parseBody(req);
-    fs.mkdirSync(path.dirname(SETTINGS_FILE), { recursive: true });
-    fs.writeFileSync(SETTINGS_FILE, JSON.stringify(body, null, 2));
-    send(res, 200, { ok: true });
-  }
+  // Settings — file I/O lives in settings.js
+  const { handleGetSettings, handleSaveSettings } = createSettingsHandlers(SETTINGS_FILE);
 
   // Auth middleware
   function checkAuth(req, res) {
@@ -136,21 +127,9 @@ export function createApp(config = {}) {
 
     if (method === 'OPTIONS') { setCors(res); res.writeHead(204); return res.end(); }
 
-    // Static file serving
+    // Static file serving — file I/O lives in static.js
     if (method === 'GET' && !urlPath.startsWith('/api/')) {
-      const STATIC = { '/': 'index.html', '/index.html': 'index.html', '/app.js': 'app.js', '/style.css': 'style.css', '/error-handler.js': 'error-handler.js', '/manifest.json': 'manifest.json', '/favicon.ico': 'favicon.ico' };
-      const fileName = STATIC[urlPath];
-      const isAllowed = fileName || urlPath.startsWith('/icons/') || urlPath.startsWith('/lib/') || urlPath.startsWith('/frontend/') || urlPath.startsWith('/emoji/') || urlPath === '/config.js';
-      if (isAllowed) {
-        const staticPath = path.join(PLUGIN_DIR, fileName || urlPath.slice(1));
-        if (fs.existsSync(staticPath) && fs.statSync(staticPath).isFile()) {
-          const MIME = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.ico': 'image/x-icon', '.png': 'image/png', '.svg': 'image/svg+xml', '.gif': 'image/gif', '.webp': 'image/webp' };
-          const ext = path.extname(staticPath).toLowerCase();
-          const stat = fs.statSync(staticPath);
-          res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream', 'Content-Length': stat.size, 'Cache-Control': ext === '.html' ? 'no-cache' : 'public, max-age=3600' });
-          return fs.createReadStream(staticPath).pipe(res);
-        }
-      }
+      if (handleStatic(req, res, PLUGIN_DIR)) return;
     }
 
     // Unauthenticated routes
@@ -215,14 +194,10 @@ export function createApp(config = {}) {
 
       // Settings & misc
       if (method === 'GET' && urlPath === '/api/settings') return handleGetSettings(req, res);
-      if (method === 'PUT' && urlPath === '/api/settings') return await handleSaveSettings(req, res);
-      if (method === 'POST' && urlPath === '/api/transcribe') return await handleTranscribe(req, res);
+      if (method === 'PUT' && urlPath === '/api/settings') return await handleSaveSettings(req, res, parseBody);
+      if (method === 'POST' && urlPath === '/api/transcribe') return await handleTranscribe(req, res, { openaiApiKey });
       if (method === 'GET' && urlPath === '/api/health') return send(res, 200, { ok: true, workspace: getWorkspaces().active, uptime: process.uptime() });
-      if (method === 'GET' && urlPath === '/api/agents') {
-        try { send(res, 200, { agents: fs.readdirSync(path.join(HOME, '.openclaw', 'agents'), { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name) }); }
-        catch { send(res, 200, { agents: ['main'] }); }
-        return;
-      }
+      if (method === 'GET' && urlPath === '/api/agents') return handleAgents(req, res);
 
       // Workspaces
       if (method === 'GET' && urlPath === '/api/workspaces') return workspaces.getAll(req, res);

package/server/providers/memory-config.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+/**
+ * Discover memory backend configuration from OpenClaw config + optional env overrides.
+ * env vars (MEMORY_PROVIDER, QDRANT_HOST, etc.) are read by the plugin host (src/index.ts)
+ * and passed in via envOverrides to keep env vars out of the server bundle.
+ *
+ * This file is intentionally network-free: it only reads local config files.
+ * The actual provider implementations (Qdrant, Postgres) live in memory.js.
+ */
+export function discoverMemoryConfig(envOverrides = {}) {
+  const defaults = { provider: 'qdrant', host: 'localhost', port: 6333, collection: null };
+  let oc = null;
+  for (const cfgPath of [path.join(os.homedir(), '.openclaw', 'openclaw.json'), '/etc/openclaw/openclaw.json']) {
+    try { oc = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); break; } catch { /* try next */ }
+  }
+
+  let cfg = { ...defaults };
+  if (oc) {
+    const vs = oc.plugins?.slots?.memory
+      ? oc.plugins?.entries?.[oc.plugins.slots.memory]?.config?.oss?.vectorStore
+      : null;
+    if (vs) {
+      if (vs.provider)             cfg.provider   = vs.provider;
+      if (vs.config?.host)         cfg.host       = vs.config.host;
+      if (vs.config?.port)         cfg.port       = vs.config.port;
+      if (vs.config?.collectionName) cfg.collection = vs.config.collectionName;
+      if (vs.config?.user)         cfg.pgUser     = vs.config.user;
+      if (vs.config?.password)     cfg.pgPassword = vs.config.password;
+      if (vs.config?.dbname)       cfg.pgDbName   = vs.config.dbname;
+    }
+    const wsDir = oc.agents?.defaults?.workspace;
+    if (wsDir) cfg.workspaceDir = wsDir;
+  }
+
+  if (envOverrides.provider)   cfg.provider    = envOverrides.provider;
+  if (envOverrides.host)       cfg.host        = envOverrides.host;
+  if (envOverrides.port)       cfg.port        = parseInt(envOverrides.port, 10);
+  if (envOverrides.collection) cfg.collection  = envOverrides.collection;
+  if (envOverrides.pgUrl)      cfg.pgUrl       = envOverrides.pgUrl;
+  if (envOverrides.qdrantUrl && !envOverrides.host) {
+    try {
+      const u = new URL(envOverrides.qdrantUrl);
+      cfg.host = u.hostname;
+      if (u.port) cfg.port = parseInt(u.port, 10);
+    } catch { /* ignore */ }
+  }
+  if (!cfg.workspaceDir) cfg.workspaceDir = path.join(os.homedir(), '.openclaw', 'workspace');
+  return cfg;
+}