@aiworker/web 1.22.0 → 1.22.2

package/server/lib/quota/providers/exe-dev.js

@@ -0,0 +1,75 @@
+import { readManagedCredential } from '../credentials/providers.js';
+import { asObject, buildResult, formatMoney, toNumber, toTimestamp, toUsageWindow } from '../utils/index.js';
+
+export const providerId = 'exe-dev';
+export const providerName = 'exe.dev';
+export const aliases = ['exe-dev'];
+const EXEC_URL = 'https://exe.dev/exec';
+const USAGE_COMMAND = 'billing credits usage --group=day --json';
+
+export const parseExeDevUsage = (payload) => {
+  const data = asObject(payload);
+  if (!data) return null;
+
+  const totalCost = toNumber(data.total_cost_usd);
+  const monthlyAllowance = toNumber(data.monthly_allowance_usd);
+  const resetAt = toTimestamp(data.period_end);
+  if (totalCost === null || monthlyAllowance === null || monthlyAllowance < 0 || resetAt === null) return null;
+
+  const usedPercent = monthlyAllowance > 0
+    ? Math.min(100, Math.max(0, (totalCost / monthlyAllowance) * 100))
+    : null;
+  const spent = formatMoney(totalCost);
+  const allowance = formatMoney(monthlyAllowance);
+  if (spent === null || allowance === null) return null;
+
+  return {
+    monthly: toUsageWindow({
+      usedPercent,
+      windowSeconds: null,
+      resetAt,
+      valueLabel: `$${spent} / $${allowance}`,
+    }),
+  };
+};
+
+export const fetchExeDevUsage = async (credential, fetchImpl = fetch) => {
+  const response = await fetchImpl(EXEC_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      Authorization: `Bearer ${credential.usageToken}`,
+      'Content-Type': 'text/plain',
+      'User-Agent': 'AiWorker quota provider',
+    },
+    body: USAGE_COMMAND,
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (response.status === 401 || response.status === 403) throw new Error('exe.dev authentication failed');
+  if (!response.ok) throw new Error(`exe.dev usage API returned HTTP ${response.status}`);
+  const windows = parseExeDevUsage(await response.json().catch(() => null));
+  if (!windows) throw new Error('exe.dev usage data could not be parsed');
+  return windows;
+};
+
+export const isConfigured = () => Boolean(readManagedCredential(providerId));
+
+export const fetchQuota = async () => {
+  const credential = readManagedCredential(providerId);
+  if (!credential) {
+    return buildResult({ providerId, providerName, ok: false, configured: false, error: 'Not configured' });
+  }
+
+  try {
+    const windows = await fetchExeDevUsage(credential);
+    return buildResult({ providerId, providerName, ok: true, configured: true, usage: { windows } });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed',
+    });
+  }
+};

package/server/lib/quota/providers/exe-dev.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'bun:test';
+import { fetchExeDevUsage, parseExeDevUsage } from './exe-dev.js';
+
+const payload = {
+  allowance_spend_usd: 0.11,
+  extra_spend_usd: 0,
+  group: 'day',
+  month: '2026-09',
+  monthly_allowance_usd: 20,
+  period_end: '2026-10-01T00:00:00Z',
+  period_start: '2026-09-01T00:00:00Z',
+  total_cost_usd: 0.11,
+  total_requests: 17,
+};
+
+describe('exe.dev quota provider', () => {
+  it('parses monthly credit usage', () => {
+    const windows = parseExeDevUsage(payload);
+    expect(windows?.monthly.usedPercent).toBeCloseTo(0.55);
+    expect(windows?.monthly.valueLabel).toBe('$0.11 / $20.00');
+    expect(windows?.monthly.resetAt).toBe(Date.parse('2026-10-01T00:00:00Z'));
+  });
+
+  it('sends the scoped billing command without exposing the token elsewhere', async () => {
+    const requests = [];
+    const windows = await fetchExeDevUsage({ usageToken: 'test-token' }, async (url, init) => {
+      requests.push({ url, init });
+      return Response.json(payload);
+    });
+    expect(windows.monthly.valueLabel).toBe('$0.11 / $20.00');
+    expect(requests).toHaveLength(1);
+    expect(requests[0].url).toBe('https://exe.dev/exec');
+    expect(requests[0].init.method).toBe('POST');
+    expect(requests[0].init.body).toBe('billing credits usage --group=day --json');
+    expect(requests[0].init.headers.Authorization).toBe('Bearer test-token');
+  });
+
+  it('rejects malformed successful responses', async () => {
+    await expect(fetchExeDevUsage({ usageToken: 'test-token' }, async () => Response.json({})))
+      .rejects.toThrow('could not be parsed');
+  });
+
+  it('reports authentication failure without including the token', async () => {
+    await expect(fetchExeDevUsage({ usageToken: 'test-token' }, async () => new Response('', { status: 401 })))
+      .rejects.toThrow('exe.dev authentication failed');
+  });
+});

package/server/lib/quota/providers/hyper.js

@@ -0,0 +1,118 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  formatMoney,
+  asObject,
+  asNonEmptyString
+} from '../utils/index.js';
+
+export const providerId = 'hyper';
+export const providerName = 'Charm Hyper';
+export const aliases = ['hyper'];
+const HYPER_QUOTA_URL = 'https://hyper.charm.land/v1/credits';
+const CREDIT_TO_USD = 0.05;
+
+const getApiKey = (auth) => {
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  return asNonEmptyString(entry?.key) ?? asNonEmptyString(entry?.token);
+};
+
+export const isConfigured = (auth = readAuthFile()) => Boolean(getApiKey(auth));
+
+export const fetchQuota = async ({ readAuth = readAuthFile, fetchImpl = fetch } = {}) => {
+  const apiKey = getApiKey(readAuth());
+
+  if (!apiKey) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  const timeoutSignal = AbortSignal.timeout(15_000);
+
+  try {
+    const response = await fetchImpl(HYPER_QUOTA_URL, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Accept-Encoding': 'identity'
+      },
+      signal: timeoutSignal
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: response.status === 401 || response.status === 403
+          ? 'Session expired — please re-authenticate with Charm Hyper'
+          : `API error: ${response.status}`
+      });
+    }
+
+    const payload = asObject(await response.json());
+    const rawBalance = payload?.balance;
+    const balance = toNumber(asNonEmptyString(rawBalance)
+      ?? (Number.isFinite(rawBalance) ? rawBalance : null));
+
+    if (balance === null) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: 'No quota data in response'
+      });
+    }
+
+    const creditsLabel = Number.isInteger(balance) ? String(balance) : formatMoney(balance);
+    const windows = {
+      credits_balance: toUsageWindow({
+        usedPercent: null,
+        windowSeconds: null,
+        resetAt: null,
+        valueLabel: `$${formatMoney(balance * CREDIT_TO_USD)}`
+      }),
+      credits: toUsageWindow({
+        usedPercent: null,
+        windowSeconds: null,
+        resetAt: null,
+        valueLabel: creditsLabel
+      })
+    };
+
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows }
+    });
+  } catch (error) {
+    const isTimeout = error instanceof DOMException && (
+      error.name === 'TimeoutError' || (error.name === 'AbortError' && timeoutSignal.aborted)
+    );
+    const isParseError = error instanceof SyntaxError;
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: isTimeout
+        ? 'Request timed out'
+        : isParseError
+          ? 'Invalid response from provider'
+          : (error instanceof Error ? error.message : 'Request failed')
+    });
+  }
+};

package/server/lib/quota/providers/hyper.test.js

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+import { fetchQuota, isConfigured } from './hyper.js';
+
+const readAuth = () => ({ hyper: { key: 'test-token' } });
+
+// https://hyper.charm.land/docs/api/credits.html documents the balance payload.
+// https://hyper.charm.land/faq defines one Hypercredit as $0.05.
+describe('Charm Hyper quota provider', () => {
+  it.each([
+    [100, '100', '$5.00'],
+    ['50', '50', '$2.50'],
+    [25.5, '25.50', '$1.28'],
+    [0, '0', '$0.00'],
+    ['0', '0', '$0.00'],
+  ])('formats balance %s without an untranslated unit', async (balance, credits, dollars) => {
+    const result = await fetchQuota({
+      readAuth,
+      fetchImpl: async () => Response.json({ balance }),
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.providerId).toBe('hyper');
+    expect(result.configured).toBe(true);
+    expect(result.usage.windows.credits.valueLabel).toBe(credits);
+    expect(result.usage.windows.credits_balance.valueLabel).toBe(dollars);
+    for (const window of Object.values(result.usage.windows)) {
+      expect(window.usedPercent).toBeNull();
+      expect(window.remainingPercent).toBeNull();
+      expect(window.windowSeconds).toBeNull();
+      expect(window.resetAt).toBeNull();
+      expect(window.resetAfterSeconds).toBeNull();
+    }
+  });
+
+  it.each([
+    {}, null, [], { balance: '' }, { balance: ' \t ' }, { balance: 'NaN' },
+    { balance: 'Infinity' }, { balance: null }, { balance: true }, { balance: [] },
+    { balance: {} },
+  ])('rejects invalid payload %j instead of showing zero', async (payload) => {
+    const result = await fetchQuota({ readAuth, fetchImpl: async () => Response.json(payload) });
+
+    expect(result.ok).toBe(false);
+    expect(result.configured).toBe(true);
+    expect(result.error).toBe('No quota data in response');
+    expect(result.usage).toBeNull();
+  });
+
+  it.each([
+    { hyper: { key: 'test-token' } },
+    { hyper: { token: 'test-token' } },
+    { hyper: 'test-token' },
+    { hyper: { key: '  ', token: 'test-token' } },
+    { hyper: { key: 42, token: 'test-token' } },
+  ])('uses a validated credential for the documented request', async (auth) => {
+    expect(isConfigured(auth)).toBe(true);
+    let requests = 0;
+    const result = await fetchQuota({
+      readAuth: () => auth,
+      fetchImpl: async (url, options) => {
+        requests += 1;
+        expect(url).toBe('https://hyper.charm.land/v1/credits');
+        expect(options.method).toBe('GET');
+        expect(new Headers(options.headers).get('Authorization')).toBe('Bearer test-token');
+        expect(options.signal).toBeInstanceOf(AbortSignal);
+        return Response.json({ balance: 100 });
+      },
+    });
+
+    expect(requests).toBe(1);
+    expect(result.ok).toBe(true);
+    expect(JSON.stringify(result)).not.toContain('test-token');
+  });
+
+  it.each([{}, { hyper: { key: '' } }, { hyper: { key: '  ' } }, { hyper: { key: 42 } }])(
+    'does not request usage without a valid credential',
+    async (auth) => {
+      expect(isConfigured(auth)).toBe(false);
+      let requests = 0;
+      const result = await fetchQuota({
+        readAuth: () => auth,
+        fetchImpl: async () => {
+          requests += 1;
+          return Response.json({ balance: 100 });
+        },
+      });
+
+      expect(requests).toBe(0);
+      expect(result.ok).toBe(false);
+      expect(result.configured).toBe(false);
+      expect(result.error).toBe('Not configured');
+    },
+  );
+
+  it.each([
+    [401, 'Session expired — please re-authenticate with Charm Hyper'],
+    [403, 'Session expired — please re-authenticate with Charm Hyper'],
+    [429, 'API error: 429'],
+    [500, 'API error: 500'],
+  ])('reports HTTP %s as a failure', async (status, error) => {
+    const result = await fetchQuota({ readAuth, fetchImpl: async () => new Response(null, { status }) });
+
+    expect(result.ok).toBe(false);
+    expect(result.configured).toBe(true);
+    expect(result.error).toBe(error);
+    expect(result.usage).toBeNull();
+  });
+
+  it('reports invalid JSON as a parse failure', async () => {
+    const result = await fetchQuota({ readAuth, fetchImpl: async () => new Response('{') });
+    expect(result.error).toBe('Invalid response from provider');
+    expect(result.ok).toBe(false);
+    expect(result.configured).toBe(true);
+    expect(result.usage).toBeNull();
+  });
+
+  it.each([
+    [new DOMException('Timed out', 'TimeoutError'), 'Request timed out'],
+    [new Error('Network unavailable'), 'Network unavailable'],
+  ])('reports request failure', async (failure, message) => {
+    const result = await fetchQuota({ readAuth, fetchImpl: async () => { throw failure; } });
+    expect(result.error).toBe(message);
+    expect(result.ok).toBe(false);
+    expect(result.configured).toBe(true);
+    expect(result.usage).toBeNull();
+  });
+});

package/server/lib/quota/providers/index.js

@@ -13,7 +13,9 @@ import * as copilot from './copilot.js';
 import * as crof from './crof.js';
 import * as cursor from './cursor.js';
 import * as deepseek from './deepseek.js';
+import * as exeDev from './exe-dev.js';
 import * as google from './google/index.js';
+import * as hyper from './hyper.js';
 import * as kimi from './kimi.js';
 import * as nanogpt from './nanogpt.js';
 import * as openai from './openai.js';
@@ -59,12 +61,24 @@ const registry = {
     isConfigured: deepseek.isConfigured,
     fetchQuota: deepseek.fetchQuota
   },
+  'exe-dev': {
+    providerId: exeDev.providerId,
+    providerName: exeDev.providerName,
+    isConfigured: exeDev.isConfigured,
+    fetchQuota: exeDev.fetchQuota
+  },
   google: {
     providerId: google.providerId,
     providerName: google.providerName,
     isConfigured: google.isConfigured,
     fetchQuota: google.fetchGoogleQuota
   },
+  hyper: {
+    providerId: hyper.providerId,
+    providerName: hyper.providerName,
+    isConfigured: hyper.isConfigured,
+    fetchQuota: hyper.fetchQuota
+  },
   'zai-coding-plan': {
     providerId: zai.providerId,
     providerName: zai.providerName,
@@ -213,6 +227,7 @@ export const fetchGoogleQuota = google.fetchGoogleQuota;
 export const fetchCodexQuota = codex.fetchQuota;
 export const fetchCursorQuota = cursor.fetchQuota;
 export const fetchDeepseekQuota = deepseek.fetchQuota;
+export const fetchHyperQuota = hyper.fetchQuota;
 export const fetchCopilotQuota = copilot.fetchQuota;
 export const fetchCopilotAddonQuota = copilot.fetchQuotaAddon;
 export const fetchKimiQuota = kimi.fetchQuota;

package/server/lib/quota/providers/ollama-cloud.js

@@ -45,7 +45,7 @@ export const isConfigured = () => {
 export const fetchOllamaCloudUsage = async (credential, fetchImpl = fetch) => {
   const response = await fetchImpl('https://ollama.com/settings', {
     method: 'GET',
-    headers: { Cookie: credential.cookie, 'User-Agent': 'OpenChamber quota provider' },
+    headers: { Cookie: credential.cookie, 'User-Agent': 'AiWorker quota provider' },
     redirect: 'manual',
     signal: AbortSignal.timeout(15_000),
   });

package/server/lib/quota/providers/opencode-go.js

@@ -37,7 +37,8 @@ export const fetchOpenCodeGoUsage = async (apiKey, fetchImpl = fetch) => {
     headers: {
       Accept: 'application/json',
       Authorization: `Bearer ${apiKey}`,
-      'User-Agent': 'OpenChamber quota provider',
+      'x-opencode-session': 'openchamber-usage',
+      'User-Agent': 'AiWorker quota provider',
     },
     signal: AbortSignal.timeout(15_000),
   });

package/server/lib/quota/providers/opencode-go.test.js

@@ -3,9 +3,9 @@ import os from 'node:os';
 import path from 'node:path';
 import { afterAll, afterEach, describe, expect, it, vi } from 'vitest';
 
-const previousDataDirectory = process.env.OPENCHAMBER_DATA_DIR;
+const previousDataDirectory = process.env.AIWORKER_DATA_DIR;
 const temporaryDataDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-opencode-go-'));
-process.env.OPENCHAMBER_DATA_DIR = temporaryDataDirectory;
+process.env.AIWORKER_DATA_DIR = temporaryDataDirectory;
 
 vi.mock('../../opencode/auth.js', () => ({
   readAuthFile: () => ({ 'opencode-go': { key: 'test-key' } }),
@@ -18,8 +18,8 @@ afterEach(() => {
 });
 
 afterAll(() => {
-  if (previousDataDirectory === undefined) delete process.env.OPENCHAMBER_DATA_DIR;
-  else process.env.OPENCHAMBER_DATA_DIR = previousDataDirectory;
+  if (previousDataDirectory === undefined) delete process.env.AIWORKER_DATA_DIR;
+  else process.env.AIWORKER_DATA_DIR = previousDataDirectory;
   fs.rmSync(temporaryDataDirectory, { recursive: true, force: true });
 });
 
@@ -43,7 +43,11 @@ describe('OpenCode Go quota provider', () => {
       return new Response(JSON.stringify({ usage: { rolling: { percent: 25, resetsAt: '2026-08-12T12:00:00.000Z' } } }));
     });
     expect(request.url).toBe('https://opencode.ai/zen/go/v1/usage');
-    expect(request.options.headers).toMatchObject({ Accept: 'application/json', Authorization: 'Bearer secret' });
+    expect(request.options.headers).toMatchObject({
+      Accept: 'application/json',
+      Authorization: 'Bearer secret',
+      'x-opencode-session': 'openchamber-usage',
+    });
     expect(request.options.headers.Cookie).toBeUndefined();
     expect(usage['5h'].usedPercent).toBe(25);
   });

package/server/lib/quota/providers/xai.js

@@ -323,7 +323,7 @@ const fetchUsage = async (accessToken) => {
       'Content-Type': 'application/grpc-web+proto',
       'x-grpc-web': '1',
       'x-user-agent': 'connect-es/2.1.1',
-      'User-Agent': 'OpenChamber'
+      'User-Agent': 'AiWorker'
     },
     body: EMPTY_GRPC_WEB_BODY,
     signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)

package/server/lib/quota/routes.js

@@ -2,8 +2,10 @@ import express from 'express';
 import { deleteManagedCredential, getManagedCredentialStatus, normalizers, readManagedCredential, writeManagedCredential } from './credentials/providers.js';
 import { fetchOllamaCloudUsage } from './providers/ollama-cloud.js';
 import { importCursorCredential, validateCursorCredential } from './providers/cursor.js';
+import { fetchExeDevUsage } from './providers/exe-dev.js';
 
 const validators = {
+  'exe-dev': fetchExeDevUsage,
   'ollama-cloud': fetchOllamaCloudUsage,
   cursor: validateCursorCredential,
 };

package/server/lib/quota/utils/auth.js

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { OPENCODE_CONFIG_DIR } from '../../opencode/shared.js';
 
-const OPENCODE_CONFIG_DIR = path.join(os.homedir(), '.config', 'opencode');
 const OPENCODE_DATA_DIR = path.join(os.homedir(), '.local', 'share', 'opencode');
 
 export const ANTIGRAVITY_ACCOUNTS_PATHS = [

package/server/lib/relay/DOCUMENTATION.md

@@ -41,7 +41,7 @@ Relay is not a separate link format: it is one transport candidate inside the un
 Everything a client normally sends to the single AiWorker origin:
 - **HTTP** — REST endpoints and proxied OpenCode SDK calls under `/api/*`, plus `/auth/*` and `/health`.
 - **SSE** — long-lived streamed responses (the event stream and notifications). These are just HTTP responses whose body streams; the tunnel needs no special SSE handling.
-- **WebSocket** — the endpoints that use a real socket (the global event stream on platforms that support WS, terminal I/O, dictation).
+- **WebSocket** — the endpoints that use a real socket (the global event stream on platforms that support WS, terminal I/O, dictation, and desktop dev-server previews).
 
 The host dispatcher restricts tunneled traffic to explicit path allowlists (one for HTTP, one for WS).
 

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

@@ -33,7 +33,7 @@ const DEFAULT_BATCH_WINDOW_MS = 150;
 // the 150 ms default. Only applies on directions where batching was negotiated.
 const resolveBatchWindowMs = (option) => {
   if (Number.isFinite(option) && option >= 0) return option;
-  const envValue = Number.parseInt(process.env.OPENCHAMBER_RELAY_BATCH_WINDOW_MS ?? '', 10);
+  const envValue = Number.parseInt(process.env.AIWORKER_RELAY_BATCH_WINDOW_MS ?? '', 10);
   if (Number.isFinite(envValue) && envValue >= 0) return envValue;
   return DEFAULT_BATCH_WINDOW_MS;
 };

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

@@ -98,6 +98,9 @@ const startFakeRelay = () => {
         wsUrl: `ws://127.0.0.1:${port}`,
         state,
         stop: () => new Promise((r) => {
+          // A socket a failed test left open would hold server.close() until
+          // the hook timeout; drop them so a failure is reported once.
+          for (const client of wss.clients) client.terminate();
           wss.close();
           server.close(() => r());
         }),
@@ -162,7 +165,6 @@ const runScriptedClient = async ({ relayUrl, serverId, hostEncPubJwk }) => {
   url.searchParams.set('role', 'client');
   url.searchParams.set('serverId', serverId);
   url.searchParams.set('connectionId', connectionId);
-  const ws = new WebSocket(url.toString());
 
   const hostPub = await globalThis.crypto.subtle.importKey(
     'jwk',
@@ -182,6 +184,12 @@ const runScriptedClient = async ({ relayUrl, serverId, hostEncPubJwk }) => {
     resolveDone = resolve;
   });
 
+  // Dialed only now, with the key material ready and the listeners attached
+  // in the same tick. Dialing before the WebCrypto awaits above let a loopback
+  // socket open while the key generation was still queued on the threadpool,
+  // and an `open` event with no listener means no hello, no ready, and a
+  // client that waits forever. Loaded CI runners hit exactly that.
+  const ws = new WebSocket(url.toString());
   ws.on('open', async () => {
     ws.send(JSON.stringify({
       t: 'hello',

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

@@ -1,4 +1,4 @@
-// Per-machine relay-host claim. Every OpenChamber instance on a machine shares
+// Per-machine relay-host claim. Every AiWorker instance on a machine shares
 // the same data dir and therefore the same relay signing key / serverId, so if
 // two processes run a relay host at once they fight over the single host slot
 // at the relay worker (each new connection closes the previous one with

package/server/lib/relay/service.js

@@ -3,7 +3,7 @@
 //
 // Config lives in the server settings file as `settings.privateRelay =
 // { enabled, relayUrl }` (same storage precedent as tunnels/notifications).
-// Routes are registered with the other OpenChamber feature routes, before the
+// Routes are registered with the other AiWorker feature routes, before the
 // generic OpenCode proxy, and are covered by the same global UI auth gate.
 //
 // Cross-runtime parity note: relay host mode intentionally targets the web
@@ -16,7 +16,7 @@ import express from 'express';
 import { createRelayIdentityRuntime } from './identity.js';
 import { startRelayHost } from './host-client.js';
 
-export const DEFAULT_RELAY_URL = 'wss://relay.openchamber.dev/ws';
+export const DEFAULT_RELAY_URL = 'wss://relay.aiworker.dev/ws';
 
 const isValidRelayUrl = (value) => {
   if (typeof value !== 'string') return false;
@@ -40,7 +40,7 @@ const normalizeRelayUrl = (value) => {
 // stored setting entirely, so the host connection, the pairing offer, and the
 // status all point at it — clients then inherit it from the offer automatically.
 const envRelayUrlOverride = () => {
-  const raw = process.env.OPENCHAMBER_RELAY_URL;
+  const raw = process.env.AIWORKER_RELAY_URL;
   if (typeof raw !== 'string' || !raw.trim() || !isValidRelayUrl(raw)) return null;
   return raw.trim();
 };
@@ -100,7 +100,7 @@ export const createRelayService = ({
     return {
       enabled: stored?.enabled === true,
       relayUrl: override ?? normalizeRelayUrl(stored?.relayUrl),
-      // True when the endpoint is pinned by OPENCHAMBER_RELAY_URL (a self-hosted
+      // True when the endpoint is pinned by AIWORKER_RELAY_URL (a self-hosted
       // relay); the stored setting is ignored while it is set.
       relayUrlLocked: override !== null,
     };
@@ -122,7 +122,7 @@ export const createRelayService = ({
 
   const standbyStatus = (holderPid) => ({
     state: 'standby',
-    lastError: `relay host is owned by another local OpenChamber process (pid ${holderPid})`,
+    lastError: `relay host is owned by another local AiWorker process (pid ${holderPid})`,
     connectedClients: 0,
   });
 

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

@@ -33,7 +33,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
@@ -425,7 +427,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;
     }

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.