@aiworker/web 1.22.0 → 1.23.0

package/server/lib/relay/tunnel-host.js

@@ -15,7 +15,6 @@ import {
   createFragmentAssembler,
   decodeJsonPayload,
   decodeTunnelFrame,
-  encodeFragmentedMessage,
   encodeJsonPayload,
   encodeTunnelFrame,
 } from './tunnel-codec.js';
@@ -33,7 +32,9 @@ const ALLOWED_WS_PATHS = new Set([
   '/api/event/ws',
   '/api/terminal/ws',
   '/api/dictation/ws',
+  '/api/dev-tunnel',
 ]);
+export const isAllowedRelayWebSocketPath = (pathname) => ALLOWED_WS_PATHS.has(pathname);
 
 // Hop-by-hop headers stripped from tunneled requests; `host` is set by fetch
 // to the loopback origin. content-length is dropped too because the body is
@@ -72,6 +73,11 @@ const BODY_BUFFER_MAX_BYTES = 512 * 1024;
 // completes, so a stalled tunnel converts into an ambiguous transport failure
 // (which the client already retries) instead of a hung loopback request.
 const BODY_DELIVERY_TIMEOUT_MS = 15_000;
+const MAX_PENDING_WS_BYTES = 16 * 1024 * 1024;
+const MAX_PENDING_WS_MESSAGES = 1024;
+// Node ws supports read backpressure. Bun's ws shim does not implement pause;
+// there the bounded queue fails the affected substream explicitly on overflow.
+const CAN_PAUSE_WS_READS = !process.versions.bun;
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -97,13 +103,17 @@ const isWsClosePayload = (parsed) => Boolean(parsed && typeof parsed === 'object
  *   sendFrame: (plaintextFrame: Uint8Array) => void | Promise<void>,
  *   getBufferedAmount: () => number,
  *   bodyDeliveryTimeoutMs?: number,
+ *   responseChunkBytes?: number,
+ *   cancelPendingFrames?: (streamId: number) => void,
  * }} deps
  */
-export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBufferedAmount, bodyDeliveryTimeoutMs = BODY_DELIVERY_TIMEOUT_MS }) => {
+export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBufferedAmount, bodyDeliveryTimeoutMs = BODY_DELIVERY_TIMEOUT_MS, responseChunkBytes = MAX_TUNNEL_PAYLOAD_BYTES, cancelPendingFrames = () => {} }) => {
   /** @type {Map<number, { kind: 'http', abort: AbortController, body: { enqueue(payload: Uint8Array): void, close(): void, error(error: Error): void } | null, noBody: boolean } | { kind: 'ws', socket: WebSocket, opened: boolean }>} */
   const streams = new Map();
   const assembler = createFragmentAssembler();
   let closed = false;
+  let pendingWsBytes = 0;
+  let pendingWsMessages = 0;
 
   const send = async (frame) => {
     if (closed) return;
@@ -126,6 +136,7 @@ export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBuf
     const stream = streams.get(streamId);
     if (!stream) return;
     dropStream(streamId);
+    cancelPendingFrames(streamId);
     if (stream.kind === 'http') {
       try {
         stream.body?.error(new Error(String(reason ?? 'aborted')));
@@ -203,17 +214,27 @@ export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBuf
       if (STRIPPED_RESPONSE_HEADERS.has(name)) continue;
       responseHeaders[name] = value;
     }
-    await sendJson(TunnelFrameType.HttpResponse, streamId, { status: response.status, headers: responseHeaders });
+    if (closed || stream.abort.signal.aborted) {
+      await response.body?.cancel();
+      return;
+    }
 
     try {
+      await sendJson(TunnelFrameType.HttpResponse, streamId, { status: response.status, headers: responseHeaders });
       if (response.body) {
         for await (const chunk of response.body) {
           if (closed || stream.abort.signal.aborted) return;
           const bytes = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
-          for (const piece of chunkPayload(bytes, MAX_TUNNEL_PAYLOAD_BYTES)) {
+          const pieces = chunkPayload(bytes, responseChunkBytes);
+          // Offer at most one plaintext-frame budget at a time. The scheduler
+          // can batch small slices and interleave streams without buffering the
+          // entire source or encrypting hundreds of tiny messages separately.
+          const groupSize = Math.max(1, Math.floor(MAX_TUNNEL_PAYLOAD_BYTES / responseChunkBytes));
+          for (let offset = 0; offset < pieces.length; offset += groupSize) {
             await waitForBackpressure(stream.abort.signal);
             if (closed || stream.abort.signal.aborted) return;
-            await send(encodeTunnelFrame(TunnelFrameType.HttpBody, streamId, piece));
+            await Promise.all(pieces.slice(offset, offset + groupSize).map(piece =>
+              send(encodeTunnelFrame(TunnelFrameType.HttpBody, streamId, piece))));
           }
         }
       }
@@ -425,7 +446,7 @@ export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBuf
       void sendAbort(streamId, error?.message ?? 'malformed ws open');
       return;
     }
-    if (!ALLOWED_WS_PATHS.has(open.path)) {
+    if (!isAllowedRelayWebSocketPath(open.path)) {
       void sendAbort(streamId, 'Path is not allowed through the relay');
       return;
     }
@@ -446,6 +467,7 @@ export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBuf
     try {
       socket = new WebSocket(url, open.protocols, {
         headers: dialHeaders,
+        maxPayload: MAX_PENDING_WS_BYTES,
       });
     } catch (error) {
       void sendAbort(streamId, error?.message ?? 'ws dial failed');
@@ -453,6 +475,8 @@ export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBuf
     }
     const stream = { kind: 'ws', socket, opened: false };
     streams.set(streamId, stream);
+    let outputChain = Promise.resolve();
+    let socketPendingMessages = 0;
 
     socket.on('open', () => {
       if (streams.get(streamId) !== stream) return;
@@ -463,23 +487,47 @@ export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBuf
       if (streams.get(streamId) !== stream || closed) return;
       const bytes = Buffer.isBuffer(data) ? new Uint8Array(data) : new Uint8Array(Buffer.concat(data));
       const frameType = isBinary ? TunnelFrameType.WsBinary : TunnelFrameType.WsText;
-      void (async () => {
-        for (const frame of encodeFragmentedMessage(frameType, streamId, bytes)) {
+      if (pendingWsBytes + bytes.length > MAX_PENDING_WS_BYTES || pendingWsMessages >= MAX_PENDING_WS_MESSAGES) {
+        abortLocalStream(streamId, 'upstream WebSocket exceeded downstream queue limit');
+        void sendAbort(streamId, 'upstream WebSocket exceeded downstream queue limit');
+        return;
+      }
+      pendingWsBytes += bytes.length;
+      pendingWsMessages += 1;
+      socketPendingMessages += 1;
+      if (CAN_PAUSE_WS_READS) socket.pause();
+      outputChain = outputChain.then(async () => {
+        // Serialize entire messages, including their fragments. A later close
+        // must also wait here or it can overtake the final output.
+        const chunks = chunkPayload(bytes, responseChunkBytes);
+        const groupSize = Math.max(1, Math.floor(MAX_TUNNEL_PAYLOAD_BYTES / responseChunkBytes));
+        for (let offset = 0; offset < chunks.length; offset += groupSize) {
           await waitForBackpressure(null);
           if (streams.get(streamId) !== stream || closed) return;
-          await send(frame);
+          await Promise.all(chunks.slice(offset, offset + groupSize).map((chunk, index) =>
+            send(encodeTunnelFrame(frameType, streamId, chunk, offset + index < chunks.length - 1))));
         }
-      })();
+      }).catch(() => {
+        abortLocalStream(streamId, 'upstream WebSocket forwarding failed');
+        void sendAbort(streamId, 'upstream WebSocket forwarding failed');
+      }).finally(() => {
+        pendingWsBytes -= bytes.length;
+        pendingWsMessages -= 1;
+        socketPendingMessages -= 1;
+        if (CAN_PAUSE_WS_READS && socketPendingMessages === 0 && streams.get(streamId) === stream && socket.readyState === WebSocket.OPEN) socket.resume();
+      });
     });
     socket.on('close', (code, reasonBuffer) => {
-      if (streams.get(streamId) !== stream) return;
-      dropStream(streamId);
-      const reason = reasonBuffer ? reasonBuffer.toString('utf8') : '';
-      if (stream.opened) {
-        void sendJson(TunnelFrameType.WsClose, streamId, { code: code || 1000, reason });
-      } else {
-        void sendAbort(streamId, reason || `upstream ws closed (${code || 'no code'})`);
-      }
+      void outputChain.then(async () => {
+        if (streams.get(streamId) !== stream) return;
+        dropStream(streamId);
+        const reason = reasonBuffer ? reasonBuffer.toString('utf8') : '';
+        if (stream.opened) {
+          await sendJson(TunnelFrameType.WsClose, streamId, { code: code || 1000, reason });
+        } else {
+          await sendAbort(streamId, reason || `upstream ws closed (${code || 'no code'})`);
+        }
+      });
     });
     socket.on('error', (error) => {
       if (streams.get(streamId) !== stream) return;
@@ -510,6 +558,7 @@ export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBuf
     const stream = streams.get(streamId);
     if (!stream || stream.kind !== 'ws') return;
     dropStream(streamId);
+    cancelPendingFrames(streamId);
     let close = { code: 1000, reason: '' };
     try {
       close = decodeJsonPayload(payload, isWsClosePayload);
@@ -518,6 +567,8 @@ export const createTunnelHost = ({ connectionId, getLocalPort, sendFrame, getBuf
     }
     const code = Number.isInteger(close.code) && close.code >= 1000 && close.code <= 4999 ? close.code : 1000;
     try {
+      // A paused receiver still needs to read the peer's close handshake.
+      if (CAN_PAUSE_WS_READS) stream.socket.resume();
       stream.socket.close(code, typeof close.reason === 'string' ? close.reason : '');
     } catch {
       stream.socket.terminate();

package/server/lib/relay/tunnel-host.test.js

@@ -1,7 +1,7 @@
 import { describe, test, expect } from 'bun:test';
 import http from 'node:http';
 
-import { createTunnelHost } from './tunnel-host.js';
+import { createTunnelHost, isAllowedRelayWebSocketPath } from './tunnel-host.js';
 import { decodeTunnelFrame, encodeTunnelFrame, encodeJsonPayload, TunnelFrameType } from './tunnel-codec.js';
 
 const startLoopback = () =>
@@ -145,3 +145,11 @@ describe('tunnel-host HTTP body forwarding', () => {
     await loopback.stop();
   });
 });
+
+describe('relay host WebSocket allowlist', () => {
+  test('allows only the exact dev-server tunnel path', () => {
+    expect(isAllowedRelayWebSocketPath('/api/dev-tunnel')).toBe(true);
+    expect(isAllowedRelayWebSocketPath('/api/dev-tunnel/')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/database/ws')).toBe(false);
+  });
+});

package/server/lib/scheduled-tasks/issue-2710-double-execution.test.js

@@ -1,10 +1,10 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
 
 /**
- * Regression for https://github.com/openchamber/openchamber/issues/2710
+ * Regression for https://roweb.cn/roweb/openchamber/issues/2710
  * "Scheduled daily task executes twice at the configured time"
  *
- * Root cause: each OpenChamber server process keeps its own timers. Two
+ * Root cause: each AiWorker server process keeps its own timers. Two
  * instances that share the same on-disk project config (CLI serve on port 3000
  * + Electron on 57123, or a startup login service + desktop) each arm a timer
  * for the same occurrence and both dispatch.

package/server/lib/scheduled-tasks/routes.js

@@ -15,7 +15,7 @@ export const registerScheduledTaskRoutes = (app, dependencies) => {
     sanitizeProjects,
     projectConfigRuntime,
     scheduledTasksRuntime,
-    getOpenChamberEventClients,
+    getAiWorkerEventClients,
     writeSseEvent,
     scheduledTaskService = createScheduledTaskService(dependencies),
   } = dependencies;
@@ -149,14 +149,14 @@ export const registerScheduledTaskRoutes = (app, dependencies) => {
     // not of this server: a desktop shell and a browser tab can be connected to
     // the same server at once. Recording it on the connection keeps the answer
     // current without any enable/disable setting to go stale.
-    res.openchamberBrowserCapable = req.query?.browser === '1';
+    res.aiworkerBrowserCapable = req.query?.browser === '1';
 
-    const clients = getOpenChamberEventClients();
+    const clients = getAiWorkerEventClients();
     clients.add(res);
 
     try {
       writeSseEvent(res, {
-        type: 'openchamber:event-stream-ready',
+        type: 'aiworker:event-stream-ready',
         properties: {
           connectedAt: Date.now(),
         },
@@ -167,7 +167,7 @@ export const registerScheduledTaskRoutes = (app, dependencies) => {
     const heartbeat = setInterval(() => {
       try {
         writeSseEvent(res, {
-          type: 'openchamber:heartbeat',
+          type: 'aiworker:heartbeat',
           properties: {
             timestamp: Date.now(),
           },

package/server/lib/scheduled-tasks/service.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { OpenChamberControlError } from '../openchamber-control/error.js';
+import { AiWorkerControlError } from '../openchamber-control/error.js';
 import { setLoopFileEnabled } from './loops.js';
 
 const asNonEmptyString = (value) => {
@@ -24,10 +24,10 @@ export const createScheduledTaskService = (dependencies) => {
 
   const findProjectByID = async (projectID) => {
     const normalized = asNonEmptyString(projectID);
-    if (!normalized) throw new OpenChamberControlError('projectId is required', 400);
+    if (!normalized) throw new AiWorkerControlError('projectId is required', 400);
     const projects = await listProjects();
     const project = projects.find((entry) => entry.id === normalized) || null;
-    if (!project) throw new OpenChamberControlError('Project not found', 404);
+    if (!project) throw new AiWorkerControlError('Project not found', 404);
     return project;
   };
 
@@ -35,17 +35,17 @@ export const createScheduledTaskService = (dependencies) => {
     const requestedProjectID = asNonEmptyString(projectId);
     const requestedDirectory = asNonEmptyString(directory);
     if (requestedProjectID && requestedDirectory) {
-      throw new OpenChamberControlError('Provide only one of projectId or directory', 400);
+      throw new AiWorkerControlError('Provide only one of projectId or directory', 400);
     }
     if (requestedProjectID) {
       await findProjectByID(requestedProjectID);
       return requestedProjectID;
     }
-    if (!requestedDirectory) throw new OpenChamberControlError('projectId or directory is required', 400);
+    if (!requestedDirectory) throw new AiWorkerControlError('projectId or directory is required', 400);
     const resolvedDirectory = path.resolve(requestedDirectory);
     const projects = await listProjects();
     const project = projects.find((entry) => path.resolve(entry.path) === resolvedDirectory);
-    if (!project) throw new OpenChamberControlError(`Project not found for directory: ${resolvedDirectory}`, 404);
+    if (!project) throw new AiWorkerControlError(`Project not found for directory: ${resolvedDirectory}`, 404);
     return project.id;
   };
 
@@ -57,28 +57,28 @@ export const createScheduledTaskService = (dependencies) => {
   const findLoopTask = async (projectID, taskID) => {
     await findProjectByID(projectID);
     const normalizedTaskID = asNonEmptyString(taskID);
-    if (!normalizedTaskID) throw new OpenChamberControlError('taskId is required', 400);
+    if (!normalizedTaskID) throw new AiWorkerControlError('taskId is required', 400);
     const tasks = await scheduledTasksRuntime.syncProject(projectID);
     const task = tasks.find((entry) => entry?.id === normalizedTaskID) || null;
-    if (!task) throw new OpenChamberControlError('Task not found', 404);
-    if (!task.loopFile) throw new OpenChamberControlError('Task is not managed by a loop file', 400);
-    if (!fs.existsSync(task.loopFile)) throw new OpenChamberControlError('Loop file not found', 404);
+    if (!task) throw new AiWorkerControlError('Task not found', 404);
+    if (!task.loopFile) throw new AiWorkerControlError('Task is not managed by a loop file', 400);
+    if (!fs.existsSync(task.loopFile)) throw new AiWorkerControlError('Loop file not found', 404);
     return task;
   };
 
   const setLoopEnabled = async (projectID, taskID, enabled) => {
     if (typeof enabled !== 'boolean') {
-      throw new OpenChamberControlError('enabled must be a boolean', 400);
+      throw new AiWorkerControlError('enabled must be a boolean', 400);
     }
     const task = await findLoopTask(projectID, taskID);
     try {
       if (!setLoopFileEnabled(task.loopFile, enabled)) {
-        throw new OpenChamberControlError('Loop file must be valid before changing its enabled state', 400);
+        throw new AiWorkerControlError('Loop file must be valid before changing its enabled state', 400);
       }
     } catch (error) {
-      if (error instanceof OpenChamberControlError) throw error;
+      if (error instanceof AiWorkerControlError) throw error;
       const message = error instanceof Error ? error.message : 'Failed to update loop file';
-      throw new OpenChamberControlError(message, 500);
+      throw new AiWorkerControlError(message, 500);
     }
     const tasks = await scheduledTasksRuntime.syncProject(projectID);
     return tasks.find((entry) => entry.id === taskID) || null;
@@ -90,7 +90,7 @@ export const createScheduledTaskService = (dependencies) => {
       fs.unlinkSync(task.loopFile);
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Failed to delete loop file';
-      throw new OpenChamberControlError(message, 500);
+      throw new AiWorkerControlError(message, 500);
     }
     return scheduledTasksRuntime.syncProject(projectID);
   };
@@ -98,7 +98,7 @@ export const createScheduledTaskService = (dependencies) => {
   const upsert = async (projectID, taskInput) => {
     await findProjectByID(projectID);
     if (!taskInput || typeof taskInput !== 'object') {
-      throw new OpenChamberControlError('task payload is required', 400);
+      throw new AiWorkerControlError('task payload is required', 400);
     }
     let upserted;
     try {
@@ -106,7 +106,7 @@ export const createScheduledTaskService = (dependencies) => {
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Failed to save scheduled task';
       const invalid = message.toLowerCase().includes('required') || message.toLowerCase().includes('invalid');
-      throw new OpenChamberControlError(message, invalid ? 400 : 500);
+      throw new AiWorkerControlError(message, invalid ? 400 : 500);
     }
     await scheduledTasksRuntime.syncProject(projectID);
     const tasks = await projectConfigRuntime.listScheduledTasks(projectID);
@@ -120,7 +120,7 @@ export const createScheduledTaskService = (dependencies) => {
   const remove = async (projectID, taskID) => {
     await findProjectByID(projectID);
     const normalizedTaskID = asNonEmptyString(taskID);
-    if (!normalizedTaskID) throw new OpenChamberControlError('taskId is required', 400);
+    if (!normalizedTaskID) throw new AiWorkerControlError('taskId is required', 400);
     const current = await projectConfigRuntime.listScheduledTasks(projectID);
     const existing = current.find((task) => task.id === normalizedTaskID) || null;
     if (existing?.loopFile && fs.existsSync(existing.loopFile)) {
@@ -129,13 +129,13 @@ export const createScheduledTaskService = (dependencies) => {
       // file exists. The file itself is the removal surface. Once the file is
       // gone (the task is an orphan that the next sync would remove anyway),
       // deleting the row is safe and allowed.
-      throw new OpenChamberControlError(
+      throw new AiWorkerControlError(
         'Loop task is managed by its .agents/loops markdown file; delete the file to remove the task',
         400,
       );
     }
     const result = await projectConfigRuntime.deleteScheduledTask(projectID, normalizedTaskID);
-    if (!result.deleted) throw new OpenChamberControlError('Task not found', 404);
+    if (!result.deleted) throw new AiWorkerControlError('Task not found', 404);
     await scheduledTasksRuntime.syncProject(projectID);
     return projectConfigRuntime.listScheduledTasks(projectID);
   };
@@ -143,14 +143,14 @@ export const createScheduledTaskService = (dependencies) => {
   const run = async (projectID, taskID) => {
     await findProjectByID(projectID);
     const normalizedTaskID = asNonEmptyString(taskID);
-    if (!normalizedTaskID) throw new OpenChamberControlError('taskId is required', 400);
+    if (!normalizedTaskID) throw new AiWorkerControlError('taskId is required', 400);
     const result = await scheduledTasksRuntime.runNow(projectID, normalizedTaskID);
     if (result.running || result.queued) {
-      throw new OpenChamberControlError(result.error || 'Task already running', 409);
+      throw new AiWorkerControlError(result.error || 'Task already running', 409);
     }
-    if (result.skipped) throw new OpenChamberControlError('Task not found or disabled', 404);
+    if (result.skipped) throw new AiWorkerControlError('Task not found or disabled', 404);
     if (!result.ok) {
-      throw new OpenChamberControlError(result.error || 'Task run failed', 500, { task: result.task });
+      throw new AiWorkerControlError(result.error || 'Task run failed', 500, { task: result.task });
     }
     return {
       task: result.task,
@@ -164,7 +164,7 @@ export const createScheduledTaskService = (dependencies) => {
   const setEnabled = async (projectID, taskID, enabled) => {
     const tasks = await list(projectID);
     const task = tasks.find((entry) => entry?.id === taskID);
-    if (!task) throw new OpenChamberControlError('Task not found', 404);
+    if (!task) throw new AiWorkerControlError('Task not found', 404);
     const result = await upsert(projectID, { ...task, enabled });
     return result.task;
   };

package/server/lib/scheduled-tasks/service.test.js

@@ -166,7 +166,7 @@ describe('scheduled-task loop-file routes', () => {
       sanitizeProjects: vi.fn(),
       projectConfigRuntime: {},
       scheduledTasksRuntime: {},
-      getOpenChamberEventClients: () => new Set(),
+      getAiWorkerEventClients: () => new Set(),
       writeSseEvent: vi.fn(),
     });
     return handlers;

package/server/lib/security/bind-host.js

@@ -32,9 +32,9 @@ export const isLoopbackBindHost = (host) => {
 export const isNetworkExposedBindHost = (host) => !isLoopbackBindHost(host);
 
 export const isUnsafeUnauthenticatedLanAllowed = (env = process.env) =>
-  env?.OPENCHAMBER_ALLOW_UNAUTHENTICATED_LAN === 'true';
+  env?.AIWORKER_ALLOW_UNAUTHENTICATED_LAN === 'true';
 
 export const getUnauthenticatedLanErrorMessage = (host) =>
-  `OpenChamber refuses to bind to ${host || 'a network-exposed host'} without UI authentication. `
-  + 'Set --ui-password or OPENCHAMBER_UI_PASSWORD before exposing it over LAN, '
-  + 'or set OPENCHAMBER_ALLOW_UNAUTHENTICATED_LAN=true to accept the risk.';
+  `AiWorker refuses to bind to ${host || 'a network-exposed host'} without UI authentication. `
+  + 'Set --ui-password or AIWORKER_UI_PASSWORD before exposing it over LAN, '
+  + 'or set AIWORKER_ALLOW_UNAUTHENTICATED_LAN=true to accept the risk.';

package/server/lib/security/bind-host.test.js

@@ -25,7 +25,7 @@ describe('bind host exposure classification', () => {
       '::ffff:192.168.1.10',
       'fe80::1',
       'fc00::1',
-      'openchamber.local',
+      'aiworker.local',
       'example.com',
       '',
     ]) {

package/server/lib/security/request-security.js

@@ -103,7 +103,7 @@ export const createRequestSecurityRuntime = (deps) => {
     return { origins, hosts };
   };
 
-  const isRequestOriginAllowed = async (req) => {
+  const isRequestOriginAllowed = (req) => {
     const originHeader = typeof req.headers.origin === 'string' ? req.headers.origin.trim() : '';
     if (!originHeader) {
       return false;
@@ -120,15 +120,21 @@ export const createRequestSecurityRuntime = (deps) => {
       return false;
     }
 
-    const candidates = await getRequestOriginCandidates(req);
-    if (candidates.origins.has(origin.origin)) return true;
+    const forwardedHostHeader = req.headers['x-forwarded-host'];
+    const forwardedHost = (Array.isArray(forwardedHostHeader) ? forwardedHostHeader[0] : forwardedHostHeader || '')
+      .split(',')[0].trim().toLowerCase();
+    const hostHeader = req.headers.host;
+    const host = forwardedHost || (Array.isArray(hostHeader) ? hostHeader[0] : hostHeader || '').trim().toLowerCase();
+    if (host && host === origin.host.toLowerCase()) return true;
 
-    // TLS commonly ends at a cloud edge before an HTTP hop to OpenChamber.
+    // TLS commonly ends at a cloud edge before an HTTP hop to AiWorker.
     // In that setup the browser's Origin is https while a generic reverse
     // proxy reports the upstream request as http. The external host remains
     // authoritative, so compare it directly instead of requiring the proxy to
     // preserve the browser-facing protocol.
-    return candidates.hosts.has(origin.host.toLowerCase());
+    return getRequestOriginCandidates(req).then((candidates) => (
+      candidates.origins.has(origin.origin) || candidates.hosts.has(origin.host.toLowerCase())
+    ));
   };
 
   return {

package/server/lib/security/request-security.test.js

@@ -9,55 +9,55 @@ describe('request security runtime', () => {
   test('allows packaged client origins for remote client transports', async () => {
     const runtime = createRuntime();
 
-    await expect(runtime.isRequestOriginAllowed({
+    expect(await runtime.isRequestOriginAllowed({
       headers: {
         origin: 'openchamber-ui://app',
         host: '192.168.1.130:1202',
       },
       socket: {},
-    })).resolves.toBe(true);
+    })).toBe(true);
 
-    await expect(runtime.isRequestOriginAllowed({
+    expect(await runtime.isRequestOriginAllowed({
       headers: {
         origin: 'capacitor://localhost',
         host: '192.168.1.130:1202',
       },
       socket: {},
-    })).resolves.toBe(true);
+    })).toBe(true);
 
     // Android Capacitor WebView (androidScheme 'https') reports this origin.
-    await expect(runtime.isRequestOriginAllowed({
+    expect(await runtime.isRequestOriginAllowed({
       headers: {
         origin: 'https://localhost',
         host: '192.168.1.130:1202',
       },
       socket: {},
-    })).resolves.toBe(true);
+    })).toBe(true);
   });
 
   test('rejects unknown origins', async () => {
     const runtime = createRuntime();
 
-    await expect(runtime.isRequestOriginAllowed({
+    expect(await runtime.isRequestOriginAllowed({
       headers: {
         origin: 'https://evil.example.com',
         host: '192.168.1.130:1202',
       },
       socket: {},
-    })).resolves.toBe(false);
+    })).toBe(false);
   });
 
   test('allows the external host when TLS terminates before an HTTP proxy hop', async () => {
     const runtime = createRuntime();
 
-    await expect(runtime.isRequestOriginAllowed({
+    expect(await runtime.isRequestOriginAllowed({
       headers: {
         origin: 'https://devchamber.example.com',
         host: 'devchamber.example.com',
         'x-forwarded-proto': 'http',
       },
       socket: {},
-    })).resolves.toBe(true);
+    })).toBe(true);
   });
 
   test('uses the forwarded external host without trusting a different origin', async () => {
@@ -71,13 +71,13 @@ describe('request security runtime', () => {
       socket: {},
     };
 
-    await expect(runtime.isRequestOriginAllowed({
+    expect(await runtime.isRequestOriginAllowed({
       ...request,
       headers: { ...request.headers, origin: 'https://devchamber.example.com' },
-    })).resolves.toBe(true);
-    await expect(runtime.isRequestOriginAllowed({
+    })).toBe(true);
+    expect(await runtime.isRequestOriginAllowed({
       ...request,
       headers: { ...request.headers, origin: 'https://evil.example.com' },
-    })).resolves.toBe(false);
+    })).toBe(false);
   });
 });

package/server/lib/session-assist/runtime.js

@@ -1,7 +1,7 @@
 // Session assist: after a session goes idle and stays quiet, generate a short
 // recap of the agent's last reply plus one suggested user follow-up with the
 // small model, and store both on the session's metadata
-// (metadata.openchamber.assist). Clients decide visibility from
+// (metadata.aiworker.assist). Clients decide visibility from
 // assist.forMessageID — a new message makes the payload stale everywhere
 // without any extra writes.
 //
@@ -11,11 +11,12 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { readMergedSettingsSync } from '../opencode/settings-files.js';
 
-const OPENCHAMBER_SETTINGS_FILE = path.join(
-  process.env.OPENCHAMBER_DATA_DIR
-    ? path.resolve(process.env.OPENCHAMBER_DATA_DIR)
-    : path.join(os.homedir(), '.config', 'openchamber'),
+const AIWORKER_SETTINGS_FILE = path.join(
+  process.env.AIWORKER_DATA_DIR
+    ? path.resolve(process.env.AIWORKER_DATA_DIR)
+    : path.join(os.homedir(), '.config', 'aiworker'),
   'settings.json',
 );
 
@@ -23,16 +24,11 @@ const OPENCHAMBER_SETTINGS_FILE = path.join(
 // off, no small-model calls and no metadata writes happen at all. Existing
 // payloads stay untouched — clients keep showing them and dismissal still works.
 const getSessionAssistTargets = () => {
-  try {
-    const raw = fs.readFileSync(OPENCHAMBER_SETTINGS_FILE, 'utf8');
-    const settings = JSON.parse(raw);
-    return {
-      recap: settings?.sessionRecapEnabled !== false,
-      suggestion: settings?.sessionSuggestionEnabled !== false,
-    };
-  } catch {
-    return { recap: true, suggestion: true };
-  }
+  const settings = readMergedSettingsSync({ fs, path, settingsFilePath: AIWORKER_SETTINGS_FILE });
+  return {
+    recap: settings.sessionRecapEnabled !== false,
+    suggestion: settings.sessionSuggestionEnabled !== false,
+  };
 };
 
 const IDLE_QUIET_MS = 60_000;
@@ -257,6 +253,7 @@ export const createSessionAssistRuntime = ({
         prompt: `The latest exchange in the conversation:\n\n${transcript}\n\nWrite ${requestedFields} in the SAME language as this sample from the conversation: "${languageSample}"`,
         system: buildAssistSystemPrompt(targets),
         directory,
+        sessionID: sessionId,
         preferredProviderID: typeof lastAssistantInfo.providerID === 'string' ? lastAssistantInfo.providerID : undefined,
         preferredModelID: typeof lastAssistantInfo.modelID === 'string' ? lastAssistantInfo.modelID : undefined,
       });
@@ -316,8 +313,8 @@ export const createSessionAssistRuntime = ({
     const currentMetadata = freshSession?.metadata && typeof freshSession.metadata === 'object'
       ? freshSession.metadata
       : (session.metadata && typeof session.metadata === 'object' ? session.metadata : {});
-    const currentNamespace = currentMetadata.openchamber && typeof currentMetadata.openchamber === 'object'
-      ? currentMetadata.openchamber
+    const currentNamespace = currentMetadata.aiworker && typeof currentMetadata.aiworker === 'object'
+      ? currentMetadata.aiworker
       : {};
 
     console.log(`[session-assist] generated for ${sessionId} via ${generated.providerID}/${generated.modelID}`);
@@ -327,7 +324,7 @@ export const createSessionAssistRuntime = ({
       body: {
         metadata: {
           ...currentMetadata,
-          openchamber: {
+          aiworker: {
             ...currentNamespace,
             assist: {
               recap,