shraga 0.0.3 → 0.1.2

package/src/client/hooks/useSchedules.ts

@@ -0,0 +1,73 @@
+import { useCallback, useEffect, useState } from 'react';
+import type { Schedule } from '@/lib/schedule-types';
+
+async function api<T>(path: string, getToken: () => Promise<string | null>, init?: RequestInit): Promise<T> {
+  const token = await getToken();
+  const res = await fetch(path, {
+    ...init,
+    headers: { Authorization: `Bearer ${token ?? ''}`, 'Content-Type': 'application/json', ...init?.headers },
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error || `${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+
+export function useSchedules(getToken: () => Promise<string | null>, enabled: boolean, refreshKey = 0) {
+  const [schedules, setSchedules] = useState<Schedule[]>([]);
+  const [serverRunningIds, setServerRunningIds] = useState<Set<string>>(new Set());
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await api<{ schedules: Schedule[]; runningIds: string[] }>('/api/schedules', getToken);
+      setSchedules(data.schedules);
+      setServerRunningIds(new Set(data.runningIds));
+    } catch (e: any) {
+      setError(e.message);
+    } finally {
+      setLoading(false);
+    }
+  }, [getToken]);
+
+  useEffect(() => { if (enabled) refresh(); }, [enabled, refresh, refreshKey]);
+
+  const create = useCallback(async (s: Partial<Schedule>) => {
+    const created = await api<Schedule>('/api/schedules', getToken, { method: 'POST', body: JSON.stringify(s) });
+    await refresh();
+    return created;
+  }, [getToken, refresh]);
+
+  const update = useCallback(async (id: string, s: Partial<Schedule>) => {
+    const updated = await api<Schedule>(`/api/schedules/${id}`, getToken, { method: 'PUT', body: JSON.stringify(s) });
+    await refresh();
+    return updated;
+  }, [getToken, refresh]);
+
+  const remove = useCallback(async (id: string) => {
+    await api(`/api/schedules/${id}`, getToken, { method: 'DELETE' });
+    await refresh();
+  }, [getToken, refresh]);
+
+  const toggle = useCallback(async (id: string, en: boolean) => {
+    await api(`/api/schedules/${id}/toggle`, getToken, { method: 'POST', body: JSON.stringify({ enabled: en }) });
+    await refresh();
+  }, [getToken, refresh]);
+
+  const runNow = useCallback(async (id: string, override?: string) => {
+    const result = await api<{ sessionId: string }>(`/api/schedules/${id}/run`, getToken, { method: 'POST', body: JSON.stringify(override ? { override } : {}) });
+    await refresh();
+    return result.sessionId;
+  }, [getToken, refresh]);
+
+  const cancelRun = useCallback(async (id: string) => {
+    await api(`/api/schedules/${id}/cancel`, getToken, { method: 'POST' });
+    await refresh();
+  }, [getToken, refresh]);
+
+  return { schedules, serverRunningIds, loading, error, refresh, create, update, remove, toggle, runNow, cancelRun };
+}

package/src/client/hooks/useUnread.ts

@@ -0,0 +1,238 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { AgentSocket, ServerEvent } from '@/lib/ws';
+import { requestDesktopAttention, setDesktopBadge } from '@/lib/desktopAttention';
+
+export interface UnreadSession {
+  count: number;
+  preview: string;
+  source: 'response' | 'proactive' | 'schedule';
+  title?: string;
+}
+
+export interface ToastItem {
+  id: string;
+  sessionId: string;
+  preview: string;
+  title?: string;
+  ts: number;
+}
+
+const MAX_TOASTS = 4;
+const TOAST_TTL = 0; // 0 = sticky (no auto-dismiss), positive ms = auto-expire
+
+export function useUnread(
+  socket: AgentSocket | null,
+  activeSessionId: string | undefined,
+) {
+  const [unreads, setUnreads] = useState<Record<string, UnreadSession>>({});
+  const [toasts, setToasts] = useState<ToastItem[]>([]);
+  const activeRef = useRef(activeSessionId);
+  activeRef.current = activeSessionId;
+  const focusedRef = useRef(!document.hidden);
+  const socketRef = useRef(socket);
+  socketRef.current = socket;
+
+  // Track tab focus
+  useEffect(() => {
+    const onVisChange = () => {
+      focusedRef.current = !document.hidden;
+      socketRef.current?.sendPresence(activeRef.current, focusedRef.current);
+      if (focusedRef.current && activeRef.current) {
+        markRead(activeRef.current);
+      }
+    };
+    const onFocus = () => {
+      focusedRef.current = true;
+      socketRef.current?.sendPresence(activeRef.current, true);
+      if (activeRef.current) markRead(activeRef.current);
+    };
+    const onBlur = () => {
+      focusedRef.current = false;
+      socketRef.current?.sendPresence(activeRef.current, false);
+    };
+    document.addEventListener('visibilitychange', onVisChange);
+    window.addEventListener('focus', onFocus);
+    window.addEventListener('blur', onBlur);
+    return () => {
+      document.removeEventListener('visibilitychange', onVisChange);
+      window.removeEventListener('focus', onFocus);
+      window.removeEventListener('blur', onBlur);
+    };
+  }, []);
+
+  // Send presence when active session changes
+  useEffect(() => {
+    socket?.sendPresence(activeSessionId, focusedRef.current);
+    if (activeSessionId && focusedRef.current) {
+      markRead(activeSessionId);
+    }
+  }, [activeSessionId, socket]);
+
+  useEffect(() => {
+    if (!TOAST_TTL || toasts.length === 0) return;
+    const timer = setInterval(() => {
+      const now = Date.now();
+      setToasts(prev => prev.filter(t => now - t.ts < TOAST_TTL));
+    }, 5_000);
+    return () => clearInterval(timer);
+  }, [toasts.length]);
+
+  const handleUnreadEvent = useCallback((event: ServerEvent) => {
+    if (event.type === 'unread') {
+      const isViewingThis = activeRef.current === event.sessionId && focusedRef.current;
+      if (isViewingThis) {
+        socketRef.current?.markRead(event.sessionId);
+        return;
+      }
+      setUnreads(prev => ({
+        ...prev,
+        [event.sessionId]: {
+          count: event.count,
+          preview: event.preview,
+          source: event.source,
+          title: event.title,
+        },
+      }));
+      setToasts(prev => {
+        const existing = prev.filter(t => t.sessionId !== event.sessionId);
+        const toast: ToastItem = {
+          id: `${event.sessionId}-${Date.now()}`,
+          sessionId: event.sessionId,
+          preview: event.preview,
+          title: event.title,
+          ts: Date.now(),
+        };
+        return [toast, ...existing].slice(0, MAX_TOASTS);
+      });
+    }
+
+    if (event.type === 'unread_sync') {
+      const mapped: Record<string, UnreadSession> = {};
+      for (const [sid, entry] of Object.entries(event.sessions)) {
+        if (sid === activeRef.current && focusedRef.current) {
+          socketRef.current?.markRead(sid);
+          continue;
+        }
+        mapped[sid] = {
+          count: entry.count,
+          preview: entry.preview,
+          source: entry.source as UnreadSession['source'],
+          title: entry.title,
+        };
+      }
+      setUnreads(mapped);
+    }
+
+    if (event.type === 'unread_cleared') {
+      setUnreads(prev => {
+        const next = { ...prev };
+        delete next[event.sessionId];
+        return next;
+      });
+    }
+  }, []);
+
+  const markRead = useCallback((sessionId: string) => {
+    setUnreads(prev => {
+      if (!prev[sessionId]) return prev;
+      const next = { ...prev };
+      delete next[sessionId];
+      return next;
+    });
+    setToasts(prev => prev.filter(t => t.sessionId !== sessionId));
+    socketRef.current?.markRead(sessionId);
+  }, []);
+
+  const dismissToast = useCallback((id: string) => {
+    setToasts(prev => prev.filter(t => t.id !== id));
+  }, []);
+
+  // Surface an ad-hoc in-app toast (e.g. a foreground native push) reusing the existing stack.
+  const addToast = useCallback((t: { sessionId: string; preview: string; title?: string }) => {
+    if (activeRef.current === t.sessionId && focusedRef.current) return; // already on that screen
+    setToasts(prev => {
+      const existing = prev.filter(x => x.sessionId !== t.sessionId);
+      const toast: ToastItem = { id: `${t.sessionId}-${Date.now()}`, sessionId: t.sessionId, preview: t.preview, title: t.title, ts: Date.now() };
+      return [toast, ...existing].slice(0, MAX_TOASTS);
+    });
+  }, []);
+
+  const totalUnread = Object.keys(unreads).length;
+
+  // Update document title and favicon
+  useEffect(() => {
+    const base = 'Shraga';
+    document.title = totalUnread > 0 ? `(${totalUnread}) ${base}` : base;
+    updateFavicon(totalUnread);
+  }, [totalUnread]);
+
+  // Desktop shell (appwrap/macOS): mirror the unread count on the Dock badge, and bounce the Dock
+  // icon when a NEW unread arrives while the window is unfocused. No-op on web/mobile/no-kit.
+  const prevUnreadRef = useRef(0);
+  useEffect(() => {
+    setDesktopBadge(totalUnread);
+    if (totalUnread > prevUnreadRef.current) requestDesktopAttention(false); // completed response → informational
+    prevUnreadRef.current = totalUnread;
+  }, [totalUnread]);
+
+  return { unreads, toasts, totalUnread, markRead, dismissToast, addToast, handleUnreadEvent };
+}
+
+let faviconCanvas: HTMLCanvasElement | null = null;
+let originalFavicon: string | null = null;
+
+function updateFavicon(count: number) {
+  if (typeof document === 'undefined') return;
+
+  if (!originalFavicon) {
+    const existing = document.querySelector('link[rel="icon"]') as HTMLLinkElement | null;
+    originalFavicon = existing?.href ?? '';
+  }
+
+  if (count === 0) {
+    setFaviconHref(originalFavicon || '');
+    return;
+  }
+
+  if (!faviconCanvas) {
+    faviconCanvas = document.createElement('canvas');
+    faviconCanvas.width = 32;
+    faviconCanvas.height = 32;
+  }
+
+  const ctx = faviconCanvas.getContext('2d');
+  if (!ctx) return;
+
+  ctx.clearRect(0, 0, 32, 32);
+
+  // Draw base circle icon
+  ctx.fillStyle = '#6366f1';
+  ctx.beginPath();
+  ctx.arc(16, 16, 14, 0, Math.PI * 2);
+  ctx.fill();
+
+  // Draw badge
+  ctx.fillStyle = '#ef4444';
+  ctx.beginPath();
+  ctx.arc(24, 8, 8, 0, Math.PI * 2);
+  ctx.fill();
+
+  // Draw count
+  ctx.fillStyle = '#fff';
+  ctx.font = 'bold 10px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.textBaseline = 'middle';
+  ctx.fillText(count > 9 ? '9+' : String(count), 24, 8);
+
+  setFaviconHref(faviconCanvas.toDataURL());
+}
+
+function setFaviconHref(href: string) {
+  let link = document.querySelector('link[rel="icon"]') as HTMLLinkElement | null;
+  if (!link) {
+    link = document.createElement('link');
+    link.rel = 'icon';
+    document.head.appendChild(link);
+  }
+  if (link.href !== href) link.href = href;
+}

package/src/client/lib/desktopAttention.ts

@@ -0,0 +1,75 @@
+// Draw the user's attention in the appwrap DESKTOP shell (Tauri/macOS) when a response finishes or
+// something needs input while the window is NOT focused. Every path is a silent no-op on web,
+// mobile, or when no native shell is connected — so the app is unchanged everywhere else.
+//
+// Two shell methods are used (see runtime-desktop/src-tauri/src/main.rs):
+//   • app.requestAttention { critical }      → bounces the Dock icon (single bounce vs. until-focus)
+//   • notifications.setBadge / clear         → the Dock-icon badge (NSDockTile)
+// Older/other shells return UNSUPPORTED — every invoke is guarded so it can never break the app.
+import { kit } from '@livx.cc/native-kit';
+
+let enabled = false;
+let initPromise: Promise<boolean> | null = null;
+
+// Warn once per failing method — an old shell missing a method (UNSUPPORTED) rejects on EVERY
+// call (each unread tick / permission_request / badge update); we surface it once, not as spam.
+const warned = new Set<string>();
+function warnOnce(key: string, msg: string, err: unknown): void {
+  if (warned.has(key)) return;
+  warned.add(key);
+  console.warn(msg, err);
+}
+
+/**
+ * One-time detection: are we inside the appwrap desktop shell? Resolves `true` only when the native
+ * adapter won the handshake AND it reports platform 'desktop'. Idempotent; never rejects.
+ * (`kit.platform` is typed 'ios' | 'android' | 'web' upstream, but the desktop shell reports the
+ * runtime string 'desktop' — hence the cast.)
+ */
+export function initDesktopAttention(): Promise<boolean> {
+  if (!initPromise) {
+    initPromise = kit
+      .ready()
+      .then(() => {
+        enabled = kit.is.native && (kit.platform as string) === 'desktop';
+        return enabled;
+      })
+      .catch((err) => {
+        console.warn('[desktop] kit.ready() failed, attention disabled', err);
+        return false;
+      });
+  }
+  return initPromise;
+}
+
+/** True only when running in the desktop shell. */
+export function isDesktopShell(): boolean {
+  return enabled;
+}
+
+/** True when the window currently has OS focus (no bounce needed then). */
+function windowFocused(): boolean {
+  return typeof document !== 'undefined' && document.hasFocus();
+}
+
+/**
+ * Bounce the Dock icon to draw attention — but only in the desktop shell and only when the window
+ * is NOT focused (a focused window needs no nudge). `blocking` = a question/approval waiting on the
+ * user → critical bounce (until focus); otherwise a single informational bounce (completed response).
+ */
+export function requestDesktopAttention(blocking = false): void {
+  if (!enabled || windowFocused()) return;
+  kit
+    .invoke('app.requestAttention', { critical: blocking })
+    .catch((err) => warnOnce('requestAttention', '[desktop] requestAttention failed', err));
+}
+
+/**
+ * Reflect the pending/unread count on the Dock-icon badge. No-op off the desktop shell.
+ * `count <= 0` clears the badge.
+ */
+export function setDesktopBadge(count: number): void {
+  if (!enabled) return;
+  const p = count > 0 ? kit.notifications.setBadge(count) : kit.notifications.clear();
+  p.catch((err) => warnOnce('setBadge', '[desktop] setBadge failed', err));
+}

package/src/client/lib/firebase.ts

@@ -0,0 +1,32 @@
+import { initializeApp, type FirebaseApp } from 'firebase/app';
+import { getAuth, GoogleAuthProvider, signInWithPopup, signOut, onAuthStateChanged, type Auth, type User } from 'firebase/auth';
+import { canUseNativeGoogleSignIn, signInWithGoogleNative } from './googleAuthNative';
+
+// Firebase is OPTIONAL — only initialized when VITE_FIREBASE_CONFIG_PROD is present (an optional
+// add-on). This build ships with local auth and no Firebase config; guard so importing this
+// module never throws when unconfigured.
+const firebaseConfig = JSON.parse(import.meta.env.VITE_FIREBASE_CONFIG_PROD ?? '{}');
+export const hasFirebase = !!firebaseConfig.apiKey;
+
+let app: FirebaseApp | null = null;
+export const auth: Auth | null = hasFirebase ? getAuth((app = initializeApp(firebaseConfig))) : null;
+
+export async function signInWithGoogle() {
+  if (!auth) throw new Error('Firebase not configured');
+  // In the appwrap native shell, Google blocks OAuth in the embedded WebView (disallowed_useragent),
+  // so run it in the system browser via kit.oauth → signInWithCredential. Falls back to the web popup.
+  if (await canUseNativeGoogleSignIn()) {
+    await signInWithGoogleNative(auth);
+    return;
+  }
+  await signInWithPopup(auth, new GoogleAuthProvider());
+}
+
+export async function signOutUser() {
+  if (auth) await signOut(auth);
+}
+
+export function onAuth(cb: (user: User | null) => void) {
+  if (!auth) { cb(null); return () => {}; }
+  return onAuthStateChanged(auth, cb);
+}

package/src/client/lib/googleAuthNative.ts

@@ -0,0 +1,94 @@
+// Google sign-in for the appwrap native shell.
+//
+// Google rejects OAuth loaded inside an embedded WebView with `403 disallowed_useragent` (the
+// "Use secure browsers" policy). So inside the native shell we run the authorization-code + PKCE
+// flow in the SYSTEM browser via `kit.oauth` (ASWebAuthenticationSession), exchange the code for an
+// id_token, then hand it to Firebase via `signInWithCredential` — same end state as the web popup.
+//
+// Gated on `VITE_GOOGLE_IOS_OAUTH_CLIENT_ID` (a per-instance iOS OAuth client created in that
+// instance's Firebase project for bundle `cc.livx.shraga`). Until it's set, the app uses the popup.
+// Mirrors the proven AGF appwrap implementation.
+import { kit } from '@livx.cc/native-kit';
+import { GoogleAuthProvider, signInWithCredential, type Auth } from 'firebase/auth';
+
+const CLIENT_ID = import.meta.env.VITE_GOOGLE_IOS_OAUTH_CLIENT_ID as string | undefined;
+
+/** True only inside the native shell, with the oauth module compiled in and a client id configured. */
+export async function canUseNativeGoogleSignIn(): Promise<boolean> {
+  if (!CLIENT_ID) return false;
+  try {
+    await kit.ready();
+  } catch {
+    return false;
+  }
+  return kit.is.native && kit.oauth.capability === 'native';
+}
+
+function base64Url(bytes: Uint8Array): string {
+  let s = '';
+  for (const b of bytes) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+async function sha256(input: string): Promise<Uint8Array> {
+  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+  return new Uint8Array(digest);
+}
+
+/** The reversed iOS OAuth client id IS the custom URL scheme Google redirects back to.
+ *  '1234-abc.apps.googleusercontent.com' → 'com.googleusercontent.apps.1234-abc' */
+function reversedClientId(clientId: string): string {
+  return `com.googleusercontent.apps.${clientId.replace(/\.apps\.googleusercontent\.com$/, '')}`;
+}
+
+/** Run the native Google sign-in flow against the given Firebase Auth. Throws on failure. */
+export async function signInWithGoogleNative(auth: Auth): Promise<void> {
+  if (!CLIENT_ID) throw new Error('VITE_GOOGLE_IOS_OAUTH_CLIENT_ID not configured');
+  await kit.ready();
+  if (kit.oauth.capability !== 'native') {
+    throw new Error('kit.oauth unavailable — shell built without the "oauth" module');
+  }
+
+  const scheme = reversedClientId(CLIENT_ID);
+  const redirectUri = `${scheme}:/oauth2redirect`;
+  const verifier = base64Url(crypto.getRandomValues(new Uint8Array(32)));
+  const challenge = base64Url(await sha256(verifier));
+
+  const authUrl =
+    'https://accounts.google.com/o/oauth2/v2/auth?' +
+    new URLSearchParams({
+      client_id: CLIENT_ID,
+      redirect_uri: redirectUri,
+      response_type: 'code',
+      scope: 'openid email profile',
+      code_challenge: challenge,
+      code_challenge_method: 'S256',
+    }).toString();
+
+  console.log('[auth] native Google sign-in via system browser');
+  const { url } = await kit.oauth.authorize({ url: authUrl, callbackScheme: scheme });
+
+  const code = new URL(url).searchParams.get('code');
+  if (!code) throw new Error('OAuth callback missing authorization code');
+
+  // iOS OAuth clients are "installed apps" — PKCE, no client secret.
+  const tokenRes = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      client_id: CLIENT_ID,
+      code,
+      code_verifier: verifier,
+      grant_type: 'authorization_code',
+      redirect_uri: redirectUri,
+    }).toString(),
+  });
+  if (!tokenRes.ok) {
+    const body = await tokenRes.text().catch(() => '');
+    throw new Error(`token exchange failed: HTTP ${tokenRes.status} — ${body}`);
+  }
+  const { id_token } = await tokenRes.json();
+  if (!id_token) throw new Error('token response missing id_token');
+
+  await signInWithCredential(auth, GoogleAuthProvider.credential(id_token));
+}

package/src/client/lib/native.ts

@@ -0,0 +1,43 @@
+// Thin wrapper around @livx.cc/native-kit. In a plain browser the kit's WebAdapter wins the
+// handshake → `kit.is.native === false` and every push capability reports 'none', so all the
+// push paths below no-op cleanly. Inside an appwrap native shell the AppwrapAdapter wins and
+// push becomes 'native'. We expose only what the client needs (readiness + push + visibility).
+import { kit } from '@livx.cc/native-kit';
+import type { PushMessage, PushToken } from '@livx.cc/native-kit';
+
+export type { PushMessage, PushToken };
+
+/** The native-kit push module (isomorphic; reports capability 'none' in a browser). */
+export const push = kit.push;
+
+let readyPromise: Promise<boolean> | null = null;
+
+/**
+ * Run the one-time `kit.ready()` handshake and resolve whether we're inside a native shell.
+ * Idempotent and never rejects — a failed/timed-out handshake degrades to `false` (web).
+ */
+export function initNative(): Promise<boolean> {
+  if (!readyPromise) {
+    readyPromise = kit
+      .ready()
+      .then(() => kit.is.native)
+      .catch((err) => {
+        console.warn('[push] kit.ready() failed, treating as web', err);
+        return false;
+      });
+  }
+  return readyPromise;
+}
+
+/** Current page visibility (Page Visibility API). True when the tab/app is foregrounded. */
+export function isVisible(): boolean {
+  return typeof document === 'undefined' ? true : !document.hidden;
+}
+
+/** Subscribe to foreground/background changes. Returns an unsubscribe fn. */
+export function onVisibilityChange(cb: (visible: boolean) => void): () => void {
+  if (typeof document === 'undefined') return () => {};
+  const handler = () => cb(!document.hidden);
+  document.addEventListener('visibilitychange', handler);
+  return () => document.removeEventListener('visibilitychange', handler);
+}

package/src/client/lib/schedule-types.ts

@@ -0,0 +1,34 @@
+export type Trigger =
+  | { kind: 'once'; at: number }
+  | { kind: 'interval'; everyMs: number }
+  | { kind: 'cron'; expr: string; tz: string }
+  | { kind: 'event'; source: string; match?: Record<string, string> };
+
+export type Task =
+  | { kind: 'prompt'; prompt: string; model?: string }
+  | { kind: 'bash'; command: string; model?: string }
+  | { kind: 'job'; command: string };
+
+export type Scope = 'system' | 'user';
+
+export interface ScheduleRunSummary {
+  at: number;
+  sessionId: string;
+  status: 'running' | 'ok' | 'error' | 'aborted';
+  error?: string;
+}
+
+export interface Schedule {
+  id: string;
+  name: string;
+  enabled: boolean;
+  trigger: Trigger;
+  task: Task;
+  scope: Scope;
+  createdBy: { uid: string; email: string };
+  createdAt: number;
+  updatedAt: number;
+  nextRun?: number;
+  lastRun?: ScheduleRunSummary;
+  runCount: number;
+}

package/src/client/lib/sessionApi.ts

@@ -0,0 +1,58 @@
+import { randomUUID } from '@/lib/utils';
+import type { ChatMessage, MessageBlock } from '@/hooks/useConversation';
+
+/** Authenticated fetch with bearer token + timeout. Throws on !ok. */
+export async function apiFetch(
+  path: string,
+  getToken: () => Promise<string | null>,
+  init?: RequestInit & { timeoutMs?: number },
+) {
+  const token = await getToken();
+  if (!token) throw new Error('No auth token');
+  const timeout = init?.timeoutMs ?? 15_000;
+  const controller = new AbortController();
+  if (init?.signal) init.signal.addEventListener('abort', () => controller.abort());
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetch(path, {
+      ...init,
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${token}`, ...init?.headers },
+    });
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+    return res;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Normalize a /api/sessions/:id/messages payload into ChatMessage[]. */
+export function historyToMessages(data: { format: string; messages: any[] }): ChatMessage[] {
+  // Our own clean format
+  if (data.format === 'conv') {
+    return (data.messages as ChatMessage[]).filter((m) => m.blocks?.length > 0);
+  }
+
+  // Fallback: Claude's JSONL format
+  const result: ChatMessage[] = [];
+  for (const m of data.messages) {
+    const payload = m.message as any;
+    if (!payload?.content) continue;
+    const blocks: MessageBlock[] = [];
+    for (const block of payload.content) {
+      if (block.type === 'text' && block.text) blocks.push({ type: 'text', text: block.text });
+      else if (block.type === 'tool_use')
+        blocks.push({ type: 'tool_use', tool: block.name, toolUseId: block.id, input: block.input });
+      else if (block.type === 'tool_result') {
+        const output = Array.isArray(block.content)
+          ? block.content.map((c: any) => c.text ?? '').join('')
+          : String(block.content ?? '');
+        blocks.push({ type: 'tool_result', toolUseId: String(block.tool_use_id), output });
+      }
+    }
+    if (blocks.length > 0) {
+      result.push({ id: m.uuid || randomUUID(), role: m.type === 'user' ? 'user' : 'assistant', blocks });
+    }
+  }
+  return result;
+}