@openchambery/web 1.19.11 → 1.19.13-beta.1

package/server/lib/notifications/live-activity-refresh-runtime.js

@@ -0,0 +1,185 @@
+// Periodic Live Activity snapshot refresh for iOS devices that registered a
+// Live Activity push token. While the app is foreground/connected the UI keeps
+// its own ActivityKit state fresh; once iOS suspends or kills the app, only
+// APNs can move the on-screen activity. Completion/error/title already push
+// event-driven (runtime.js → sendLiveActivityEnd); this runtime covers the
+// busy phase: every interval it recomputes each persisted token's snapshot
+// from the authoritative session-status snapshot and pushes an update only
+// when something actually changed (APNs budgets Live Activity updates per
+// hour, so unchanged snapshots never send).
+//
+// Interval: default 30s, override with OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS
+// (milliseconds; `0` disables the timer). Snapshots use unix seconds, matching
+// the persisted token store (apns-runtime.js parseLiveActivitySnapshot).
+
+export const LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS = 30_000;
+export const LIVE_ACTIVITY_REFRESH_ITEM_LIMIT = 4; // mirrors the UI catalog cap
+export const LIVE_ACTIVITY_REFRESH_TITLE_MAX = 80;
+
+export const resolveLiveActivityRefreshIntervalMs = (env = process.env) => {
+  const raw = env?.OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS;
+  if (raw === undefined || raw === null || String(raw).trim() === '') {
+    return LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) return LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS;
+  return Math.floor(parsed);
+};
+
+const liveActivityItemIsWorking = (status) => status !== 'complete' && status !== 'error';
+
+// Session-side sub-states the server has no authoritative source for. The UI
+// derives them from live permission/question/message-delta channels; once it is
+// gone we keep the last row state instead of flickering back to `working`.
+const LIVE_ACTIVITY_PRESERVED_ROW_STATUSES = new Set(['permission', 'input', 'tool']);
+
+const mapSessionStatusToRowStatus = (sessionStatus) => {
+  if (sessionStatus === 'retry') return 'retry';
+  if (sessionStatus === 'busy') return 'working';
+  return null; // idle / unknown → terminal
+};
+
+const nextRowStatus = (currentRowStatus, sessionStatus) => {
+  if (sessionStatus === 'busy') {
+    if (LIVE_ACTIVITY_PRESERVED_ROW_STATUSES.has(currentRowStatus)) return currentRowStatus;
+    return 'working'; // including stale → working (server connection is authoritative here)
+  }
+  if (sessionStatus === 'retry') return 'retry';
+  return 'complete';
+};
+
+const capLiveActivityItems = (items) => {
+  if (items.length <= LIVE_ACTIVITY_REFRESH_ITEM_LIMIT) return items;
+  const working = items.filter((item) => liveActivityItemIsWorking(item.status));
+  const settled = items
+    .filter((item) => !liveActivityItemIsWorking(item.status))
+    .sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
+  const next = [...working];
+  for (const item of settled) {
+    if (next.length >= LIVE_ACTIVITY_REFRESH_ITEM_LIMIT) break;
+    next.push(item);
+  }
+  return next.slice(0, LIVE_ACTIVITY_REFRESH_ITEM_LIMIT);
+};
+
+const liveActivityItemsSignature = (items) => items
+  .map((item) => `${item.sessionId}\0${item.title}\0${item.status}\0${item.endedAt ?? ''}`)
+  .join('\n');
+
+/**
+ * Recompute one entry's snapshot from the authoritative session-state snapshot.
+ * Returns `{ items }` (unix seconds) when something changed, `null` to skip.
+ * Rows for sessions with no live server state are preserved as-is (never guess
+ * terminal from missing data); new busy/retry sessions join only when the
+ * injected resolver confirms sidebar visibility.
+ */
+export const computeLiveActivityRefreshSnapshot = async (input) => {
+  const { entry, sessionStates, resolveSession, nowMs } = input;
+  const nowSeconds = Math.floor(nowMs / 1000);
+  const previous = Array.isArray(entry.snapshot) ? entry.snapshot : [];
+  const items = [];
+  const seen = new Set();
+
+  for (const item of previous) {
+    if (!item || typeof item.sessionId !== 'string') continue;
+    seen.add(item.sessionId);
+    const state = sessionStates[item.sessionId];
+    if (!state) {
+      items.push(item); // no authoritative state → keep the last known row
+      continue;
+    }
+    const rowStatus = nextRowStatus(item.status, state.status);
+    if (rowStatus === item.status) {
+      items.push(item);
+      continue;
+    }
+    if (rowStatus === 'complete') {
+      items.push({
+        ...item,
+        status: 'complete',
+        endedAt: item.endedAt ?? nowSeconds,
+      });
+      continue;
+    }
+    items.push({ ...item, status: rowStatus });
+  }
+
+  const additions = [];
+  for (const [sessionId, state] of Object.entries(sessionStates || {})) {
+    if (seen.has(sessionId)) continue;
+    const mapped = mapSessionStatusToRowStatus(state?.status);
+    if (mapped === null || mapped === 'complete') continue;
+    let candidate = null;
+    try {
+      candidate = await resolveSession(sessionId);
+    } catch {
+      candidate = null;
+    }
+    if (!candidate || candidate.visible !== true) continue;
+    additions.push({
+      sessionId,
+      title: typeof candidate.title === 'string' ? candidate.title.slice(0, LIVE_ACTIVITY_REFRESH_TITLE_MAX) : '',
+      status: mapped,
+      startedAt: nowSeconds,
+    });
+  }
+
+  const merged = capLiveActivityItems([...items, ...additions]);
+  if (liveActivityItemsSignature(merged) === liveActivityItemsSignature(previous)) return null;
+  return { items: merged };
+};
+
+/**
+ * Owns the refresh interval. One tick snapshots the authoritative session
+ * states once, then hands every persisted Live Activity entry to
+ * `refreshLiveActivityTokens` (apns-runtime.js), which skips entries whose
+ * computed snapshot is unchanged. Overlapping ticks are dropped, not queued.
+ */
+export const createLiveActivityRefreshRuntime = (deps) => {
+  const {
+    intervalMs,
+    refreshLiveActivityTokens,
+    getSessionStateSnapshot,
+    resolveSession,
+  } = deps;
+  let timer = null;
+  let ticking = false;
+
+  const tick = async () => {
+    if (ticking) return;
+    ticking = true;
+    try {
+      const sessionStates = getSessionStateSnapshot();
+      const nowMs = Date.now();
+      await refreshLiveActivityTokens({
+        computeSnapshot: (entry) => computeLiveActivityRefreshSnapshot({
+          entry,
+          sessionStates,
+          resolveSession,
+          nowMs,
+        }),
+      });
+    } catch (error) {
+      console.warn('[Live Activity refresh] tick failed:', error?.message ?? error);
+    } finally {
+      ticking = false;
+    }
+  };
+
+  const start = () => {
+    if (timer || !(intervalMs > 0)) return;
+    timer = setInterval(() => {
+      void tick();
+    }, intervalMs);
+    timer.unref?.();
+  };
+
+  const dispose = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+
+  return { start, dispose, tick };
+};

package/server/lib/notifications/live-activity-refresh-runtime.test.js

@@ -0,0 +1,242 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS,
+  computeLiveActivityRefreshSnapshot,
+  createLiveActivityRefreshRuntime,
+  resolveLiveActivityRefreshIntervalMs,
+} from './live-activity-refresh-runtime.js';
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+
+describe('resolveLiveActivityRefreshIntervalMs', () => {
+  it('defaults to 30s', () => {
+    expect(resolveLiveActivityRefreshIntervalMs({})).toBe(LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS);
+    expect(resolveLiveActivityRefreshIntervalMs({
+      OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS: '  ',
+    })).toBe(LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS);
+  });
+
+  it('honours explicit overrides including disable', () => {
+    expect(resolveLiveActivityRefreshIntervalMs({
+      OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS: '45000',
+    })).toBe(45_000);
+    expect(resolveLiveActivityRefreshIntervalMs({
+      OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS: '0',
+    })).toBe(0);
+  });
+
+  it('falls back to the default for invalid values', () => {
+    expect(resolveLiveActivityRefreshIntervalMs({
+      OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS: 'abc',
+    })).toBe(LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS);
+    expect(resolveLiveActivityRefreshIntervalMs({
+      OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS: '-5',
+    })).toBe(LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS);
+  });
+});
+
+describe('computeLiveActivityRefreshSnapshot', () => {
+  const baseInput = (overrides = {}) => ({
+    entry: { token: 't', sessionId: 'live', snapshot: [] },
+    sessionStates: {},
+    resolveSession: async () => null,
+    nowMs: 1_700_000_000_000,
+    ...overrides,
+  });
+
+  it('maps idle to complete with endedAt and marks the snapshot changed', async () => {
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: {
+        token: 't',
+        sessionId: 'live',
+        snapshot: [{ sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 }],
+      },
+      sessionStates: { ses_1: { status: 'idle' } },
+    }));
+    expect(result).toEqual({
+      items: [{
+        sessionId: 'ses_1',
+        title: 'One',
+        status: 'complete',
+        startedAt: 1,
+        endedAt: Math.floor(1_700_000_000_000 / 1000),
+      }],
+    });
+  });
+
+  it('keeps server-side-only sub-states while the session stays busy', async () => {
+    const snapshot = [{ sessionId: 'ses_1', title: 'One', status: 'permission', startedAt: 1 }];
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: { token: 't', sessionId: 'live', snapshot },
+      sessionStates: { ses_1: { status: 'busy' } },
+    }));
+    expect(result).toBeNull();
+  });
+
+  it('recovers stale rows to working while busy', async () => {
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: {
+        token: 't',
+        sessionId: 'live',
+        snapshot: [{ sessionId: 'ses_1', title: 'One', status: 'stale', startedAt: 1 }],
+      },
+      sessionStates: { ses_1: { status: 'busy' } },
+    }));
+    expect(result?.items[0].status).toBe('working');
+  });
+
+  it('maps retry sessions to the retry row status', async () => {
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: {
+        token: 't',
+        sessionId: 'live',
+        snapshot: [{ sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 }],
+      },
+      sessionStates: { ses_1: { status: 'retry' } },
+    }));
+    expect(result?.items[0].status).toBe('retry');
+  });
+
+  it('preserves rows whose session has no authoritative server state', async () => {
+    const snapshot = [{ sessionId: 'ses_gone', title: 'Gone', status: 'working', startedAt: 1 }];
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: { token: 't', sessionId: 'live', snapshot },
+      sessionStates: {},
+    }));
+    expect(result).toBeNull();
+  });
+
+  it('adds new busy sessions only when the resolver marks them visible', async () => {
+    const resolveSession = vi.fn(async (sessionId) => (
+      sessionId === 'ses_child'
+        ? { title: 'Child', visible: false }
+        : { title: 'New Task', visible: true }
+    ));
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: { token: 't', sessionId: 'live', snapshot: [] },
+      sessionStates: {
+        ses_new: { status: 'busy' },
+        ses_child: { status: 'busy' },
+        ses_idle: { status: 'idle' },
+      },
+      resolveSession,
+    }));
+    expect(result?.items).toHaveLength(1);
+    expect(result?.items[0]).toMatchObject({ sessionId: 'ses_new', title: 'New Task', status: 'working' });
+    expect(resolveSession).not.toHaveBeenCalledWith('ses_idle');
+  });
+
+  it('skips new sessions when the resolver throws or resolves empty', async () => {
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: { token: 't', sessionId: 'live', snapshot: [] },
+      sessionStates: { ses_new: { status: 'busy' } },
+      resolveSession: async () => {
+        throw new Error('boom');
+      },
+    }));
+    expect(result).toBeNull();
+  });
+
+  it('caps merged rows at the catalog limit, working rows first', async () => {
+    const snapshot = [1, 2, 3, 4, 5].map((n) => ({
+      sessionId: `ses_${n}`,
+      title: `S${n}`,
+      status: 'complete',
+      startedAt: n,
+      endedAt: n,
+    }));
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: { token: 't', sessionId: 'live', snapshot },
+      sessionStates: { ses_new: { status: 'busy' } },
+      resolveSession: async () => ({ title: 'New', visible: true }),
+    }));
+    expect(result?.items).toHaveLength(4);
+    expect(result?.items.some((item) => item.sessionId === 'ses_new')).toBe(true);
+    // Most recently settled rows survive the cap.
+    expect(result?.items.some((item) => item.sessionId === 'ses_5')).toBe(true);
+    expect(result?.items.some((item) => item.sessionId === 'ses_1')).toBe(false);
+  });
+
+  it('returns null when nothing changed', async () => {
+    const snapshot = [
+      { sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 },
+      { sessionId: 'ses_2', title: 'Two', status: 'complete', startedAt: 2, endedAt: 3 },
+    ];
+    const result = await computeLiveActivityRefreshSnapshot(baseInput({
+      entry: { token: 't', sessionId: 'live', snapshot },
+      sessionStates: { ses_1: { status: 'busy' } },
+    }));
+    expect(result).toBeNull();
+  });
+});
+
+describe('createLiveActivityRefreshRuntime', () => {
+  it('ticks the refresh with one session-state snapshot for all entries', async () => {
+    const refreshLiveActivityTokens = vi.fn(async () => {});
+    const runtime = createLiveActivityRefreshRuntime({
+      intervalMs: LIVE_ACTIVITY_REFRESH_DEFAULT_INTERVAL_MS,
+      refreshLiveActivityTokens,
+      getSessionStateSnapshot: () => ({ ses_1: { status: 'busy' } }),
+      resolveSession: async () => null,
+    });
+    await runtime.tick();
+
+    expect(refreshLiveActivityTokens).toHaveBeenCalledTimes(1);
+    const arg = refreshLiveActivityTokens.mock.calls[0][0];
+    expect(typeof arg.computeSnapshot).toBe('function');
+    const result = await arg.computeSnapshot({
+      token: 't',
+      sessionId: 'live',
+      snapshot: [{ sessionId: 'ses_1', title: 'One', status: 'working', startedAt: 1 }],
+    });
+    expect(result).toBeNull();
+  });
+
+  it('drops overlapping ticks instead of queueing them', async () => {
+    let release;
+    const gate = new Promise((resolve) => { release = resolve; });
+    const refreshLiveActivityTokens = vi.fn(async () => { await gate; });
+    const runtime = createLiveActivityRefreshRuntime({
+      intervalMs: 1000,
+      refreshLiveActivityTokens,
+      getSessionStateSnapshot: () => ({}),
+      resolveSession: async () => null,
+    });
+    const first = runtime.tick();
+    await runtime.tick(); // overlapping → dropped
+    release();
+    await first;
+    expect(refreshLiveActivityTokens).toHaveBeenCalledTimes(1);
+  });
+
+  it('never schedules a timer when disabled (interval 0) and disposes cleanly', async () => {
+    vi.useFakeTimers();
+    const refreshLiveActivityTokens = vi.fn(async () => {});
+    const runtime = createLiveActivityRefreshRuntime({
+      intervalMs: 0,
+      refreshLiveActivityTokens,
+      getSessionStateSnapshot: () => ({}),
+      resolveSession: async () => null,
+    });
+    runtime.start();
+    await vi.advanceTimersByTimeAsync(120_000);
+    expect(refreshLiveActivityTokens).not.toHaveBeenCalled();
+
+    const enabled = createLiveActivityRefreshRuntime({
+      intervalMs: 30_000,
+      refreshLiveActivityTokens,
+      getSessionStateSnapshot: () => ({}),
+      resolveSession: async () => null,
+    });
+    enabled.start();
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(refreshLiveActivityTokens).toHaveBeenCalledTimes(1);
+    enabled.dispose();
+    await vi.advanceTimersByTimeAsync(120_000);
+    expect(refreshLiveActivityTokens).toHaveBeenCalledTimes(1);
+  });
+});

package/server/lib/notifications/runtime.js

@@ -316,6 +316,34 @@ export const createNotificationTriggerRuntime = (deps) => {
     return isHiddenFromNavSession(meta);
   };
 
+  // Live Activity refresh ticks carry no directory, so the cache lookup must
+  // match the session under ANY cached directory key before falling back to the
+  // directory-less OpenCode session endpoint.
+  const lookupSessionMetaAnyDirectory = (sessionId) => {
+    const direct = getCachedSessionMeta(sessionId, undefined);
+    if (direct) return direct;
+    const suffix = `\0${sessionId}`;
+    const now = Date.now();
+    for (const [key, entry] of sessionMetaCache) {
+      if (!key.endsWith(suffix)) continue;
+      if (now - entry.at <= SESSION_META_CACHE_TTL_MS) return entry;
+    }
+    return undefined;
+  };
+
+  // Sidebar candidate for a new Live Activity snapshot row: title + visibility
+  // under the same suppression rules as ordinary push. Cache-first; a missing
+  // meta resolves as not-visible (hidden sessions must never leak into a push).
+  const resolveLiveActivitySessionCandidate = async (sessionId) => {
+    const cached = lookupSessionMetaAnyDirectory(sessionId);
+    if (cached?.complete) {
+      return { title: cached.title ?? '', visible: !isHiddenFromNavSession(cached) };
+    }
+    const meta = await fetchSessionMeta(sessionId, undefined);
+    if (!meta) return null;
+    return { title: meta.title ?? '', visible: !isHiddenFromNavSession(meta) };
+  };
+
   const extractSessionIdFromPayload = (payload) => {
     if (!payload || typeof payload !== 'object') return null;
     const props = payload.properties;
@@ -650,7 +678,7 @@ export const createNotificationTriggerRuntime = (deps) => {
 
         const settings = await readSettingsFromDisk();
 
-        if (settings.notifyOnQuestion === false) {
+        if (settings.notifyOnPermission === false) {
           return;
         }
 
@@ -726,6 +754,8 @@ export const createNotificationTriggerRuntime = (deps) => {
   // full text; APNs with the generic per-type title and the session name as
   // body, so the relay never sees content).
   const sendGoalSettlePush = async ({ sessionId, directory, status, title, body }) => {
+    const settings = await readSettingsFromDisk();
+    if (settings.notifyOnGoals === false) return;
     let sessionName = '';
     try {
       const base = buildOpenCodeUrl(`/session/${encodeURIComponent(sessionId)}`, '');
@@ -759,6 +789,65 @@ export const createNotificationTriggerRuntime = (deps) => {
     );
   };
 
+  // Scheduled task run notification: fired by the scheduled-tasks runtime when
+  // a scheduled (non-manual) run settles. Desktop/UI SSE carry the task name
+  // and, on failure, the error text; push channels follow the same generic
+  // contract as other triggers (APNs title is the localized scenario, body is
+  // the task name). Manual runs skip — the user just clicked "run now".
+  const sendScheduledTaskRunNotification = async ({
+    projectID,
+    taskID,
+    taskName,
+    status,
+    sessionId,
+    reason,
+    errorMessage,
+  } = {}) => {
+    if (typeof projectID !== 'string' || !projectID) return;
+    if (typeof taskID !== 'string' || !taskID) return;
+    if (reason === 'manual') return;
+    if (status !== 'success' && status !== 'error') return;
+    const settings = await readSettingsFromDisk();
+    if (settings.notifyOnScheduledTasks === false) return;
+
+    const name = typeof taskName === 'string' && taskName.trim() ? taskName.trim() : 'Schedule';
+    const isError = status === 'error';
+    const title = isError ? 'Scheduled task failed' : 'Scheduled task completed';
+    const trimmedError = typeof errorMessage === 'string' && errorMessage.trim() ? errorMessage.trim() : '';
+    const body = isError && trimmedError ? `${name}: ${trimmedError}` : name;
+    const tag = `scheduled-${projectID}-${taskID}`;
+
+    if (settings.nativeNotificationsEnabled) {
+      const notificationPayload = {
+        kind: isError ? 'task-error' : 'task-complete',
+        title,
+        body,
+        tag,
+        ...(sessionId ? { sessionId } : {}),
+        requireHidden: false,
+      };
+      const desktopNotificationDelivered = emitDesktopNotification(notificationPayload);
+      broadcastUiNotification(notificationPayload, { desktopNotificationDelivered });
+    }
+
+    await fanoutPush(
+      {
+        title,
+        body,
+        tag,
+        data: {
+          url: typeof sessionId === 'string' && sessionId
+            ? buildSessionDeepLinkUrl(sessionId)
+            : '/',
+          ...(typeof sessionId === 'string' && sessionId ? { sessionId } : {}),
+          sessionName: name,
+          type: isError ? 'task_error' : 'task_complete',
+        },
+      },
+      { requireNoSse: true },
+    );
+  };
+
   const contactNotificationTitle = (name) => {
     if (typeof name !== 'string' || !name.trim()) return 'Assistant';
     const stripped = name.replace(/^(?:\p{Extended_Pictographic}|\p{Regional_Indicator}|[\uFE0F\u200D])+\s*/u, '').trim();
@@ -768,7 +857,7 @@ export const createNotificationTriggerRuntime = (deps) => {
   const sendContactTurnNotification = async ({ assistantID, name, body, status } = {}) => {
     if (typeof assistantID !== 'string' || !assistantID.trim()) return;
     const settings = await readSettingsFromDisk();
-    if (settings.notifyOnCompletion === false) return;
+    if (settings.notifyOnAssistants === false) return;
 
     const title = contactNotificationTitle(name);
     const rawBody = typeof body === 'string' ? body : '';
@@ -818,5 +907,7 @@ export const createNotificationTriggerRuntime = (deps) => {
     clearPendingPushBadge,
     sendGoalSettlePush,
     sendContactTurnNotification,
+    sendScheduledTaskRunNotification,
+    resolveLiveActivitySessionCandidate,
   };
 };