@aiworker/web 1.22.0 → 1.22.2

package/server/lib/notifications/push-runtime.js

@@ -305,16 +305,16 @@ export const createPushRuntime = (deps) => {
   };
 
   const resolveVapidSubject = async () => {
-    const configured = process.env.OPENCHAMBER_VAPID_SUBJECT;
+    const configured = process.env.AIWORKER_VAPID_SUBJECT;
     if (typeof configured === 'string' && configured.trim().length > 0) {
       return configured.trim();
     }
 
-    const originEnv = process.env.OPENCHAMBER_PUBLIC_ORIGIN;
+    const originEnv = process.env.AIWORKER_PUBLIC_ORIGIN;
     if (typeof originEnv === 'string' && originEnv.trim().length > 0) {
       const trimmed = originEnv.trim();
       if (isLoopbackHttpOrigin(trimmed)) {
-        return 'mailto:openchamber@localhost';
+        return 'mailto:aiworker@localhost';
       }
       return trimmed;
     }
@@ -325,14 +325,14 @@ export const createPushRuntime = (deps) => {
       if (typeof stored === 'string' && stored.trim().length > 0) {
         const trimmed = stored.trim();
         if (isLoopbackHttpOrigin(trimmed)) {
-          return 'mailto:openchamber@localhost';
+          return 'mailto:aiworker@localhost';
         }
         return trimmed;
       }
     } catch {
     }
 
-    return 'mailto:openchamber@localhost';
+    return 'mailto:aiworker@localhost';
   };
 
   const ensurePushInitialized = async () => {
@@ -340,8 +340,8 @@ export const createPushRuntime = (deps) => {
     const keys = await getOrCreateVapidKeys();
     const subject = await resolveVapidSubject();
 
-    if (subject === 'mailto:openchamber@localhost') {
-      console.warn('[Push] No public origin configured for VAPID; set OPENCHAMBER_VAPID_SUBJECT or enable push once from a real origin.');
+    if (subject === 'mailto:aiworker@localhost') {
+      console.warn('[Push] No public origin configured for VAPID; set AIWORKER_VAPID_SUBJECT or enable push once from a real origin.');
     }
 
     webPush.setVapidDetails(subject, keys.publicKey, keys.privateKey);

package/server/lib/notifications/routes.js

@@ -272,7 +272,7 @@ export const registerNotificationRoutes = (app, dependencies) => {
 
     try {
       writeSseEvent(res, {
-        type: 'openchamber:notification-stream-ready',
+        type: 'aiworker:notification-stream-ready',
         properties: { uiToken },
       });
       flushSse();

package/server/lib/notifications/runtime.js

@@ -293,7 +293,7 @@ export const createNotificationTriggerRuntime = (deps) => {
       });
       if (!response.ok) return false;
       const session = await response.json().catch(() => null);
-      const goal = session?.metadata?.openchamber?.goal;
+      const goal = session?.metadata?.aiworker?.goal;
       return Boolean(goal && typeof goal === 'object' && goal.status === 'active');
     } catch {
       return false;

package/server/lib/openchamber-control/action-resolution.test.js

@@ -4,28 +4,28 @@ import { resolveAgentToolAction } from './actions.js';
 
 /**
  * Both cases here are from one real conversation: the model called `read` and
- * then `get` on `openchamber_memory`, having dropped the namespace its own tool
+ * then `get` on `aiworker_memory`, having dropped the namespace its own tool
  * name appeared to supply, and gave up after the second bare "unsupported".
  */
 describe('a namespace the tool name already implies', () => {
   test('resolves a bare action inside the calling tool', () => {
-    expect(resolveAgentToolAction('read', 'openchamber_memory')).toEqual({ action: 'memory.read' });
-    expect(resolveAgentToolAction('save', 'openchamber_memory')).toEqual({ action: 'memory.save' });
+    expect(resolveAgentToolAction('read', 'aiworker_memory')).toEqual({ action: 'memory.read' });
+    expect(resolveAgentToolAction('save', 'aiworker_memory')).toEqual({ action: 'memory.save' });
   });
 
   test('resolves a bare name that is ambiguous only across tools', () => {
     // `delete` belongs to schedule and to memory; inside one tool it is plain.
-    expect(resolveAgentToolAction('delete', 'openchamber_memory')).toEqual({ action: 'memory.delete' });
-    expect(resolveAgentToolAction('delete', 'openchamber')).toEqual({ action: 'schedule.delete' });
+    expect(resolveAgentToolAction('delete', 'aiworker_memory')).toEqual({ action: 'memory.delete' });
+    expect(resolveAgentToolAction('delete', 'aiworker')).toEqual({ action: 'schedule.delete' });
   });
 
   test('keeps a fully qualified action as it is', () => {
-    expect(resolveAgentToolAction('memory.read', 'openchamber_memory')).toEqual({ action: 'memory.read' });
+    expect(resolveAgentToolAction('memory.read', 'aiworker_memory')).toEqual({ action: 'memory.read' });
   });
 
   test('does not reach outside the tool that asked', () => {
     // The memory tool asking for `open` must fail, not drive the browser.
-    expect(resolveAgentToolAction('open', 'openchamber_memory').action).toBeUndefined();
+    expect(resolveAgentToolAction('open', 'aiworker_memory').action).toBeUndefined();
   });
 });
 
@@ -41,7 +41,7 @@ describe('an unidentified caller', () => {
 
 describe('what an unresolvable action reports', () => {
   test('names the actions the calling tool actually has', () => {
-    const { error } = resolveAgentToolAction('get', 'openchamber_memory');
+    const { error } = resolveAgentToolAction('get', 'aiworker_memory');
 
     expect(error).toContain('memory.read');
     expect(error).toContain('memory.save');
@@ -50,14 +50,14 @@ describe('what an unresolvable action reports', () => {
   });
 
   test('reports a missing action rather than resolving to something', () => {
-    const { error, action } = resolveAgentToolAction('', 'openchamber_memory');
+    const { error, action } = resolveAgentToolAction('', 'aiworker_memory');
 
     expect(action).toBeUndefined();
     expect(error).toContain('missing');
   });
 
   test('an unknown tool falls back to the full action list', () => {
-    const { error } = resolveAgentToolAction('nonsense', 'openchamber_future');
+    const { error } = resolveAgentToolAction('nonsense', 'aiworker_future');
 
     expect(error).toContain('memory.read');
     expect(error).toContain('browser.open');

package/server/lib/openchamber-control/actions.js

@@ -7,7 +7,7 @@
  * removes it entirely, parameters included, rather than leaving its inputs
  * visible in a shared schema.
  */
-export const OPENCHAMBER_CONTROL_ACTION_DEFINITIONS = Object.freeze([
+export const AIWORKER_CONTROL_ACTION_DEFINITIONS = Object.freeze([
   { action: 'projects.list', title: 'List configured projects', description: 'List configured projects; no parameters' },
   { action: 'models.list', title: 'Show model preferences', description: 'Show default, favorite, and recent model preferences; no parameters' },
   { action: 'session.list', title: 'List sessions', description: 'List sessions; optional directory, limit (default 10), all, or withStatus' },
@@ -24,19 +24,19 @@ export const OPENCHAMBER_CONTROL_ACTION_DEFINITIONS = Object.freeze([
   { action: 'schedule.toggle', title: 'Enable or disable a scheduled task', description: 'Enable or disable taskId; requires the disabled boolean' },
 ]);
 
-const OPENCHAMBER_CONTROL_ACTIONS = Object.freeze(
-  OPENCHAMBER_CONTROL_ACTION_DEFINITIONS.map(({ action }) => action),
+const AIWORKER_CONTROL_ACTIONS = Object.freeze(
+  AIWORKER_CONTROL_ACTION_DEFINITIONS.map(({ action }) => action),
 );
 
-export const OPENCHAMBER_AGENT_TOOL_ACTION_DEFINITIONS = Object.freeze(
-  OPENCHAMBER_CONTROL_ACTION_DEFINITIONS.filter(({ agentExposed }) => agentExposed !== false),
+export const AIWORKER_AGENT_TOOL_ACTION_DEFINITIONS = Object.freeze(
+  AIWORKER_CONTROL_ACTION_DEFINITIONS.filter(({ agentExposed }) => agentExposed !== false),
 );
 
-export const OPENCHAMBER_AGENT_TOOL_ACTIONS = Object.freeze(
-  OPENCHAMBER_AGENT_TOOL_ACTION_DEFINITIONS.map(({ action }) => action),
+export const AIWORKER_AGENT_TOOL_ACTIONS = Object.freeze(
+  AIWORKER_AGENT_TOOL_ACTION_DEFINITIONS.map(({ action }) => action),
 );
 
-export const OPENCHAMBER_WEB_ACTION_DEFINITIONS = Object.freeze([
+export const AIWORKER_WEB_ACTION_DEFINITIONS = Object.freeze([
   { action: 'browser.open', title: 'Open a page in the browser panel', description: 'Open url in the in-app browser panel; use it to look at the running app. Set viewport to mobile, tablet or desktop to lay the page out at that size' },
   { action: 'browser.snapshot', title: 'Read the open page', description: 'Read the open page: url, title, visible text, and interactive elements with the selectors the other browser actions accept. Pass selector to read only that part of a long page. Reports any errors the page logged' },
   { action: 'browser.click', title: 'Click on the open page', description: 'Click an element; give selector, or text to match a link or button by its visible label' },
@@ -49,8 +49,8 @@ export const OPENCHAMBER_WEB_ACTION_DEFINITIONS = Object.freeze([
   { action: 'browser.resize', title: 'Change the page viewport', description: 'Lay the open page out at a different size; viewport is mobile, tablet, desktop, or fill to use the whole panel' },
 ]);
 
-export const OPENCHAMBER_WEB_ACTIONS = Object.freeze(
-  OPENCHAMBER_WEB_ACTION_DEFINITIONS.map(({ action }) => action),
+export const AIWORKER_WEB_ACTIONS = Object.freeze(
+  AIWORKER_WEB_ACTION_DEFINITIONS.map(({ action }) => action),
 );
 
 /**
@@ -64,31 +64,31 @@ export const OPENCHAMBER_WEB_ACTIONS = Object.freeze(
  * listing everything again — and toward reading it at all, since a title that
  * reads as a complete fact is exactly the one whose conditions get lost.
  */
-export const OPENCHAMBER_MEMORY_ACTION_DEFINITIONS = Object.freeze([
+export const AIWORKER_MEMORY_ACTION_DEFINITIONS = Object.freeze([
   { action: 'memory.read', title: 'Read a stored memory', description: 'Read the full text of one memory listed in the session index. The index shows titles only, and a title omits the conditions that decide how the memory applies, so read before acting rather than working from the title. Requires title (as the index spells it) or memoryId; scope is optional and both stores are searched without it' },
   { action: 'memory.list', title: 'List stored memories', description: 'List stored memory titles when the session index is missing or stale; scope is global, project, or both (default)' },
   { action: 'memory.save', title: 'Remember something', description: 'Store a durable fact, preference, or reference; requires title and body, plus scope global (about the user) or project (about this codebase). Restating something already stored updates it. Do not store secrets, one-off task state, or anything the user asked you not to keep' },
   { action: 'memory.delete', title: 'Forget a memory', description: 'Delete a memory that turned out to be wrong or obsolete; requires memoryId and scope' },
 ]);
 
-export const OPENCHAMBER_MEMORY_ACTIONS = Object.freeze(
-  OPENCHAMBER_MEMORY_ACTION_DEFINITIONS.map(({ action }) => action),
+export const AIWORKER_MEMORY_ACTIONS = Object.freeze(
+  AIWORKER_MEMORY_ACTION_DEFINITIONS.map(({ action }) => action),
 );
 
 /**
  * Which actions each managed tool may ask for.
  *
  * The callback needs this because models routinely drop the namespace: asked
- * for `memory.read` from a tool already called `openchamber_memory`, they send
+ * for `memory.read` from a tool already called `aiworker_memory`, they send
  * `read`, since the tool's own name appears to have said "memory" already. The
  * name is unambiguous inside one tool's action set even when it is not across
  * all of them (`delete` belongs to both schedule and memory), so resolution
  * starts from the tool that asked.
  */
 const ACTIONS_BY_TOOL = Object.freeze({
-  openchamber: OPENCHAMBER_AGENT_TOOL_ACTIONS,
-  openchamber_web: OPENCHAMBER_WEB_ACTIONS,
-  openchamber_memory: OPENCHAMBER_MEMORY_ACTIONS,
+  aiworker: AIWORKER_AGENT_TOOL_ACTIONS,
+  aiworker_web: AIWORKER_WEB_ACTIONS,
+  aiworker_memory: AIWORKER_MEMORY_ACTIONS,
 });
 
 const bareName = (action) => {
@@ -110,7 +110,7 @@ const uniqueMatch = (candidates, requested) => {
 export const resolveAgentToolAction = (requested, toolName) => {
   const value = typeof requested === 'string' ? requested.trim() : '';
   const scoped = ACTIONS_BY_TOOL[toolName] ?? null;
-  const known = scoped ?? OPENCHAMBER_ALL_ACTIONS;
+  const known = scoped ?? AIWORKER_ALL_ACTIONS;
 
   if (value && known.includes(value)) {
     return { action: value };
@@ -119,20 +119,20 @@ export const resolveAgentToolAction = (requested, toolName) => {
     const resolved = uniqueMatch(known, value)
       // A tool that did not identify itself still gets the benefit when the
       // bare name means only one thing across every action.
-      ?? (scoped ? null : uniqueMatch(OPENCHAMBER_ALL_ACTIONS, value));
+      ?? (scoped ? null : uniqueMatch(AIWORKER_ALL_ACTIONS, value));
     if (resolved) {
       return { action: resolved };
     }
   }
 
   return {
-    error: `Unsupported OpenChamber action: ${value || 'missing'}. Use one of: ${known.join(', ')}`,
+    error: `Unsupported AiWorker action: ${value || 'missing'}. Use one of: ${known.join(', ')}`,
   };
 };
 
 /** Everything the callback route will dispatch, whichever tool asked. */
-export const OPENCHAMBER_ALL_ACTIONS = Object.freeze([
-  ...OPENCHAMBER_CONTROL_ACTIONS,
-  ...OPENCHAMBER_WEB_ACTIONS,
-  ...OPENCHAMBER_MEMORY_ACTIONS,
+export const AIWORKER_ALL_ACTIONS = Object.freeze([
+  ...AIWORKER_CONTROL_ACTIONS,
+  ...AIWORKER_WEB_ACTIONS,
+  ...AIWORKER_MEMORY_ACTIONS,
 ]);

package/server/lib/openchamber-control/error.js

@@ -1,16 +1,16 @@
-export class OpenChamberControlError extends Error {
+export class AiWorkerControlError extends Error {
   constructor(message, statusCode = 500, details = {}) {
     super(message);
-    this.name = 'OpenChamberControlError';
+    this.name = 'AiWorkerControlError';
     this.statusCode = statusCode;
     Object.assign(this, details);
   }
 }
 
 export const asControlError = (error, fallbackMessage, fallbackStatus = 500) => {
-  if (error instanceof OpenChamberControlError) return error;
+  if (error instanceof AiWorkerControlError) return error;
   const message = error instanceof Error ? error.message : fallbackMessage;
-  return new OpenChamberControlError(message || fallbackMessage, Number(error?.statusCode) || fallbackStatus, {
+  return new AiWorkerControlError(message || fallbackMessage, Number(error?.statusCode) || fallbackStatus, {
     ...(error?.goalConfigured === true ? { goalConfigured: true } : {}),
   });
 };

package/server/lib/openchamber-control/routes.js

@@ -1,7 +1,7 @@
 import express from 'express';
 import { asControlError } from './error.js';
 
-export const registerOpenChamberControlRoutes = (app, { controlService }) => {
+export const registerAiWorkerControlRoutes = (app, { controlService }) => {
   app.post('/api/openchamber/control', express.json({ limit: '1mb' }), async (req, res) => {
     const controller = new AbortController();
     const abortOnDisconnect = () => {
@@ -18,7 +18,7 @@ export const registerOpenChamberControlRoutes = (app, { controlService }) => {
       const data = await controlService.execute(action, input, req.body?.contextDirectory, { signal: controller.signal });
       return res.json(data);
     } catch (error) {
-      const controlError = asControlError(error, 'OpenChamber control action failed');
+      const controlError = asControlError(error, 'AiWorker control action failed');
       return res.status(controlError.statusCode).json({
         error: controlError.message,
         ...(controlError.partial === true ? {

package/server/lib/openchamber-control/routes.test.js

@@ -2,16 +2,16 @@ import express from 'express';
 import request from 'supertest';
 import { describe, expect, it, vi } from 'vitest';
 
-import { OpenChamberControlError } from './error.js';
-import { registerOpenChamberControlRoutes } from './routes.js';
+import { AiWorkerControlError } from './error.js';
+import { registerAiWorkerControlRoutes } from './routes.js';
 
 const createApp = (execute) => {
   const app = express();
-  registerOpenChamberControlRoutes(app, { controlService: { execute } });
+  registerAiWorkerControlRoutes(app, { controlService: { execute } });
   return app;
 };
 
-describe('OpenChamber control route', () => {
+describe('AiWorker control route', () => {
   it('is a thin adapter over the control service', async () => {
     const execute = vi.fn(async () => ({ projects: [] }));
     const response = await request(createApp(execute))
@@ -24,7 +24,7 @@ describe('OpenChamber control route', () => {
 
   it('preserves service status and partial-result details', async () => {
     const execute = vi.fn(async () => {
-      throw new OpenChamberControlError('dispatch failed', 500, {
+      throw new AiWorkerControlError('dispatch failed', 500, {
         partial: true,
         partialAction: 'fork-created',
         sessionId: 'ses_fork',

package/server/lib/openchamber-control/screenshots.js

@@ -15,7 +15,7 @@ import path from 'node:path';
 import fsPromises from 'node:fs/promises';
 
 /** Project-relative home for agent screenshots. */
-export const SCREENSHOT_DIRECTORY = path.join('.openchamber', 'screenshots');
+export const SCREENSHOT_DIRECTORY = path.join('.aiworker', 'screenshots');
 
 const MAX_LABEL_LENGTH = 48;
 

package/server/lib/openchamber-control/screenshots.test.js

@@ -47,7 +47,7 @@ describe('writing a screenshot', () => {
       fs,
     });
 
-    expect(result.path).toBe('.openchamber/screenshots/after-fix-2026-08-13T09-37-00-000.jpg');
+    expect(result.path).toBe('.aiworker/screenshots/after-fix-2026-08-13T09-37-00-000.jpg');
     expect(result.path.includes('\\')).toBe(false);
     expect(result.absolutePath).toBe(path.join('/work/project', SCREENSHOT_DIRECTORY, 'after-fix-2026-08-13T09-37-00-000.jpg'));
     expect(fs.written.get(result.absolutePath).toString()).toBe('image-bytes');