@aiworker/web 1.22.0 → 1.22.2

package/server/lib/message-queue/runtime.test.js

@@ -0,0 +1,482 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createMessageQueueRuntime, parseQueuedItemInput } from './runtime.js';
+
+const SESSION = 'ses_queue_test_1';
+const DIRECTORY = '/repo';
+
+const item = (overrides = {}) => ({
+  content: 'follow up',
+  text: 'follow up',
+  attachments: [],
+  sendConfig: { providerID: 'anthropic', modelID: 'claude', agent: 'build' },
+  ...overrides,
+});
+
+const tempDirs = [];
+const makeDataDir = () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-message-queue-'));
+  tempDirs.push(dir);
+  return dir;
+};
+
+afterEach(() => {
+  vi.useRealTimers();
+  for (const dir of tempDirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+/**
+ * A fake OpenCode: status map, message tail, command list, and a log of every
+ * prompt/command it received.
+ */
+const createOpenCode = () => {
+  const state = {
+    statuses: {},
+    tail: [],
+    commands: [],
+    sent: [],
+    failNext: null,
+  };
+  const fetchImpl = vi.fn(async (url, init = {}) => {
+    const { pathname } = new URL(url);
+    const method = init.method ?? 'GET';
+    if (state.failNext && state.failNext.test(pathname)) {
+      state.failNext = null;
+      return new Response('boom', { status: 500 });
+    }
+    if (pathname === '/session/status') return Response.json(state.statuses);
+    if (pathname.endsWith('/message')) return Response.json(state.tail);
+    if (pathname === '/command') return Response.json(state.commands);
+    if (method === 'POST' && (pathname.endsWith('/prompt_async') || pathname.endsWith('/command'))) {
+      state.sent.push({ path: pathname, body: JSON.parse(init.body) });
+      return new Response(null, { status: 204 });
+    }
+    return new Response('not found', { status: 404 });
+  });
+  return { state, fetchImpl };
+};
+
+const createRuntime = ({ dataDir = makeDataDir(), openCode = createOpenCode(), knowledge = null, retryDelayMs } = {}) => {
+  let eventHandler = () => {};
+  let statusHandler = () => {};
+  const broadcasts = [];
+  const promptSent = [];
+  const options = {
+    globalEventHub: {
+      subscribeEvent(handler) { eventHandler = handler; return () => {}; },
+      subscribeStatus(handler) { statusHandler = handler; return () => {}; },
+    },
+    buildOpenCodeUrl: (fetchPath) => `http://opencode.test${fetchPath}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    sessionKnowledgeRuntime: knowledge,
+    broadcastGlobalUiEvent: (event) => broadcasts.push(event),
+    onPromptSent: (sessionId) => promptSent.push(sessionId),
+    dataDir,
+    fetchImpl: openCode.fetchImpl,
+    dispatchQuietMs: 0,
+    abortHoldMs: 50,
+  };
+  if (retryDelayMs) options.retryDelayMs = retryDelayMs;
+  const runtime = createMessageQueueRuntime(options);
+  return {
+    runtime,
+    openCode,
+    dataDir,
+    broadcasts,
+    promptSent,
+    emit: (payload, directory = DIRECTORY) => eventHandler({ payload, directory }),
+    connect: () => statusHandler({ type: 'connect' }),
+  };
+};
+
+const settle = async (ms = 30) => {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+describe('parseQueuedItemInput', () => {
+  it('rejects an item the server could not deliver later', () => {
+    expect(() => parseQueuedItemInput({ content: 'x' })).toThrow(TypeError);
+    expect(() => parseQueuedItemInput(item({ content: '', text: '' }))).toThrow(TypeError);
+    expect(() => parseQueuedItemInput(item({ attachments: [{ filename: 'a.png' }] }))).toThrow(TypeError);
+  });
+
+  it('keeps delivery fields and trims blank edges of the content', () => {
+    const parsed = parseQueuedItemInput(item({ content: '\n\nhello\n', text: 'hello', agentMention: 'reviewer' }));
+    expect(parsed).toEqual({
+      content: 'hello',
+      text: 'hello',
+      agentMention: 'reviewer',
+      attachments: [],
+      context: [],
+      sendConfig: { providerID: 'anthropic', modelID: 'claude', agent: 'build' },
+    });
+  });
+
+  it('keeps captured context and rejects a malformed part', () => {
+    const context = [
+      { kind: 'context', text: 'Comment on `a.ts`', metadata: { aiworkerContext: { kind: 'code-comment' } }, instructions: '' },
+      { kind: 'instruction', text: 'use the skill' },
+      { kind: 'synthetic', text: 'conflict payload' },
+    ];
+    expect(parseQueuedItemInput(item({ context })).context).toEqual([
+      { kind: 'context', text: 'Comment on `a.ts`', metadata: { aiworkerContext: { kind: 'code-comment' } } },
+      { kind: 'instruction', text: 'use the skill' },
+      { kind: 'synthetic', text: 'conflict payload' },
+    ]);
+    expect(() => parseQueuedItemInput(item({ context: [{ kind: 'context', text: 'no metadata' }] }))).toThrow(TypeError);
+    expect(() => parseQueuedItemInput(item({ context: [{ kind: 'other', text: 'x' }] }))).toThrow(TypeError);
+  });
+
+  it('accepts an item that is only context', () => {
+    const parsed = parseQueuedItemInput(item({ content: '', text: '', context: [{ kind: 'synthetic', text: 'just context' }] }));
+    expect(parsed.text).toBe('');
+    expect(parsed.context).toHaveLength(1);
+  });
+});
+
+describe('message queue runtime', () => {
+  it('delivers the head of the queue when the session goes idle, in order', async () => {
+    const { runtime, openCode, emit, promptSent, broadcasts } = createRuntime();
+    runtime.start();
+    openCode.state.statuses = { [SESSION]: { type: 'busy' } };
+
+    await runtime.enqueue(SESSION, DIRECTORY, item({ content: 'first', text: 'first' }));
+    await runtime.enqueue(SESSION, DIRECTORY, item({ content: 'second', text: 'second' }));
+    await settle();
+    expect(openCode.state.sent).toHaveLength(0);
+
+    openCode.state.statuses = {};
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+
+    expect(openCode.state.sent).toHaveLength(1);
+    expect(openCode.state.sent[0].path).toBe(`/session/${SESSION}/prompt_async`);
+    expect(openCode.state.sent[0].body).toEqual({
+      model: { providerID: 'anthropic', modelID: 'claude' },
+      agent: 'build',
+      parts: [{ type: 'text', text: 'first' }],
+    });
+    expect(promptSent).toEqual([SESSION]);
+    expect(runtime.sessionSnapshot(SESSION).items.map((entry) => entry.content)).toEqual(['second']);
+    // Clients learned about the in-flight item and then the removal.
+    expect(broadcasts.at(-1)).toMatchObject({
+      type: 'aiworker:message-queue.updated',
+      properties: { session: { sessionId: SESSION, sendingId: null } },
+    });
+
+    // The next turn: busy, then idle again — the second message goes out.
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'busy' } } });
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent).toHaveLength(2);
+    expect(runtime.sessionSnapshot(SESSION).items).toEqual([]);
+  });
+
+  it('does not send into a running turn even when the status event says idle', async () => {
+    const { runtime, openCode, emit } = createRuntime();
+    runtime.start();
+    openCode.state.tail = [{ info: { role: 'assistant', time: { created: 1 } } }];
+    await runtime.enqueue(SESSION, DIRECTORY, item());
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent).toHaveLength(0);
+
+    // The reply completes: that alone drains the queue (a missed idle event
+    // must not strand it).
+    openCode.state.tail = [{ info: { role: 'assistant', time: { created: 1, completed: 2 } } }];
+    emit({ type: 'message.updated', properties: { info: { role: 'assistant', sessionID: SESSION, time: { created: 1, completed: 2 } } } });
+    await settle();
+    expect(openCode.state.sent).toHaveLength(1);
+  });
+
+  it('treats an unreachable OpenCode as unknown, not idle', async () => {
+    const { runtime, openCode, emit } = createRuntime({ retryDelayMs: () => 10 });
+    runtime.start();
+    await runtime.enqueue(SESSION, DIRECTORY, item());
+    openCode.state.failNext = /\/session\/status$/;
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle(5);
+    expect(openCode.state.sent).toHaveLength(0);
+    // Retried after the status fetch recovers.
+    await settle(40);
+    expect(openCode.state.sent).toHaveLength(1);
+  });
+
+  it('keeps a failed item and retries with backoff', async () => {
+    const { runtime, openCode, emit, broadcasts } = createRuntime({ retryDelayMs: () => 20 });
+    runtime.start();
+    await runtime.enqueue(SESSION, DIRECTORY, item());
+    openCode.state.failNext = /prompt_async$/;
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle(10);
+    expect(openCode.state.sent).toHaveLength(0);
+    expect(runtime.sessionSnapshot(SESSION).items).toHaveLength(1);
+    expect(runtime.sessionSnapshot(SESSION).sendingId).toBeNull();
+    expect(broadcasts.at(-1).properties.session.sendingId).toBeNull();
+    await settle(40);
+    expect(openCode.state.sent).toHaveLength(1);
+    expect(runtime.sessionSnapshot(SESSION).items).toHaveLength(0);
+  });
+
+  it('holds delivery briefly after a user abort', async () => {
+    const { runtime, openCode, emit } = createRuntime();
+    runtime.start();
+    await runtime.enqueue(SESSION, DIRECTORY, item());
+    emit({ type: 'message.updated', properties: { info: { role: 'assistant', sessionID: SESSION, error: { name: 'MessageAbortedError' } } } });
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle(10);
+    expect(openCode.state.sent).toHaveLength(0);
+    await settle(80);
+    expect(openCode.state.sent).toHaveLength(1);
+  });
+
+  it('honors a hold until it is released', async () => {
+    const { runtime, openCode, emit } = createRuntime();
+    runtime.start();
+    await runtime.enqueue(SESSION, DIRECTORY, item());
+    runtime.setHold(SESSION, true, 60_000);
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent).toHaveLength(0);
+
+    runtime.setHold(SESSION, false);
+    await settle();
+    expect(openCode.state.sent).toHaveLength(1);
+  });
+
+  it('survives a restart and delivers once OpenCode reconnects', async () => {
+    const dataDir = makeDataDir();
+    const first = createRuntime({ dataDir });
+    first.runtime.start();
+    first.openCode.state.statuses = { [SESSION]: { type: 'busy' } };
+    await first.runtime.enqueue(SESSION, DIRECTORY, item({ content: 'persisted', text: 'persisted' }));
+    await first.runtime.flush();
+    first.runtime.stop();
+
+    const second = createRuntime({ dataDir });
+    second.runtime.start();
+    await second.runtime.load();
+    expect(second.runtime.sessionSnapshot(SESSION).items.map((entry) => entry.content)).toEqual(['persisted']);
+    second.connect();
+    await settle();
+    expect(second.openCode.state.sent).toHaveLength(1);
+    expect(second.openCode.state.sent[0].body.parts).toEqual([{ type: 'text', text: 'persisted' }]);
+  });
+
+  it('moves an unreadable queue file aside instead of treating it as empty', async () => {
+    const dataDir = makeDataDir();
+    fs.writeFileSync(path.join(dataDir, 'message-queue.json'), '{ not json');
+    const { runtime } = createRuntime({ dataDir });
+    await runtime.load();
+    expect(runtime.snapshot().sessions).toEqual([]);
+    expect(fs.readdirSync(dataDir).some((name) => name.startsWith('message-queue.json.corrupt-'))).toBe(true);
+  });
+
+  it('refuses to remove or take the item currently being sent', async () => {
+    const { runtime, openCode, emit } = createRuntime();
+    runtime.start();
+    let release;
+    // status map, message tail, then the prompt itself (held open until released)
+    openCode.fetchImpl.mockImplementationOnce(async () => Response.json({}))
+      .mockImplementationOnce(async () => Response.json([]))
+      .mockImplementationOnce(() => new Promise((resolve) => { release = () => resolve(new Response(null, { status: 204 })); }));
+    const { itemId } = await runtime.enqueue(SESSION, DIRECTORY, item());
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(runtime.sessionSnapshot(SESSION).sendingId).toBe(itemId);
+
+    await expect(runtime.remove(SESSION, itemId)).rejects.toMatchObject({ status: 409 });
+    await expect(runtime.take(SESSION, itemId)).rejects.toMatchObject({ status: 409 });
+    const taken = await runtime.takeAll(SESSION);
+    expect(taken.items).toEqual([]);
+    expect(runtime.sessionSnapshot(SESSION).items).toHaveLength(1);
+
+    release();
+    await settle();
+    expect(runtime.sessionSnapshot(SESSION).items).toHaveLength(0);
+  });
+
+  it('take hands back the full payload and leaves the rest queued', async () => {
+    const { runtime } = createRuntime();
+    runtime.start();
+    const attachment = { id: 'a1', filename: 'shot.png', mimeType: 'image/png', size: 3, source: 'local', dataUrl: 'data:image/png;base64,AAA=' };
+    const first = await runtime.enqueue(SESSION, DIRECTORY, item({ content: 'with image', attachments: [attachment] }));
+    await runtime.enqueue(SESSION, DIRECTORY, item({ content: 'plain' }));
+
+    expect(runtime.sessionSnapshot(SESSION).items[0].attachments[0]).not.toHaveProperty('dataUrl');
+    const taken = await runtime.take(SESSION, first.itemId);
+    expect(taken.item.attachments[0].dataUrl).toBe(attachment.dataUrl);
+    expect(runtime.sessionSnapshot(SESSION).items.map((entry) => entry.content)).toEqual(['plain']);
+
+    const all = await runtime.takeAll(SESSION);
+    expect(all.items.map((entry) => entry.content)).toEqual(['plain']);
+    expect(runtime.snapshot().sessions).toEqual([]);
+  });
+
+  it('names the directory in the broadcast that empties a queue', async () => {
+    // The UI keys its projection by directory; without it the client cannot
+    // tell which queue just delivered its last message and keeps showing it.
+    const { runtime, emit, broadcasts, openCode } = createRuntime();
+    runtime.start();
+    await runtime.enqueue(SESSION, DIRECTORY, item());
+    openCode.state.statuses = {};
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+
+    expect(openCode.state.sent).toHaveLength(1);
+    expect(runtime.snapshot().sessions).toEqual([]);
+    expect(broadcasts.at(-1).properties.session).toEqual({ sessionId: SESSION, directory: DIRECTORY, items: [], sendingId: null });
+  });
+
+  it('reorders only with a complete permutation', async () => {
+    const { runtime } = createRuntime();
+    runtime.start();
+    const a = await runtime.enqueue(SESSION, DIRECTORY, item({ content: 'a' }));
+    const b = await runtime.enqueue(SESSION, DIRECTORY, item({ content: 'b' }));
+    await expect(runtime.reorder(SESSION, [b.itemId])).rejects.toThrow(TypeError);
+    await runtime.reorder(SESSION, [b.itemId, a.itemId]);
+    expect(runtime.sessionSnapshot(SESSION).items.map((entry) => entry.content)).toEqual(['b', 'a']);
+  });
+
+  it('drops the queue of a deleted session', async () => {
+    const { runtime, emit, broadcasts } = createRuntime();
+    runtime.start();
+    await runtime.enqueue(SESSION, DIRECTORY, item());
+    emit({ type: 'session.deleted', properties: { info: { id: SESSION } } });
+    expect(runtime.snapshot().sessions).toEqual([]);
+    expect(broadcasts.at(-1).properties.session).toMatchObject({ sessionId: SESSION, items: [] });
+  });
+
+  it('dispatches a queued slash command through the command endpoint', async () => {
+    const { runtime, openCode, emit } = createRuntime();
+    runtime.start();
+    openCode.state.commands = [{ name: 'review' }];
+    await runtime.enqueue(SESSION, DIRECTORY, item({ content: '/review src', text: '/review src', sendConfig: { providerID: 'p', modelID: 'm', agent: 'build', variant: 'max' } }));
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent).toHaveLength(1);
+    expect(openCode.state.sent[0].path).toBe(`/session/${SESSION}/command`);
+    expect(openCode.state.sent[0].body).toEqual({ command: 'review', arguments: 'src', model: 'p/m', agent: 'build', variant: 'max' });
+  });
+
+  it('delivers captured context as synthetic parts, instructions first, before project knowledge', async () => {
+    const knowledge = {
+      resolvePendingForSession: async () => ({ text: 'pinned notes', signature: 'sig-1' }),
+      recordDelivered: async () => {},
+    };
+    const { runtime, openCode, emit } = createRuntime({ knowledge });
+    runtime.start();
+    const metadata = { aiworkerContext: { kind: 'github-pr', number: 7, title: 'PR', url: 'https://x/pr/7' } };
+    await runtime.enqueue(SESSION, DIRECTORY, item({
+      agentMention: 'reviewer',
+      attachments: [{ id: 'a', filename: 'f.txt', mimeType: 'text/plain', size: 1, source: 'local', dataUrl: 'data:text/plain,hi' }],
+      context: [
+        { kind: 'context', text: 'the diff', metadata, instructions: 'how to read it' },
+        { kind: 'synthetic', text: 'conflict payload' },
+        { kind: 'instruction', text: 'use the skill' },
+      ],
+    }));
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent[0].body.parts).toEqual([
+      { type: 'text', text: 'follow up' },
+      { type: 'file', mime: 'text/plain', filename: 'f.txt', url: 'data:text/plain,hi' },
+      { type: 'text', text: 'how to read it', synthetic: true },
+      { type: 'text', text: 'the diff', synthetic: true, metadata },
+      { type: 'text', text: 'conflict payload', synthetic: true },
+      { type: 'text', text: 'use the skill', synthetic: true },
+      { type: 'text', text: 'pinned notes', synthetic: true },
+      { type: 'agent', name: 'reviewer' },
+    ]);
+  });
+
+  it('keeps files on the command route, which is all that route accepts', async () => {
+    const { runtime, openCode, emit } = createRuntime();
+    runtime.start();
+    openCode.state.commands = [{ name: 'review' }];
+    await runtime.enqueue(SESSION, DIRECTORY, item({
+      content: '/review',
+      text: '/review',
+      attachments: [{ id: 'a', filename: 'f.txt', mimeType: 'text/plain', size: 1, source: 'local', dataUrl: 'data:text/plain,hi' }],
+    }));
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent[0].path).toBe(`/session/${SESSION}/command`);
+    expect(openCode.state.sent[0].body.parts).toEqual([{ type: 'file', mime: 'text/plain', filename: 'f.txt', url: 'data:text/plain,hi' }]);
+  });
+
+  it('sends a command queued with context as its expanded prompt, context included', async () => {
+    // The command route rejects text parts, so a command with captured
+    // context takes the prompt route with the template expanded, exactly as
+    // the composer does.
+    const { runtime, openCode, emit } = createRuntime();
+    runtime.start();
+    openCode.state.commands = [{ name: 'review', source: 'command', template: 'Review $1 with focus on $2' }];
+    const metadata = { aiworkerContext: { kind: 'chat-quote', quote: 'q', text: 'why?' } };
+    await runtime.enqueue(SESSION, DIRECTORY, item({
+      content: '/review src "error handling"',
+      text: '/review src "error handling"',
+      context: [{ kind: 'context', text: 'quoted', metadata }],
+    }));
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent[0].path).toBe(`/session/${SESSION}/prompt_async`);
+    expect(openCode.state.sent[0].body.parts).toEqual([
+      { type: 'text', text: 'Review src with focus on error handling' },
+      { type: 'text', text: 'quoted', synthetic: true, metadata },
+    ]);
+  });
+
+  it('sends a skill queued with context as an explicit invocation, context included', async () => {
+    const { runtime, openCode, emit } = createRuntime();
+    runtime.start();
+    openCode.state.commands = [{ name: 'grill', source: 'skill', template: 'skill body' }];
+    await runtime.enqueue(SESSION, DIRECTORY, item({
+      content: '/grill auth',
+      text: '/grill auth',
+      context: [{ kind: 'synthetic', text: 'focus on tests' }],
+    }));
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent[0].path).toBe(`/session/${SESSION}/prompt_async`);
+    expect(openCode.state.sent[0].body.parts).toEqual([
+      { type: 'text', text: '/grill auth' },
+      { type: 'text', text: 'focus on tests', synthetic: true },
+      { type: 'text', text: 'The user explicitly invoked the grill skill. Use the corresponding skill tool to handle this request.', synthetic: true },
+    ]);
+  });
+
+  it('keeps captured context out of snapshots and broadcasts, and hands it back on take', async () => {
+    const { runtime, broadcasts } = createRuntime();
+    runtime.start();
+    const context = [{ kind: 'synthetic', text: 'a large diff' }];
+    const { itemId } = await runtime.enqueue(SESSION, DIRECTORY, item({ context }));
+    expect(runtime.sessionSnapshot(SESSION).items[0]).not.toHaveProperty('context');
+    expect(runtime.sessionSnapshot(SESSION).items[0].text).toBe('follow up');
+    expect(broadcasts.at(-1).properties.session.items[0]).not.toHaveProperty('context');
+    const taken = await runtime.take(SESSION, itemId);
+    expect(taken.item.context).toEqual(context);
+  });
+
+  it('attaches pending project knowledge and records its delivery', async () => {
+    const recorded = [];
+    const knowledge = {
+      resolvePendingForSession: async () => ({ text: 'pinned notes', signature: 'sig-1' }),
+      recordDelivered: async (sessionId, directory, signature) => { recorded.push({ sessionId, directory, signature }); },
+    };
+    const { runtime, openCode, emit } = createRuntime({ knowledge });
+    runtime.start();
+    await runtime.enqueue(SESSION, DIRECTORY, item({ agentMention: 'reviewer', attachments: [{ id: 'a', filename: 'f.txt', mimeType: 'text/plain', size: 1, source: 'local', dataUrl: 'data:text/plain,hi' }] }));
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent[0].body.parts).toEqual([
+      { type: 'text', text: 'follow up' },
+      { type: 'file', mime: 'text/plain', filename: 'f.txt', url: 'data:text/plain,hi' },
+      { type: 'text', text: 'pinned notes', synthetic: true },
+      { type: 'agent', name: 'reviewer' },
+    ]);
+    expect(recorded).toEqual([{ sessionId: SESSION, directory: DIRECTORY, signature: 'sig-1' }]);
+  });
+});

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

@@ -5,7 +5,7 @@
 //   - Relay (default): POST tokens + generic text to the central Cloudflare relay, which
 //     holds the single project APNs key and signs+sends — so users configure nothing.
 //   - Direct (fallback): sign an ES256 JWT with Node crypto and send over HTTP/2 ourselves,
-//     for self-hosters who set OPENCHAMBER_APNS_* and OPENCHAMBER_PUSH_RELAY_DISABLED=true.
+//     for self-hosters who set AIWORKER_APNS_* and AIWORKER_PUSH_RELAY_DISABLED=true.
 // Wired into the same trigger fanout as web push (see runtime.js); the relay carries only
 // generic, model-based text (no session content) — see APNS.md.
 
@@ -19,8 +19,8 @@ const APNS_HOST_PRODUCTION = 'https://api.push.apple.com';
 const APNS_HOST_SANDBOX = 'https://api.sandbox.push.apple.com';
 // APNs rejects auth tokens older than 1h; refresh well inside that window.
 const JWT_TTL_MS = 50 * 60 * 1000;
-const DEFAULT_BUNDLE_ID = 'com.openchamber.app';
-const DEFAULT_RELAY_URL = 'https://api.openchamber.dev/v1/push/send';
+const DEFAULT_BUNDLE_ID = 'com.aiworker.app';
+const DEFAULT_RELAY_URL = 'https://api.aiworker.dev/v1/push/send';
 const MAX_TOKENS_PER_SESSION = 10;
 // APNs reasons that mean the token is permanently invalid → drop it.
 const DEAD_TOKEN_REASONS = new Set(['BadDeviceToken', 'Unregistered', 'DeviceTokenNotForTopic']);
@@ -227,18 +227,18 @@ export const createApnsRuntime = (deps) => {
   // ---------------------------------------------------------------------------
 
   const resolveApnsConfig = async () => {
-    let keyId = trimmedEnv('OPENCHAMBER_APNS_KEY_ID');
-    let teamId = trimmedEnv('OPENCHAMBER_APNS_TEAM_ID');
-    let bundleId = trimmedEnv('OPENCHAMBER_APNS_BUNDLE_ID');
-    let environment = (trimmedEnv('OPENCHAMBER_APNS_ENVIRONMENT') || '').toLowerCase();
-    let p8 = normalizePem(process.env.OPENCHAMBER_APNS_P8 || '');
+    let keyId = trimmedEnv('AIWORKER_APNS_KEY_ID');
+    let teamId = trimmedEnv('AIWORKER_APNS_TEAM_ID');
+    let bundleId = trimmedEnv('AIWORKER_APNS_BUNDLE_ID');
+    let environment = (trimmedEnv('AIWORKER_APNS_ENVIRONMENT') || '').toLowerCase();
+    let p8 = normalizePem(process.env.AIWORKER_APNS_P8 || '');
 
-    const p8Path = trimmedEnv('OPENCHAMBER_APNS_P8_PATH');
+    const p8Path = trimmedEnv('AIWORKER_APNS_P8_PATH');
     if (!p8 && p8Path) {
       try {
         p8 = (await fsPromises.readFile(p8Path, 'utf8')).trim();
       } catch (error) {
-        console.warn('[APNs] Failed to read OPENCHAMBER_APNS_P8_PATH:', error?.message ?? error);
+        console.warn('[APNs] Failed to read AIWORKER_APNS_P8_PATH:', error?.message ?? error);
       }
     }
 
@@ -377,15 +377,15 @@ export const createApnsRuntime = (deps) => {
   // Relay mode (default): the single APNs key lives in the central Cloudflare relay, not on
   // each user's server — so users configure nothing. The server just POSTs device tokens +
   // generic text; the relay signs + sends and reports which tokens to drop. Direct mode (below)
-  // is the fallback for self-hosters who set OPENCHAMBER_APNS_* and disable the relay.
+  // is the fallback for self-hosters who set AIWORKER_APNS_* and disable the relay.
   const resolveRelayConfig = () => {
-    if (trimmedEnv('OPENCHAMBER_PUSH_RELAY_DISABLED') === 'true') return null;
-    const url = trimmedEnv('OPENCHAMBER_PUSH_RELAY_URL') || DEFAULT_RELAY_URL;
-    const override = (trimmedEnv('OPENCHAMBER_APNS_ENVIRONMENT') || '').toLowerCase();
+    if (trimmedEnv('AIWORKER_PUSH_RELAY_DISABLED') === 'true') return null;
+    const url = trimmedEnv('AIWORKER_PUSH_RELAY_URL') || DEFAULT_RELAY_URL;
+    const override = (trimmedEnv('AIWORKER_APNS_ENVIRONMENT') || '').toLowerCase();
     return {
       url,
       registerUrl: url.replace(/\/send$/, '/register-token'),
-      // Explicit OPENCHAMBER_APNS_ENVIRONMENT forces every send to that environment; when
+      // Explicit AIWORKER_APNS_ENVIRONMENT forces every send to that environment; when
       // unset (null), each token is delivered to the environment it registered with.
       environment: override === 'sandbox' ? 'sandbox' : override === 'production' ? 'production' : null,
     };
@@ -393,7 +393,7 @@ export const createApnsRuntime = (deps) => {
 
   const sendViaRelay = async (deviceTokens, payload, relay, environment) => {
     const tokens = deviceTokens.slice(0, 100);
-    const title = typeof payload?.title === 'string' && payload.title.length > 0 ? payload.title : 'OpenChamber';
+    const title = typeof payload?.title === 'string' && payload.title.length > 0 ? payload.title : 'AiWorker';
     const { privateKey, publicJwk } = await getOrCreateRelayKeypair();
     const ts = Date.now();
     // Sign over the same canonical form the relay verifies: ts.sortedTokens.title.
@@ -438,7 +438,7 @@ export const createApnsRuntime = (deps) => {
       if (!warnedUnconfigured) {
         warnedUnconfigured = true;
         console.warn(
-          '[APNs] Relay disabled and no direct config; set OPENCHAMBER_APNS_KEY_ID / OPENCHAMBER_APNS_TEAM_ID / OPENCHAMBER_APNS_P8 for direct send.',
+          '[APNs] Relay disabled and no direct config; set AIWORKER_APNS_KEY_ID / AIWORKER_APNS_TEAM_ID / AIWORKER_APNS_P8 for direct send.',
         );
       }
       return;

package/server/lib/notifications/apns-runtime.test.js

@@ -6,7 +6,7 @@ import { createApnsRuntime } from './apns-runtime.js';
 // A real P-256 key so the ES256 signing path (direct mode) runs for real.
 const { privateKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
 const P8 = privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
-const APNS_CONFIG = { keyId: 'KEY123', teamId: 'TEAM123', p8: P8, bundleId: 'com.openchamber.app', environment: 'sandbox' };
+const APNS_CONFIG = { keyId: 'KEY123', teamId: 'TEAM123', p8: P8, bundleId: 'com.aiworker.app', environment: 'sandbox' };
 
 // In-memory fs so add-then-read reflects within a test.
 const createMemoryFs = () => {
@@ -67,9 +67,9 @@ const isSend = ([url]) => String(url) === 'https://relay.test/v1/push/send';
 
 afterEach(() => {
   vi.unstubAllGlobals();
-  delete process.env.OPENCHAMBER_PUSH_RELAY_URL;
-  delete process.env.OPENCHAMBER_PUSH_RELAY_DISABLED;
-  delete process.env.OPENCHAMBER_APNS_ENVIRONMENT;
+  delete process.env.AIWORKER_PUSH_RELAY_URL;
+  delete process.env.AIWORKER_PUSH_RELAY_DISABLED;
+  delete process.env.AIWORKER_APNS_ENVIRONMENT;
 });
 
 describe('apns runtime relay mode (default)', () => {
@@ -85,7 +85,7 @@ describe('apns runtime relay mode (default)', () => {
           }),
     );
     vi.stubGlobal('fetch', fetchMock);
-    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    process.env.AIWORKER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
 
     const runtime = createApnsRuntime(makeDeps());
     await runtime.addOrUpdateApnsToken('s1', 'tokenA');
@@ -132,7 +132,7 @@ describe('apns runtime relay mode (default)', () => {
   it('reuses one persisted keypair (same serverId) across register + send', async () => {
     const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
     vi.stubGlobal('fetch', fetchMock);
-    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    process.env.AIWORKER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
 
     const deps = makeDeps();
     const runtime = createApnsRuntime(deps);
@@ -149,8 +149,8 @@ describe('apns runtime relay mode (default)', () => {
   it('honors an explicit sandbox environment override for every token', async () => {
     const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
     vi.stubGlobal('fetch', fetchMock);
-    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
-    process.env.OPENCHAMBER_APNS_ENVIRONMENT = 'sandbox';
+    process.env.AIWORKER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    process.env.AIWORKER_APNS_ENVIRONMENT = 'sandbox';
 
     const runtime = createApnsRuntime(makeDeps());
     await runtime.addOrUpdateApnsToken('s1', 'tokenA', undefined, 'ios', 'production');
@@ -163,7 +163,7 @@ describe('apns runtime relay mode (default)', () => {
   it('routes each token to its registered environment (dev build sandbox, release production)', async () => {
     const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
     vi.stubGlobal('fetch', fetchMock);
-    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
+    process.env.AIWORKER_PUSH_RELAY_URL = 'https://relay.test/v1/push/send';
 
     const runtime = createApnsRuntime(makeDeps());
     await runtime.addOrUpdateApnsToken('s1', 'tokenXcode', undefined, 'ios', 'sandbox');
@@ -200,7 +200,7 @@ describe('apns runtime direct fallback (relay disabled)', () => {
   });
 
   it('sends each token to the APNs host of its registered environment', async () => {
-    process.env.OPENCHAMBER_PUSH_RELAY_DISABLED = 'true';
+    process.env.AIWORKER_PUSH_RELAY_DISABLED = 'true';
     const { environment: _environment, ...configWithoutEnvironment } = APNS_CONFIG;
     const hosts = [];
     const http2 = {
@@ -241,7 +241,7 @@ describe('apns runtime direct fallback (relay disabled)', () => {
   });
 
   it('signs an ES256 JWT and sends over http2 when relay is disabled', async () => {
-    process.env.OPENCHAMBER_PUSH_RELAY_DISABLED = 'true';
+    process.env.AIWORKER_PUSH_RELAY_DISABLED = 'true';
     const targeted = [];
     const http2 = {
       connect: () => ({

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

@@ -66,7 +66,7 @@ export const createNotificationEmitterRuntime = (dependencies) => {
     const desktopNotificationDelivered = options.desktopNotificationDelivered === true;
 
     const syntheticPayload = {
-      type: 'openchamber:notification',
+      type: 'aiworker:notification',
       properties: {
         ...payload,
         // Tell local desktop UI whether a native channel already accepted this

package/server/lib/notifications/emitter-runtime.test.js

@@ -36,7 +36,7 @@ describe('notification emitter runtime', () => {
     runtime.broadcastUiNotification({ title: 'Ready' }, { desktopNotificationDelivered: true });
 
     expect(broadcastGlobalUiEvent).toHaveBeenCalledWith({
-      type: 'openchamber:notification',
+      type: 'aiworker:notification',
       properties: {
         title: 'Ready',
         desktopNotificationDelivered: true,