@jlongo78/agent-spaces 0.9.8 → 0.9.9

package/.next/standalone/src/app/api/workspaces/[id]/todos/[todoId]/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { ensureInitialized } from '@/lib/db/init';
+import { updateWorkspaceTodo, deleteWorkspaceTodo } from '@/lib/db/queries';
+
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; todoId: string }> }
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const { id, todoId } = await params;
+    const wsId = parseInt(id, 10);
+    const tid = parseInt(todoId, 10);
+    if (!Number.isFinite(wsId) || !Number.isFinite(tid)) {
+      return NextResponse.json({ error: 'invalid workspace or todo id' }, { status: 400 });
+    }
+    const body = await request.json().catch(() => null);
+    if (!body || (body.text === undefined && body.completed === undefined)) {
+      return NextResponse.json({ error: 'text or completed required' }, { status: 400 });
+    }
+    try {
+      const updated = updateWorkspaceTodo(wsId, tid, {
+        text: typeof body.text === 'string' ? body.text : undefined,
+        completed: typeof body.completed === 'boolean' ? body.completed : undefined,
+      });
+      if (!updated) {
+        return NextResponse.json({ error: 'not found' }, { status: 404 });
+      }
+      return NextResponse.json(updated);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'update failed';
+      return NextResponse.json({ error: message }, { status: 400 });
+    }
+  });
+}
+
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; todoId: string }> }
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const { id, todoId } = await params;
+    const wsId = parseInt(id, 10);
+    const tid = parseInt(todoId, 10);
+    if (!Number.isFinite(wsId) || !Number.isFinite(tid)) {
+      return NextResponse.json({ error: 'invalid workspace or todo id' }, { status: 400 });
+    }
+    deleteWorkspaceTodo(wsId, tid);
+    return NextResponse.json({ ok: true });
+  });
+}

package/.next/standalone/src/app/api/workspaces/[id]/todos/route.ts

@@ -0,0 +1,43 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { ensureInitialized } from '@/lib/db/init';
+import { getWorkspaceTodos, addWorkspaceTodo } from '@/lib/db/queries';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const { id } = await params;
+    const wsId = parseInt(id, 10);
+    if (!Number.isFinite(wsId)) {
+      return NextResponse.json({ error: 'invalid workspace id' }, { status: 400 });
+    }
+    const todos = getWorkspaceTodos(wsId);
+    return NextResponse.json(todos);
+  });
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const { id } = await params;
+    const wsId = parseInt(id, 10);
+    if (!Number.isFinite(wsId)) {
+      return NextResponse.json({ error: 'invalid workspace id' }, { status: 400 });
+    }
+    const body = await request.json().catch(() => null);
+    const text = typeof body?.text === 'string' ? body.text : '';
+    if (!text.trim()) {
+      return NextResponse.json({ error: 'text is required' }, { status: 400 });
+    }
+    const todo = addWorkspaceTodo(wsId, text);
+    return NextResponse.json(todo, { status: 201 });
+  });
+}

package/.next/standalone/src/components/claude/claude-usage-strip.tsx

@@ -0,0 +1,175 @@
+'use client';
+
+import { useEffect, useRef, useState } from 'react';
+import { Zap, LogIn } from 'lucide-react';
+import { useClaudeUsage } from '@/hooks/use-claude-usage';
+import type { RateLimit } from '@/types/claude';
+
+interface Props {
+  enabled: boolean;
+}
+
+function utilizationColor(pct: number | null): string {
+  if (pct == null) return '#52525b'; // zinc-600 — unknown
+  if (pct <= 70) return '#22c55e';    // green-500
+  if (pct <= 90) return '#f59e0b';    // amber-500
+  return '#ef4444';                    // red-500
+}
+
+function formatReset(resetsAt: string | null): string {
+  if (!resetsAt) return '';
+  const ms = new Date(resetsAt).getTime() - Date.now();
+  if (ms <= 0) return 'now';
+  const h = Math.floor(ms / 3_600_000);
+  const m = Math.floor((ms % 3_600_000) / 60_000);
+  if (h >= 24) {
+    const d = Math.floor(h / 24);
+    const rh = h - d * 24;
+    return `${d}d ${rh}h`;
+  }
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+
+function Bar({ label, limit }: { label: string; limit: RateLimit | null | undefined }) {
+  if (!limit || limit.utilization == null) return null;
+  const pct = Math.min(100, Math.max(0, limit.utilization));
+  const color = utilizationColor(pct);
+  const reset = formatReset(limit.resets_at);
+  return (
+    <div
+      className="flex items-center gap-1.5 text-[10px]"
+      title={reset ? `${label}: ${Math.floor(pct)}% used · resets in ${reset}` : `${label}: ${Math.floor(pct)}% used`}
+    >
+      <span className="text-zinc-400 font-medium">{label}</span>
+      <div className="w-12 h-1 bg-zinc-800 rounded-full overflow-hidden">
+        <div
+          className="h-full transition-all"
+          style={{ width: `${pct}%`, backgroundColor: color }}
+        />
+      </div>
+      <span className="text-zinc-500 tabular-nums w-7 text-right">{Math.floor(pct)}%</span>
+    </div>
+  );
+}
+
+export function ClaudeUsageStrip({ enabled }: Props) {
+  const response = useClaudeUsage(enabled);
+  const [expanded, setExpanded] = useState(false);
+  const popoverRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!expanded) return;
+    function handleClick(e: MouseEvent) {
+      if (popoverRef.current && !popoverRef.current.contains(e.target as Node)) {
+        setExpanded(false);
+      }
+    }
+    document.addEventListener('mousedown', handleClick);
+    return () => document.removeEventListener('mousedown', handleClick);
+  }, [expanded]);
+
+  if (!enabled || !response) return null;
+
+  if (response.status === 'unauthenticated' || response.status === 'expired') {
+    return (
+      <div
+        className="flex items-center gap-1.5 px-2 py-1 text-[10px] text-zinc-500 border border-zinc-800 rounded-md"
+        title={response.status === 'expired' ? 'OAuth token expired — run any Claude Code command to refresh' : 'No Claude.ai credentials found'}
+      >
+        <LogIn className="w-3 h-3" />
+        sign in via Claude Code
+      </div>
+    );
+  }
+
+  if (response.status === 'upstream_error') {
+    return null; // Silent — per spec.
+  }
+
+  const { data } = response;
+  const extra = data.extra_usage;
+  const hasOverage = !!(extra?.is_enabled && extra?.used_credits && extra.used_credits > 0);
+
+  return (
+    <div className="relative">
+      <button
+        onClick={() => setExpanded(v => !v)}
+        className="flex items-center gap-2.5 px-2.5 py-1 border border-zinc-800 rounded-md hover:border-zinc-700 transition-colors"
+        title="Click for full usage detail"
+      >
+        <Zap className="w-3 h-3 text-amber-400" />
+        <Bar label="5h" limit={data.five_hour} />
+        <Bar label="7d" limit={data.seven_day} />
+        <Bar label="Opus" limit={data.seven_day_opus} />
+        <Bar label="Sonnet" limit={data.seven_day_sonnet} />
+        {hasOverage && extra?.used_credits != null && (
+          <span className="text-[10px] text-amber-400 border-l border-zinc-800 pl-2">
+            +${extra.used_credits.toFixed(2)} overage
+          </span>
+        )}
+      </button>
+
+      {expanded && (
+        <div
+          ref={popoverRef}
+          className="absolute top-full right-0 mt-1.5 z-50 w-80 p-3 bg-zinc-900 border border-zinc-700 rounded-md shadow-xl"
+        >
+          <div className="text-[10px] uppercase tracking-wider text-zinc-500 font-medium mb-2">
+            Plan Usage
+          </div>
+          <div className="space-y-2">
+            <ExpandedRow label="5-hour window" limit={data.five_hour} />
+            <ExpandedRow label="7-day (overall)" limit={data.seven_day} />
+            <ExpandedRow label="7-day · Opus" limit={data.seven_day_opus} />
+            <ExpandedRow label="7-day · Sonnet" limit={data.seven_day_sonnet} />
+            <ExpandedRow label="7-day · OAuth apps" limit={data.seven_day_oauth_apps} />
+          </div>
+          {extra?.is_enabled && (
+            <div className="mt-3 pt-3 border-t border-zinc-800">
+              <div className="text-[10px] uppercase tracking-wider text-zinc-500 font-medium mb-1.5">
+                Overage credits
+              </div>
+              <div className="text-xs text-zinc-300">
+                {extra.used_credits != null ? `$${extra.used_credits.toFixed(2)}` : '—'}
+                {extra.monthly_limit != null && (
+                  <span className="text-zinc-500"> / ${extra.monthly_limit.toFixed(2)} monthly</span>
+                )}
+              </div>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function ExpandedRow({ label, limit }: { label: string; limit: RateLimit | null | undefined }) {
+  if (!limit || limit.utilization == null) {
+    return (
+      <div className="flex items-center justify-between text-xs">
+        <span className="text-zinc-400">{label}</span>
+        <span className="text-zinc-600">—</span>
+      </div>
+    );
+  }
+  const pct = Math.min(100, Math.max(0, limit.utilization));
+  const color = utilizationColor(pct);
+  const reset = formatReset(limit.resets_at);
+  return (
+    <div>
+      <div className="flex items-center justify-between text-xs mb-1">
+        <span className="text-zinc-300">{label}</span>
+        <span className="text-zinc-500 tabular-nums">
+          {Math.floor(pct)}%{reset && <span className="ml-1.5 text-zinc-600">· {reset}</span>}
+        </span>
+      </div>
+      <div className="h-1.5 bg-zinc-800 rounded-full overflow-hidden">
+        <div
+          className="h-full transition-all"
+          style={{ width: `${pct}%`, backgroundColor: color }}
+        />
+      </div>
+    </div>
+  );
+}

package/.next/standalone/src/components/workspace/workspace-todos.tsx

@@ -0,0 +1,265 @@
+'use client';
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Check, Plus, X } from 'lucide-react';
+import { api } from '@/lib/api';
+import type { Workspace, WorkspaceTodo } from '@/types/claude';
+
+export function WorkspaceTodos({ workspace }: { workspace: Workspace | null }) {
+  const workspaceId = workspace?.id ?? null;
+  const color = workspace?.color ?? '#6366f1';
+
+  const [todos, setTodos] = useState<WorkspaceTodo[]>([]);
+  const [adding, setAdding] = useState(false);
+  const [addInput, setAddInput] = useState('');
+  const [editingId, setEditingId] = useState<number | null>(null);
+  const [editText, setEditText] = useState('');
+  const addInputRef = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    if (workspaceId == null) { setTodos([]); return; }
+    let cancelled = false;
+    fetch(api(`/api/workspaces/${workspaceId}/todos`))
+      .then(r => r.json())
+      .then((data: WorkspaceTodo[]) => { if (!cancelled) setTodos(Array.isArray(data) ? data : []); })
+      .catch(() => { if (!cancelled) setTodos([]); });
+    return () => { cancelled = true; };
+  }, [workspaceId]);
+
+  const addTodo = useCallback(async () => {
+    const text = addInput.trim();
+    if (!text || workspaceId == null) { setAddInput(''); setAdding(false); return; }
+
+    const tempId = -Date.now();
+    const temp: WorkspaceTodo = {
+      id: tempId,
+      workspaceId,
+      text,
+      completed: false,
+      sortOrder: Number.MAX_SAFE_INTEGER,
+      created: new Date().toISOString(),
+      completedAt: null,
+    };
+    setTodos(prev => [...prev, temp]);
+    setAddInput('');
+    addInputRef.current?.focus();
+
+    try {
+      const res = await fetch(api(`/api/workspaces/${workspaceId}/todos`), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text }),
+      });
+      if (!res.ok) throw new Error(await res.text());
+      const real: WorkspaceTodo = await res.json();
+      setTodos(prev => prev.map(t => t.id === tempId ? real : t));
+    } catch (err) {
+      console.error('failed to add todo', err);
+      setTodos(prev => prev.filter(t => t.id !== tempId));
+    }
+  }, [addInput, workspaceId]);
+
+  const toggleTodo = useCallback(async (todo: WorkspaceTodo) => {
+    if (workspaceId == null) return;
+    const next = !todo.completed;
+    setTodos(prev => prev.map(t => t.id === todo.id
+      ? { ...t, completed: next, completedAt: next ? new Date().toISOString() : null }
+      : t
+    ));
+    try {
+      const res = await fetch(api(`/api/workspaces/${workspaceId}/todos/${todo.id}`), {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ completed: next }),
+      });
+      if (!res.ok) throw new Error();
+      const real: WorkspaceTodo = await res.json();
+      setTodos(prev => prev.map(t => t.id === todo.id ? real : t));
+    } catch {
+      setTodos(prev => prev.map(t => t.id === todo.id ? todo : t));
+    }
+  }, [workspaceId]);
+
+  const deleteTodo = useCallback(async (todo: WorkspaceTodo) => {
+    if (workspaceId == null) return;
+    // Snapshot the original index so we can restore in place on failure,
+    // rather than appending to the end.
+    let originalIndex = -1;
+    setTodos(prev => {
+      originalIndex = prev.findIndex(t => t.id === todo.id);
+      return prev.filter(t => t.id !== todo.id);
+    });
+    try {
+      const res = await fetch(api(`/api/workspaces/${workspaceId}/todos/${todo.id}`), { method: 'DELETE' });
+      if (!res.ok) throw new Error();
+    } catch {
+      setTodos(prev => {
+        if (originalIndex < 0 || prev.some(t => t.id === todo.id)) return prev;
+        const next = [...prev];
+        next.splice(Math.min(originalIndex, next.length), 0, todo);
+        return next;
+      });
+    }
+  }, [workspaceId]);
+
+  const saveEdit = useCallback(async (todo: WorkspaceTodo) => {
+    const text = editText.trim();
+    setEditingId(null);
+    if (!text || text === todo.text || workspaceId == null) return;
+    setTodos(prev => prev.map(t => t.id === todo.id ? { ...t, text } : t));
+    try {
+      const res = await fetch(api(`/api/workspaces/${workspaceId}/todos/${todo.id}`), {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text }),
+      });
+      if (!res.ok) throw new Error();
+    } catch {
+      setTodos(prev => prev.map(t => t.id === todo.id ? { ...t, text: todo.text } : t));
+    }
+  }, [editText, workspaceId]);
+
+  const clearCompleted = useCallback(async () => {
+    if (workspaceId == null) return;
+    const done = todos.filter(t => t.completed);
+    if (done.length === 0) return;
+    setTodos(prev => prev.filter(t => !t.completed));
+    const results = await Promise.allSettled(
+      done.map(t => fetch(api(`/api/workspaces/${workspaceId}/todos/${t.id}`), { method: 'DELETE' }))
+    );
+    if (results.some(r => r.status === 'rejected' || (r.status === 'fulfilled' && !r.value.ok))) {
+      // Reconcile by refetching
+      fetch(api(`/api/workspaces/${workspaceId}/todos`))
+        .then(r => r.json())
+        .then((data: WorkspaceTodo[]) => setTodos(Array.isArray(data) ? data : []))
+        .catch(() => {});
+    }
+  }, [todos, workspaceId]);
+
+  const sorted = [...todos].sort((a, b) => {
+    if (a.completed !== b.completed) return a.completed ? 1 : -1;
+    if (!a.completed) return a.sortOrder - b.sortOrder;
+    const aT = a.completedAt ?? '';
+    const bT = b.completedAt ?? '';
+    return bT.localeCompare(aT);
+  });
+  const completedCount = sorted.filter(t => t.completed).length;
+
+  const chipHeight = 'h-7';
+  const chipShape = `${chipHeight} rounded-full inline-flex items-center gap-1.5 pl-2 pr-1 py-1 text-xs border whitespace-nowrap`;
+
+  return (
+    <div className="border-b border-zinc-800 bg-zinc-900/40 px-4 py-2 flex-shrink-0">
+      <div className="flex flex-wrap items-center gap-1.5 max-h-[30vh] overflow-y-auto">
+        {sorted.map(todo => {
+          const isEditing = editingId === todo.id;
+          const activeStyle = {
+            backgroundColor: `${color}22`,
+            borderColor: `${color}66`,
+            color: color,
+          };
+          const doneStyle = {
+            backgroundColor: 'rgba(39, 39, 42, 0.5)',
+            borderColor: 'rgba(63, 63, 70, 0.5)',
+            color: 'rgb(113, 113, 122)',
+          };
+          const style = todo.completed ? doneStyle : activeStyle;
+
+          return (
+            <div
+              key={todo.id}
+              className={`group ${chipShape}`}
+              style={style}
+            >
+              <button
+                onClick={() => toggleTodo(todo)}
+                className="w-3.5 h-3.5 rounded-full border-2 flex items-center justify-center flex-shrink-0 transition-colors"
+                style={{
+                  borderColor: todo.completed ? color : `${color}aa`,
+                  backgroundColor: todo.completed ? color : 'transparent',
+                }}
+                aria-label={todo.completed ? 'Mark incomplete' : 'Mark complete'}
+              >
+                {todo.completed && <Check className="w-2.5 h-2.5 text-white" />}
+              </button>
+
+              {isEditing ? (
+                <input
+                  autoFocus
+                  value={editText}
+                  onChange={e => setEditText(e.target.value)}
+                  onBlur={() => saveEdit(todo)}
+                  onKeyDown={e => {
+                    if (e.key === 'Enter') saveEdit(todo);
+                    if (e.key === 'Escape') setEditingId(null);
+                  }}
+                  className="bg-transparent focus:outline-none max-w-[240px]"
+                  style={{ color: 'inherit' }}
+                />
+              ) : (
+                <button
+                  onClick={() => { setEditingId(todo.id); setEditText(todo.text); }}
+                  className={`text-left truncate max-w-[200px] ${todo.completed ? 'line-through' : ''}`}
+                  style={{ color: 'inherit' }}
+                >
+                  {todo.text}
+                </button>
+              )}
+
+              <button
+                onClick={() => deleteTodo(todo)}
+                className="opacity-0 group-hover:opacity-100 transition-opacity rounded-full p-0.5 hover:bg-black/20 flex-shrink-0"
+                style={{ color: 'inherit' }}
+                aria-label="Delete todo"
+              >
+                <X className="w-3 h-3" />
+              </button>
+            </div>
+          );
+        })}
+
+        {/* Add chip */}
+        {adding ? (
+          <div className={`${chipShape} border-dashed border-zinc-600 text-zinc-300`}>
+            <Plus className="w-3 h-3 text-zinc-500 flex-shrink-0" />
+            <input
+              ref={addInputRef}
+              autoFocus
+              value={addInput}
+              onChange={e => setAddInput(e.target.value)}
+              onKeyDown={e => {
+                if (e.key === 'Enter') addTodo();
+                if (e.key === 'Escape') { setAddInput(''); setAdding(false); }
+              }}
+              onBlur={() => {
+                if (addInput.trim()) addTodo();
+                else setAdding(false);
+              }}
+              placeholder="todo…"
+              className="bg-transparent focus:outline-none text-xs placeholder:text-zinc-600 max-w-[200px]"
+            />
+          </div>
+        ) : (
+          <button
+            onClick={() => { if (workspaceId != null) setAdding(true); }}
+            disabled={workspaceId == null}
+            className={`${chipHeight} rounded-full inline-flex items-center gap-1 px-3 py-1 text-xs border border-dashed border-zinc-700 text-zinc-500 hover:text-zinc-300 hover:border-zinc-500 transition-colors disabled:opacity-50 disabled:cursor-not-allowed whitespace-nowrap`}
+          >
+            <Plus className="w-3 h-3" />
+            {workspaceId == null ? 'Select a workspace' : 'add todo'}
+          </button>
+        )}
+
+        {/* Clear completed */}
+        {completedCount > 0 && (
+          <button
+            onClick={clearCompleted}
+            className="ml-auto text-[10px] text-zinc-500 hover:text-zinc-300 px-2 py-1 transition-colors whitespace-nowrap"
+          >
+            clear {completedCount} done
+          </button>
+        )}
+      </div>
+    </div>
+  );
+}

package/.next/standalone/src/hooks/use-claude-usage.ts

@@ -0,0 +1,66 @@
+'use client';
+
+import { useEffect, useRef, useState } from 'react';
+import { api } from '@/lib/api';
+import type { UsageResponse } from '@/types/claude';
+
+const POLL_INTERVAL_MS = 60_000;
+const TRANSIENT_TOLERANCE = 2; // consecutive bad polls before we clobber good data
+
+export function useClaudeUsage(enabled: boolean): UsageResponse | null {
+  const [response, setResponse] = useState<UsageResponse | null>(null);
+  const badPollsRef = useRef(0);
+
+  useEffect(() => {
+    if (!enabled) {
+      badPollsRef.current = 0;
+      return;
+    }
+
+    let cancelled = false;
+
+    async function load() {
+      try {
+        const res = await fetch(api('/api/claude/usage'));
+        if (!res.ok || cancelled) return;
+        const data: UsageResponse = await res.json();
+        if (cancelled) return;
+
+        const isTransient = data.status === 'upstream_error' || data.status === 'expired';
+        if (isTransient) {
+          badPollsRef.current += 1;
+          setResponse(prev => {
+            // If we already have a good response, keep it until the bad state persists.
+            if (prev?.status === 'ok' && badPollsRef.current < TRANSIENT_TOLERANCE) {
+              return prev;
+            }
+            return data;
+          });
+        } else {
+          badPollsRef.current = 0;
+          setResponse(data);
+        }
+      } catch {
+        // Network error — treat as transient.
+        if (cancelled) return;
+        badPollsRef.current += 1;
+        setResponse(prev => {
+          if (prev?.status === 'ok' && badPollsRef.current < TRANSIENT_TOLERANCE) {
+            return prev;
+          }
+          return { status: 'upstream_error' };
+        });
+      }
+    }
+
+    load();
+    const timer = setInterval(load, POLL_INTERVAL_MS);
+
+    return () => {
+      cancelled = true;
+      clearInterval(timer);
+    };
+  }, [enabled]);
+
+  return response;
+}

package/.next/standalone/src/lib/claude/credentials.ts

@@ -0,0 +1,36 @@
+import path from 'path';
+import os from 'os';
+import { readFile } from 'fs/promises';
+
+export interface ClaudeAiOAuthTokens {
+  accessToken: string;
+  refreshToken: string | null;
+  expiresAt: number | null; // epoch ms
+  scopes?: string[];
+}
+
+function getCredentialsPath(): string {
+  const home = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  return path.join(home, '.credentials.json');
+}
+
+/**
+ * Reads ~/.claude/.credentials.json and returns the claudeAiOauth block.
+ * Returns null on any read/parse failure or if the block is absent.
+ */
+export async function readClaudeAiOauthTokens(): Promise<ClaudeAiOAuthTokens | null> {
+  try {
+    const raw = await readFile(getCredentialsPath(), 'utf8');
+    const parsed = JSON.parse(raw) as { claudeAiOauth?: ClaudeAiOAuthTokens };
+    const tokens = parsed.claudeAiOauth;
+    if (!tokens?.accessToken) return null;
+    return tokens;
+  } catch {
+    return null;
+  }
+}
+
+export function isTokenExpired(tokens: ClaudeAiOAuthTokens, nowMs = Date.now()): boolean {
+  if (!tokens.expiresAt) return false; // no expiry set → treat as valid
+  return nowMs >= tokens.expiresAt;
+}