@openchambery/web 1.18.7-beta.2 → 1.18.7-beta.3

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

@@ -0,0 +1,212 @@
+// Localized scenario titles for native push (APNs / FCM). Keys match UI locales.
+// Titles stay content-free (scenario only); session name is the body separately.
+
+export const APNS_DEFAULT_LOCALE = 'en';
+
+export const APNS_LOCALES = Object.freeze([
+  'en',
+  'fr',
+  'zh-CN',
+  'zh-TW',
+  'uk',
+  'es',
+  'pt-BR',
+  'ko',
+  'pl',
+  'ja',
+]);
+
+/** @typedef {'ready'|'error'|'question'|'permission'|'goal_complete'|'goal_blocked'|'goal_budget'|'update'} ApnsTitleType */
+
+const TITLES = Object.freeze({
+  en: Object.freeze({
+    ready: 'Agent response is ready',
+    error: 'Agent hit an error',
+    question: 'Agent needs your input',
+    permission: 'Agent needs permission',
+    goal_complete: 'Goal complete',
+    goal_blocked: 'Goal blocked',
+    goal_budget: 'Goal reached its token budget',
+    update: 'Agent update',
+    session: 'Session',
+  }),
+  fr: Object.freeze({
+    ready: "La réponse de l'agent est prête",
+    error: "L'agent a rencontré une erreur",
+    question: "L'agent a besoin de votre saisie",
+    permission: "L'agent a besoin d'une autorisation",
+    goal_complete: 'Objectif terminé',
+    goal_blocked: 'Objectif bloqué',
+    goal_budget: "L'objectif a atteint son budget de tokens",
+    update: "Mise à jour de l'agent",
+    session: 'Session',
+  }),
+  'zh-CN': Object.freeze({
+    ready: '智能体回复已就绪',
+    error: '智能体遇到错误',
+    question: '智能体需要你的输入',
+    permission: '智能体需要权限',
+    goal_complete: '目标已完成',
+    goal_blocked: '目标受阻',
+    goal_budget: '目标已达 token 预算',
+    update: '智能体更新',
+    session: '会话',
+  }),
+  'zh-TW': Object.freeze({
+    ready: '智能體回覆已就緒',
+    error: '智能體遇到錯誤',
+    question: '智能體需要你的輸入',
+    permission: '智能體需要權限',
+    goal_complete: '目標已完成',
+    goal_blocked: '目標受阻',
+    goal_budget: '目標已達 token 預算',
+    update: '智能體更新',
+    session: '工作階段',
+  }),
+  uk: Object.freeze({
+    ready: 'Відповідь агента готова',
+    error: 'Агент зіткнувся з помилкою',
+    question: 'Агенту потрібне ваше введення',
+    permission: 'Агенту потрібен дозвіл',
+    goal_complete: 'Цілі досягнуто',
+    goal_blocked: 'Цілі заблоковано',
+    goal_budget: 'Ціль досягла ліміту токенів',
+    update: 'Оновлення агента',
+    session: 'Сесія',
+  }),
+  es: Object.freeze({
+    ready: 'La respuesta del agente está lista',
+    error: 'El agente encontró un error',
+    question: 'El agente necesita tu entrada',
+    permission: 'El agente necesita permiso',
+    goal_complete: 'Objetivo completado',
+    goal_blocked: 'Objetivo bloqueado',
+    goal_budget: 'El objetivo alcanzó su presupuesto de tokens',
+    update: 'Actualización del agente',
+    session: 'Sesión',
+  }),
+  'pt-BR': Object.freeze({
+    ready: 'A resposta do agente está pronta',
+    error: 'O agente encontrou um erro',
+    question: 'O agente precisa da sua entrada',
+    permission: 'O agente precisa de permissão',
+    goal_complete: 'Objetivo concluído',
+    goal_blocked: 'Objetivo bloqueado',
+    goal_budget: 'O objetivo atingiu o orçamento de tokens',
+    update: 'Atualização do agente',
+    session: 'Sessão',
+  }),
+  ko: Object.freeze({
+    ready: '에이전트 응답이 준비되었습니다',
+    error: '에이전트에서 오류가 발생했습니다',
+    question: '에이전트가 입력을 요청합니다',
+    permission: '에이전트가 권한이 필요합니다',
+    goal_complete: '목표 완료',
+    goal_blocked: '목표 차단됨',
+    goal_budget: '목표가 토큰 예산에 도달했습니다',
+    update: '에이전트 업데이트',
+    session: '세션',
+  }),
+  pl: Object.freeze({
+    ready: 'Odpowiedź agenta jest gotowa',
+    error: 'Agent napotkał błąd',
+    question: 'Agent potrzebuje Twojego wejścia',
+    permission: 'Agent potrzebuje uprawnienia',
+    goal_complete: 'Cel ukończony',
+    goal_blocked: 'Cel zablokowany',
+    goal_budget: 'Cel osiągnął budżet tokenów',
+    update: 'Aktualizacja agenta',
+    session: 'Sesja',
+  }),
+  ja: Object.freeze({
+    ready: 'エージェントの応答が準備できました',
+    error: 'エージェントでエラーが発生しました',
+    question: 'エージェントが入力を求めています',
+    permission: 'エージェントが許可を求めています',
+    goal_complete: '目標完了',
+    goal_blocked: '目標がブロックされました',
+    goal_budget: '目標がトークン予算に達しました',
+    update: 'エージェントの更新',
+    session: 'セッション',
+  }),
+});
+
+const matchSupportedLocale = (value) => {
+  if (!value || typeof value !== 'string') return undefined;
+  const normalized = value.toLowerCase().replace(/_/g, '-');
+  if (
+    normalized === 'zh-tw'
+    || normalized.startsWith('zh-tw-')
+    || normalized === 'zh-hk'
+    || normalized.startsWith('zh-hk-')
+    || normalized === 'zh-mo'
+    || normalized.startsWith('zh-mo-')
+    || normalized === 'zh-hant'
+    || normalized.startsWith('zh-hant-')
+  ) {
+    return 'zh-TW';
+  }
+  if (normalized.startsWith('zh')) return 'zh-CN';
+  if (normalized.startsWith('en')) return 'en';
+  if (normalized === 'fr' || normalized.startsWith('fr-')) return 'fr';
+  if (normalized === 'uk' || normalized.startsWith('uk-') || normalized === 'ua' || normalized.startsWith('ua-')) {
+    return 'uk';
+  }
+  if (normalized === 'es' || normalized.startsWith('es-')) return 'es';
+  if (normalized === 'pt' || normalized.startsWith('pt-')) return 'pt-BR';
+  if (normalized === 'ko' || normalized.startsWith('ko-')) return 'ko';
+  if (normalized === 'ja' || normalized.startsWith('ja-')) return 'ja';
+  if (normalized === 'pl' || normalized.startsWith('pl-')) return 'pl';
+  return undefined;
+};
+
+export const normalizeApnsLocale = (value) => matchSupportedLocale(value) ?? APNS_DEFAULT_LOCALE;
+
+const titlesFor = (locale) => TITLES[normalizeApnsLocale(locale)] || TITLES[APNS_DEFAULT_LOCALE];
+
+/**
+ * @param {string|undefined|null} type
+ * @param {string|undefined|null} locale
+ */
+export const resolveApnsTitle = (type, locale) => {
+  const dict = titlesFor(locale);
+  if (typeof type === 'string' && Object.prototype.hasOwnProperty.call(dict, type) && type !== 'session') {
+    return dict[type];
+  }
+  return dict.update;
+};
+
+/**
+ * @param {string|undefined|null} locale
+ */
+export const resolveApnsSessionFallback = (locale) => titlesFor(locale).session;
+
+/**
+ * Localize a generic native-push payload for one device locale.
+ * `payload.type` selects the scenario title; `payload.sessionName` (or non-empty body) is the body.
+ * Callers that already pass a fixed `title`/`body` (tests / legacy) keep that text when `type` is absent.
+ *
+ * @param {{ type?: string, title?: string, body?: string, sessionName?: string, badge?: number, tag?: string, data?: object }} payload
+ * @param {string|undefined|null} locale
+ */
+export const localizeApnsPayload = (payload, locale) => {
+  const type = typeof payload?.type === 'string' ? payload.type : undefined;
+  const sessionName = typeof payload?.sessionName === 'string' && payload.sessionName.trim().length > 0
+    ? payload.sessionName.trim()
+    : '';
+  const legacyBody = typeof payload?.body === 'string' && payload.body.trim().length > 0
+    ? payload.body.trim()
+    : '';
+  const title = type
+    ? resolveApnsTitle(type, locale)
+    : (typeof payload?.title === 'string' && payload.title.length > 0
+      ? payload.title
+      : resolveApnsTitle('update', locale));
+  return {
+    title,
+    body: sessionName || legacyBody || resolveApnsSessionFallback(locale),
+    badge: payload?.badge,
+    tag: payload?.tag,
+    data: payload?.data,
+  };
+};

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

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  APNS_DEFAULT_LOCALE,
+  APNS_LOCALES,
+  localizeApnsPayload,
+  normalizeApnsLocale,
+  resolveApnsSessionFallback,
+  resolveApnsTitle,
+} from './apns-titles.js';
+
+describe('apns-titles', () => {
+  it('normalizes BCP-47 tags onto supported app locales', () => {
+    expect(normalizeApnsLocale('zh-Hans-CN')).toBe('zh-CN');
+    expect(normalizeApnsLocale('zh_TW')).toBe('zh-TW');
+    expect(normalizeApnsLocale('pt-PT')).toBe('pt-BR');
+    expect(normalizeApnsLocale('ja-JP')).toBe('ja');
+    expect(normalizeApnsLocale('nope')).toBe(APNS_DEFAULT_LOCALE);
+    expect(normalizeApnsLocale(undefined)).toBe(APNS_DEFAULT_LOCALE);
+  });
+
+  it('resolves every scenario type for every supported locale', () => {
+    const types = ['ready', 'error', 'question', 'permission', 'goal_complete', 'goal_blocked', 'goal_budget', 'update'];
+    for (const locale of APNS_LOCALES) {
+      for (const type of types) {
+        const title = resolveApnsTitle(type, locale);
+        expect(typeof title).toBe('string');
+        expect(title.length).toBeGreaterThan(0);
+      }
+      expect(resolveApnsSessionFallback(locale).length).toBeGreaterThan(0);
+    }
+  });
+
+  it('localizes payload title by type and keeps session name as body', () => {
+    expect(localizeApnsPayload({ type: 'question', sessionName: 'Build fix' }, 'zh-CN')).toEqual({
+      title: '智能体需要你的输入',
+      body: 'Build fix',
+      badge: undefined,
+      tag: undefined,
+      data: undefined,
+    });
+    expect(localizeApnsPayload({ type: 'ready' }, 'fr').body).toBe('Session');
+    expect(localizeApnsPayload({ type: 'ready' }, 'zh-CN').body).toBe('会话');
+  });
+
+  it('keeps explicit legacy title/body when type is absent', () => {
+    expect(localizeApnsPayload({ title: 'Custom', body: 'Body' }, 'ja')).toEqual({
+      title: 'Custom',
+      body: 'Body',
+      badge: undefined,
+      tag: undefined,
+      data: undefined,
+    });
+  });
+});

package/server/lib/notifications/routes.js

@@ -22,6 +22,17 @@ const parsePushUnsubscribeBody = (body) => {
   return { endpoint: endpoint.trim() };
 };
 
+const MAX_LIVE_ACTIVITY_TOKEN_LENGTH = 512;
+const MAX_LIVE_ACTIVITY_ACTIVITY_ID_LENGTH = 128;
+const MAX_LIVE_ACTIVITY_SESSION_ID_LENGTH = 128;
+
+const parseLimitedPushId = (value, maxLength) => {
+  if (typeof value !== 'string') return '';
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > maxLength) return '';
+  return trimmed;
+};
+
 export const NOTIFICATION_SSE_HEARTBEAT_INTERVAL_MS = 20_000;
 
 export const registerNotificationRoutes = (app, dependencies) => {
@@ -37,6 +48,8 @@ export const registerNotificationRoutes = (app, dependencies) => {
     removePushSubscription,
     addOrUpdateApnsToken,
     removeApnsToken,
+    addOrUpdateLiveActivityToken,
+    removeLiveActivityToken,
     updateUiVisibility,
     clearPendingPushBadge,
     isUiVisible,
@@ -162,8 +175,9 @@ export const registerNotificationRoutes = (app, dependencies) => {
     }
 
     const platform = req.body?.platform === 'android' ? 'android' : 'ios';
+    const locale = typeof req.body?.locale === 'string' ? req.body.locale.trim() : undefined;
     if (typeof addOrUpdateApnsToken === 'function') {
-      await addOrUpdateApnsToken(uiToken, deviceToken, req.headers['user-agent'], platform);
+      await addOrUpdateApnsToken(uiToken, deviceToken, req.headers['user-agent'], platform, locale);
     }
     return res.json({ ok: true });
   });
@@ -187,6 +201,48 @@ export const registerNotificationRoutes = (app, dependencies) => {
     return res.json({ ok: true });
   });
 
+  app.post('/api/push/live-activity-token', async (req, res) => {
+    await ensureSessionWatcher();
+
+    const uiToken = uiAuthController?.ensureSessionToken
+      ? await uiAuthController.ensureSessionToken(req, res)
+      : getUiSessionTokenFromRequest(req);
+    if (!uiToken) {
+      return res.status(401).json({ error: 'UI session missing' });
+    }
+
+    const token = parseLimitedPushId(req.body?.token, MAX_LIVE_ACTIVITY_TOKEN_LENGTH);
+    const activityId = parseLimitedPushId(req.body?.activityId, MAX_LIVE_ACTIVITY_ACTIVITY_ID_LENGTH);
+    const sessionId = parseLimitedPushId(req.body?.sessionId, MAX_LIVE_ACTIVITY_SESSION_ID_LENGTH);
+    if (!token || !activityId || !sessionId) {
+      return res.status(400).json({ error: 'Invalid body' });
+    }
+
+    if (typeof addOrUpdateLiveActivityToken === 'function') {
+      await addOrUpdateLiveActivityToken(uiToken, token, activityId, sessionId);
+    }
+    return res.json({ ok: true });
+  });
+
+  app.delete('/api/push/live-activity-token', async (req, res) => {
+    const uiToken = uiAuthController?.ensureSessionToken
+      ? await uiAuthController.ensureSessionToken(req, res)
+      : getUiSessionTokenFromRequest(req);
+    if (!uiToken) {
+      return res.status(401).json({ error: 'UI session missing' });
+    }
+
+    const token = parseLimitedPushId(req.body?.token, MAX_LIVE_ACTIVITY_TOKEN_LENGTH);
+    if (!token) {
+      return res.status(400).json({ error: 'Invalid body' });
+    }
+
+    if (typeof removeLiveActivityToken === 'function') {
+      await removeLiveActivityToken(uiToken, token);
+    }
+    return res.json({ ok: true });
+  });
+
   app.post('/api/push/visibility', async (req, res) => {
     const uiToken = uiAuthController?.ensureSessionToken
       ? await uiAuthController.ensureSessionToken(req, res)

package/server/lib/notifications/runtime.js

@@ -11,6 +11,7 @@ export const createNotificationTriggerRuntime = (deps) => {
     broadcastUiNotification,
     sendPushToAllUiSessions,
     sendApnsToAllUiSessions,
+    sendLiveActivityEnd,
     isAnyInteractiveClientVisible,
     buildOpenCodeUrl,
     getOpenCodeAuthHeaders,
@@ -49,24 +50,16 @@ export const createNotificationTriggerRuntime = (deps) => {
 
   // Generic notification for native push (per the mobile design): a fixed, scenario-based
   // title + the session name as the body. No model/project/message content crosses the relay.
-  const APNS_TITLE_BY_TYPE = {
-    ready: 'Agent response is ready',
-    error: 'Agent hit an error',
-    question: 'Agent needs your input',
-    permission: 'Agent needs permission',
-    goal_complete: 'Goal complete',
-    goal_blocked: 'Goal blocked',
-    goal_budget: 'Goal reached its token budget',
-  };
-
+  // Title strings are localized per device token locale inside sendApnsToAllUiSessions.
   const toApnsGenericPayload = (payload) => {
     const data = payload?.data && typeof payload.data === 'object' ? payload.data : {};
     const sessionName = typeof data.sessionName === 'string' && data.sessionName.trim().length > 0
       ? data.sessionName.trim()
-      : 'Session';
+      : '';
+    const type = typeof data.type === 'string' ? data.type : undefined;
     return {
-      title: APNS_TITLE_BY_TYPE[data.type] || 'Agent update',
-      body: sessionName,
+      type,
+      sessionName,
       badge: trackPushAndCountBadge(typeof payload?.tag === 'string' ? payload.tag : undefined),
       tag: payload?.tag,
       // sessionId is forwarded so a tapped push can deep-link; it is an opaque id, not content.
@@ -377,14 +370,24 @@ export const createNotificationTriggerRuntime = (deps) => {
 
     if (payload.type === 'message.updated') {
       const info = payload.properties?.info;
-      if (
+      const isAssistantTerminal = Boolean(
         sessionId
         && info?.role === 'assistant'
-        && (info?.finish === 'stop' || info?.finish === 'error')
-        && await shouldSkipSystemSessionNotification(sessionId, notificationDirectory)
-      ) {
+        && (info?.finish === 'stop' || info?.finish === 'error'),
+      );
+      if (isAssistantTerminal && await shouldSkipSystemSessionNotification(sessionId, notificationDirectory)) {
         return;
       }
+      if (isAssistantTerminal) {
+        try {
+          await sendLiveActivityEnd?.({
+            sessionId,
+            status: info.finish === 'error' ? 'error' : 'complete',
+          });
+        } catch (error) {
+          console.warn('[Live Activity] end failed:', error?.message ?? error);
+        }
+      }
       if (info?.role === 'assistant' && info?.finish === 'stop' && sessionId) {
         const settings = await readSettingsFromDisk();
 

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

@@ -14,6 +14,7 @@ const createRuntime = (overrides = {}) => {
   const broadcastUiNotification = vi.fn();
   const sendPushToAllUiSessions = vi.fn(async () => {});
   const sendApnsToAllUiSessions = vi.fn(async () => {});
+  const sendLiveActivityEnd = vi.fn(async () => {});
   const runtime = createNotificationTriggerRuntime({
     readSettingsFromDisk: vi.fn(async () => defaultSettings),
     prepareNotificationLastMessage: vi.fn(async ({ message }) => message || ''),
@@ -26,6 +27,7 @@ const createRuntime = (overrides = {}) => {
     broadcastUiNotification,
     sendPushToAllUiSessions,
     sendApnsToAllUiSessions,
+    sendLiveActivityEnd,
     isAnyInteractiveClientVisible: () => false,
     buildOpenCodeUrl: (path) => `http://opencode.test${path}`,
     getOpenCodeAuthHeaders: () => ({}),
@@ -38,6 +40,7 @@ const createRuntime = (overrides = {}) => {
     broadcastUiNotification,
     sendPushToAllUiSessions,
     sendApnsToAllUiSessions,
+    sendLiveActivityEnd,
   };
 };
 
@@ -174,3 +177,108 @@ describe('notification trigger runtime smallModel suppression', () => {
     expect(sendPushToAllUiSessions).toHaveBeenCalledTimes(1);
   });
 });
+
+const rootSessionResponse = () => jsonResponse({
+  id: 'ses_root',
+  parentID: null,
+  title: 'Ordinary',
+  metadata: {},
+});
+
+const completionPayload = (sessionId = 'ses_root', finish = 'stop') => ({
+  type: 'message.updated',
+  properties: {
+    directory: '/repo',
+    info: {
+      id: 'msg_2',
+      sessionID: sessionId,
+      role: 'assistant',
+      finish,
+      mode: 'build',
+      modelID: 'gpt',
+    },
+  },
+});
+
+describe('notification trigger live activity end', () => {
+  it('ends the live activity on top-level completion and error', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => rootSessionResponse()));
+    const { runtime, sendLiveActivityEnd } = createRuntime();
+    await runtime.maybeSendPushForTrigger(completionPayload('ses_root', 'stop'));
+    await runtime.maybeSendPushForTrigger({
+      type: 'session.error',
+      properties: { directory: '/repo', sessionID: 'ses_err', error: 'boom' },
+    });
+    expect(sendLiveActivityEnd).toHaveBeenNthCalledWith(1, { sessionId: 'ses_root', status: 'complete' });
+    expect(sendLiveActivityEnd).toHaveBeenNthCalledWith(2, { sessionId: 'ses_err', status: 'error' });
+  });
+
+  it('still ends the live activity when ordinary notifications are disabled', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => rootSessionResponse()));
+    const { runtime, sendLiveActivityEnd, sendPushToAllUiSessions, sendApnsToAllUiSessions } = createRuntime({
+      readSettingsFromDisk: vi.fn(async () => ({ ...defaultSettings, notifyOnCompletion: false })),
+    });
+    await runtime.maybeSendPushForTrigger(completionPayload());
+    expect(sendLiveActivityEnd).toHaveBeenCalledWith({ sessionId: 'ses_root', status: 'complete' });
+    expect(sendPushToAllUiSessions).not.toHaveBeenCalled();
+    expect(sendApnsToAllUiSessions).not.toHaveBeenCalled();
+  });
+
+  it('ends the live activity even when an interactive client is visible', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => rootSessionResponse()));
+    const { runtime, sendLiveActivityEnd, sendApnsToAllUiSessions } = createRuntime({
+      isAnyInteractiveClientVisible: () => true,
+    });
+    await runtime.maybeSendPushForTrigger(completionPayload());
+    expect(sendLiveActivityEnd).toHaveBeenCalledWith({ sessionId: 'ses_root', status: 'complete' });
+    expect(sendApnsToAllUiSessions).not.toHaveBeenCalled();
+  });
+
+  it('suppresses live activity end for child and small-model sessions', async () => {
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('ses_child')) {
+        return jsonResponse({ id: 'ses_child', parentID: 'ses_parent', metadata: {} });
+      }
+      return jsonResponse({
+        id: 'ses_small',
+        parentID: null,
+        metadata: { openchamber: { smallModel: { purpose: 'session-title' } } },
+      });
+    });
+    vi.stubGlobal('fetch', fetchMock);
+    const { runtime, sendLiveActivityEnd, sendPushToAllUiSessions } = createRuntime();
+    await runtime.maybeSendPushForTrigger(completionPayload('ses_child'));
+    await runtime.maybeSendPushForTrigger(completionPayload('ses_small', 'error'));
+    expect(sendLiveActivityEnd).not.toHaveBeenCalled();
+    expect(sendPushToAllUiSessions).not.toHaveBeenCalled();
+  });
+
+  it('isolates live activity end failure from ordinary push', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => rootSessionResponse()));
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const sendLiveActivityEnd = vi.fn(async () => {
+      throw new Error('live-activity failed');
+    });
+    const { runtime, sendPushToAllUiSessions, sendApnsToAllUiSessions } = createRuntime({
+      sendLiveActivityEnd,
+    });
+    try {
+      await runtime.maybeSendPushForTrigger(completionPayload());
+      expect(sendLiveActivityEnd).toHaveBeenCalledTimes(1);
+      expect(sendPushToAllUiSessions).toHaveBeenCalledTimes(1);
+      expect(sendApnsToAllUiSessions).toHaveBeenCalledTimes(1);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it('repeats terminal delivery on duplicate completion events', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => rootSessionResponse()));
+    const { runtime, sendLiveActivityEnd } = createRuntime();
+    await runtime.maybeSendPushForTrigger(completionPayload());
+    await runtime.maybeSendPushForTrigger(completionPayload());
+    expect(sendLiveActivityEnd).toHaveBeenCalledTimes(2);
+    expect(sendLiveActivityEnd).toHaveBeenNthCalledWith(1, { sessionId: 'ses_root', status: 'complete' });
+    expect(sendLiveActivityEnd).toHaveBeenNthCalledWith(2, { sessionId: 'ses_root', status: 'complete' });
+  });
+});

package/server/lib/opencode/DOCUMENTATION.md

@@ -83,7 +83,7 @@ This module provides OpenCode server integration utilities for the web server ru
   - `GET /api/config/opencode-resolution`
   - `GET /api/behavior/agents-md`: returns an authoritative empty document only when the file is absent (`ENOENT`); permission and I/O failures return HTTP 500.
   - `PUT /api/behavior/agents-md`
-  - `POST /api/opencode/upgrade` (proxies OpenCode upgrade, then restarts managed OpenCode so the new binary is active)
+  - `POST /api/opencode/upgrade` (proxies OpenCode `POST /global/upgrade` with a required semantic version `target`, then restarts managed OpenCode so the new binary is active)
   - `GET /api/opencode/upgrade-status`
   - `POST /api/opencode/directory`
   - `GET /api/provider/:providerId/source`

package/server/lib/opencode/bootstrap-runtime.js

@@ -43,6 +43,9 @@ export const createBootstrapRuntime = (dependencies) => {
       removePushSubscription,
       addOrUpdateApnsToken,
       removeApnsToken,
+      addOrUpdateLiveActivityToken,
+      removeLiveActivityToken,
+      sendLiveActivityEnd,
       updateUiVisibility,
       clearPendingPushBadge,
       isUiVisible,
@@ -119,6 +122,9 @@ export const createBootstrapRuntime = (dependencies) => {
       removePushSubscription,
       addOrUpdateApnsToken,
       removeApnsToken,
+      addOrUpdateLiveActivityToken,
+      removeLiveActivityToken,
+      sendLiveActivityEnd,
       updateUiVisibility,
       clearPendingPushBadge,
       isUiVisible,

package/server/lib/opencode/bootstrap-runtime.test.js

@@ -16,4 +16,25 @@ describe('bootstrap runtime', () => {
     });
     expect(registerAuthAndAccessRoutes).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ authorizeManagedOpenCodeBridgeRequest }));
   });
+
+  it('passes live activity register, unregister, and end into notification route registration', () => {
+    const registerNotificationRoutes = vi.fn();
+    const runtime = createBootstrapRuntime({
+      createUiAuth: () => ({ enabled: false }), registerServerStatusRoutes: vi.fn(), registerCommonRequestMiddleware: vi.fn(), registerAuthAndAccessRoutes: vi.fn(),
+      registerTtsRoutes: vi.fn(), registerNotificationRoutes, registerOpenChamberRoutes: vi.fn(), express: {},
+    });
+    const addOrUpdateLiveActivityToken = vi.fn();
+    const removeLiveActivityToken = vi.fn();
+    const sendLiveActivityEnd = vi.fn();
+    runtime.setupBaseRoutes({}, {
+      process: {}, openchamberVersion: 'test', runtimeName: 'test', serverStartedAt: 0, gracefulShutdown: vi.fn(), getHealthSnapshot: vi.fn(), verboseRequestLogs: false, uiPassword: null,
+      tunnelAuthController: {}, remoteClientAuthRuntime: {}, clientPairingRuntime: {}, getRelayPairingCandidate: vi.fn(), reconcileRelay: vi.fn(), getPairingTransports: vi.fn(), getDirectCandidateUrls: vi.fn(), getServerId: vi.fn(), getServerLabel: vi.fn(), readSettingsFromDiskMigrated: vi.fn(), normalizeTunnelSessionTtlMs: vi.fn(), authorizeManagedOpenCodeBridgeRequest: vi.fn(),
+      sayTTSCapability: vi.fn(), ensurePushInitialized: vi.fn(), ensureGlobalWatcherStarted: vi.fn(), getOrCreateVapidKeys: vi.fn(), getUiSessionTokenFromRequest: vi.fn(), writeSettingsToDisk: vi.fn(), addOrUpdatePushSubscription: vi.fn(), removePushSubscription: vi.fn(), addOrUpdateApnsToken: vi.fn(), removeApnsToken: vi.fn(), addOrUpdateLiveActivityToken, removeLiveActivityToken, sendLiveActivityEnd, updateUiVisibility: vi.fn(), clearPendingPushBadge: vi.fn(), isUiVisible: vi.fn(), getUiNotificationClients: vi.fn(), writeSseEvent: vi.fn(), sessionRuntime: { getSessionActivitySnapshot: vi.fn(), getSessionStateSnapshot: vi.fn(), getSessionAttentionSnapshot: vi.fn(), getSessionState: vi.fn(), getSessionAttentionState: vi.fn(), markSessionViewed: vi.fn(), markSessionUnviewed: vi.fn(), markUserMessageSent: vi.fn() }, setPushInitialized: vi.fn(), fs: {}, os: {}, path: {}, server: {}, __dirname: '', openchamberDataDir: '', fetchFreeZenModels: vi.fn(), getCachedZenModels: vi.fn(), setAutoAcceptSession: vi.fn(), sessionIndexService: {}, sessionIndexSyncRuntime: {},
+    });
+    expect(registerNotificationRoutes).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+      addOrUpdateLiveActivityToken,
+      removeLiveActivityToken,
+      sendLiveActivityEnd,
+    }));
+  });
 });

package/server/lib/opencode/routes.js

@@ -133,6 +133,20 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
     }
   };
 
+  const normalizeOpenCodeUpgradeTarget = (value) => {
+    if (typeof value !== 'string') return '';
+    return value.trim().replace(/^v/i, '');
+  };
+
+  const readOpenCodeUpgradeError = (payload, fallback) => {
+    if (typeof payload?.error === 'string' && payload.error.trim()) return payload.error.trim();
+    if (typeof payload?.data?.message === 'string' && payload.data.message.trim()) {
+      return payload.data.message.trim();
+    }
+    if (typeof payload?.message === 'string' && payload.message.trim()) return payload.message.trim();
+    return fallback;
+  };
+
   app.get('/api/config/settings', async (req, res) => {
     try {
       const settings = await readSettingsFromDiskMigrated();
@@ -175,9 +189,14 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
         });
       }
 
-      const target = typeof req.body?.target === 'string' && req.body.target.trim().length > 0
-        ? req.body.target.trim()
-        : undefined;
+      const target = normalizeOpenCodeUpgradeTarget(req.body?.target);
+      if (!target) {
+        return res.status(400).json({
+          success: false,
+          error: 'OpenCode upgrade requires a semantic version target',
+        });
+      }
+
       const response = await fetch(buildOpenCodeUrl('/global/upgrade', ''), {
         method: 'POST',
         headers: {
@@ -185,13 +204,13 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
           Accept: 'application/json',
           ...getOpenCodeAuthHeaders(),
         },
-        body: JSON.stringify(target ? { target } : {}),
+        body: JSON.stringify({ target }),
       });
       const payload = await response.json().catch(() => null);
       if (!response.ok) {
         return res.status(response.status).json({
           success: false,
-          error: payload?.error || response.statusText || 'Failed to upgrade OpenCode',
+          error: readOpenCodeUpgradeError(payload, response.statusText || 'Failed to upgrade OpenCode'),
         });
       }