@columenlabs/lumen-ui 0.0.0-stage → 0.2.0

package/dist/route-error.js

@@ -0,0 +1,229 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The router's error page for every app (Logs, and Feed before it, showed a
+// bare "Something went wrong / Show error" that looked like a crash).
+//
+// The usual cause is a tab still running the build before a deploy: its next page asks for files
+// the server no longer has. Vite then fires `vite:preloadError`; cancelling that event (as this did
+// before) makes the import resolve to `undefined`, so the page threw "Cannot read properties of
+// undefined (reading 'LogsPage')", which nothing recognised as a new build and the error page
+// showed until the reload landed. Now the event is never cancelled, the import fails as what it
+// is, and the page shows "Updating" while the tab reloads onto the new build.
+//
+// Any other error is tried once more on its own; if it fails again the page says so with Try again
+// and Reload. Every error is sent to the Worker (`POST /api/client-error`), which writes it to
+// Workers Logs, so it can be read there.
+import { useRouter } from '@tanstack/react-router';
+import { ChevronRight, RefreshCw, RotateCcw, TriangleAlert } from 'lucide-react';
+import { useEffect, useState } from 'react';
+import { toast } from 'sonner';
+import { Button } from './ui/button.js';
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from './ui/collapsible.js';
+import { Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle, } from './ui/empty.js';
+import { Spinner } from './ui/spinner.js';
+const KEY = 'lumen_new_build_reload';
+const GAP_MS = 10_000;
+/** A dynamic import that failed to load (Chrome, Firefox, Safari wording), not a page's own bug. */
+export function isStaleBuildError(error) {
+    const message = error instanceof Error ? error.message : '';
+    return (message.startsWith('Failed to fetch dynamically imported module') ||
+        message.startsWith('error loading dynamically imported module') ||
+        message.startsWith('Importing a module script failed') ||
+        message.includes('Unable to preload CSS') ||
+        // Safari, when a missing file comes back as a page instead of a script.
+        message.includes('is not a valid JavaScript MIME type'));
+}
+/** A reload this tab has already started; anything failing meanwhile waits for it. */
+let reloadStarted = false;
+/** Whether this tab has not reloaded for a new build in the last 10 s. */
+function mayReload() {
+    if (reloadStarted)
+        return true;
+    try {
+        return Date.now() - Number(sessionStorage.getItem(KEY) ?? 0) >= GAP_MS;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Reloads onto the new build unless it already did in the last 10 s (a file that is truly missing
+ * then shows its error instead of reloading forever); says whether a reload is under way.
+ */
+export function reloadForNewBuild() {
+    if (reloadStarted)
+        return true;
+    if (!mayReload())
+        return false;
+    try {
+        sessionStorage.setItem(KEY, String(Date.now()));
+    }
+    catch {
+        // No sessionStorage (private mode): reload anyway.
+    }
+    reloadStarted = true;
+    window.location.reload();
+    return true;
+}
+/**
+ * Fetches every lazy page of this build once the tab is idle, so a later click never asks the
+ * server for files a deploy has since replaced. Without it each deploy (many a day) made the next
+ * click on a page not yet opened reload the whole tab, which cut the assistant answer short.
+ */
+/** How long after load the other pages' files start loading. */
+const PRELOAD_AFTER_MS = 8_000;
+function preloadPages(router) {
+    const run = () => {
+        for (const route of Object.values(router.routesById)) {
+            const preload = route.options.component
+                ?.preload;
+            preload?.().catch(() => { });
+        }
+    };
+    // Not at load: the page's own first render and data come first. At load a phone was still
+    // building the page, and every other page's files were fetched and run beside it (2026-10-22).
+    const idle = () => setTimeout(() => 'requestIdleCallback' in window ? window.requestIdleCallback(run) : setTimeout(run, 1000), PRELOAD_AFTER_MS);
+    if (document.readyState === 'complete')
+        idle();
+    else
+        window.addEventListener('load', idle, { once: true });
+}
+/**
+ * Keeps an open tab working across deploys: every page's files load up front (when a router is
+ * given), and a file a deploy removed reloads the tab onto the new build. The event is never
+ * cancelled: cancelling it makes the import resolve to nothing, which the page then hits as a bug.
+ */
+export function watchNewBuilds(router) {
+    window.addEventListener('vite:preloadError', () => {
+        reloadForNewBuild();
+    });
+    if (router)
+        preloadPages(router);
+    watchDeploys();
+}
+/** How often a tab in view asks whether a deploy has replaced its build. */
+const CHECK_MS = 10 * 60_000;
+/** This tab's entry script, the hashed file every build names afresh. */
+const entryOf = (html) => html.match(/<script[^>]*type="module"[^>]*src="([^"]+)"/)?.[1] ?? null;
+/** Whether the app's page now names another entry script than the one this tab runs. */
+async function newBuildOut() {
+    const mine = document
+        .querySelector('script[type="module"][src]')
+        ?.getAttribute('src');
+    if (!mine)
+        return false;
+    try {
+        const res = await fetch(import.meta.env.BASE_URL ?? '/', { cache: 'no-store' });
+        if (!res.ok || !res.headers.get('content-type')?.includes('text/html'))
+            return false;
+        const live = entryOf(await res.text());
+        return !!live && live !== mine;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A tab left open across deploys keeps running its old build until a file it asks for is gone,
+ * so it can be a day behind and talk to a Worker that expects the new one (* The assistant on a phone tab from yesterday said the app had no workspaces). The tab asks whether a
+ * deploy has replaced its build when it comes back into view and every 10 minutes while in view,
+ * and offers Reload once per new build. It never reloads on its own: that would cut work short.
+ */
+function watchDeploys() {
+    let offered = false;
+    let busy = false;
+    const check = async () => {
+        if (offered || busy || document.visibilityState !== 'visible')
+            return;
+        busy = true;
+        try {
+            if (!(await newBuildOut()))
+                return;
+            offered = true;
+            toast('A new version is ready', {
+                duration: Number.POSITIVE_INFINITY,
+                action: { label: 'Reload', onClick: () => window.location.reload() },
+            });
+        }
+        finally {
+            busy = false;
+        }
+    };
+    document.addEventListener('visibilitychange', () => void check());
+    setInterval(() => void check(), CHECK_MS);
+}
+/** When each error was last sent from each place, so the same one is sent once. */
+const sent = new Map();
+/** Last error tried again on its own, so a page that keeps failing is tried once, not forever. */
+let retried = null;
+/**
+ * Sends a page error to the Worker's log; never throws, never retries. `where` names the card or
+ * panel that caught it (LumenBoundary); left out, the whole page did.
+ */
+export function reportError(error, outcome, where) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    // React renders a failing part twice before giving up: one line per error and place.
+    const key = `${where ?? 'page'} ${outcome} ${err.message}`;
+    if (Date.now() - (sent.get(key) ?? 0) < GAP_MS)
+        return;
+    sent.set(key, Date.now());
+    const body = JSON.stringify({
+        message: err.message.slice(0, 500),
+        stack: (err.stack ?? '').slice(0, 2000),
+        path: window.location.pathname + window.location.search,
+        build: import.meta.url.split('/').pop() ?? '',
+        outcome,
+        where: where ?? 'page',
+    });
+    try {
+        fetch('/api/client-error', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body,
+            keepalive: true,
+        }).catch(() => { });
+    }
+    catch {
+        // Reporting must never break the page.
+    }
+}
+/**
+ * One centred message with its buttons, the same on every app: the whole page's (RouteError) or
+ * one card's or panel's (LumenBoundary, `what` "card" or "panel", smaller).
+ */
+export function ErrorPage({ error, onRetry, what = 'page', }) {
+    const message = error instanceof Error ? error.message : String(error);
+    const stack = error instanceof Error ? error.stack : undefined;
+    return (_jsxs(Empty, { className: what === 'page' ? 'min-h-[50vh]' : 'gap-3 p-4 md:p-6', children: [_jsxs(EmptyHeader, { children: [_jsx(EmptyMedia, { variant: "icon", children: _jsx(TriangleAlert, {}) }), _jsxs(EmptyTitle, { children: ["This ", what, " hit an error"] }), _jsx(EmptyDescription, { children: "Try again, or reload the app. It has been logged." })] }), _jsxs(EmptyContent, { children: [_jsxs("div", { className: "flex gap-2", children: [_jsxs(Button, { size: "sm", onClick: onRetry, children: [_jsx(RotateCcw, {}), "Try again"] }), _jsxs(Button, { size: "sm", variant: "outline", onClick: () => window.location.reload(), children: [_jsx(RefreshCw, {}), "Reload"] })] }), _jsxs(Collapsible, { className: "w-full text-left", children: [_jsxs(CollapsibleTrigger, { className: "group flex items-center gap-1 text-xs text-muted-foreground", children: [_jsx(ChevronRight, { className: "size-3 transition-transform group-data-[state=open]:rotate-90" }), "Details"] }), _jsx(CollapsibleContent, { children: _jsx("pre", { className: "mt-2 max-h-48 overflow-auto rounded-md bg-muted p-2 text-left text-xs whitespace-pre-wrap", children: stack ?? message }) })] })] })] }));
+}
+/**
+ * The router's error page: "Updating" while the tab reloads onto a new build; any other error is
+ * tried once more on its own, then shown with Try again and Reload. Each one is logged.
+ */
+export function RouteError({ error, reset }) {
+    const router = useRouter();
+    const [mode] = useState(() => {
+        if (isStaleBuildError(error) && mayReload())
+            return 'reload';
+        const message = error instanceof Error ? error.message : String(error);
+        if (!retried || retried.message !== message || Date.now() - retried.at > GAP_MS)
+            return 'retry';
+        return 'shown';
+    });
+    const retry = () => {
+        reset();
+        router.invalidate();
+    };
+    // biome-ignore lint/correctness/useExhaustiveDependencies: once per error page.
+    useEffect(() => {
+        reportError(error, mode);
+        if (mode === 'reload')
+            reloadForNewBuild();
+        if (mode === 'retry') {
+            retried = { message: error instanceof Error ? error.message : String(error), at: Date.now() };
+            retry();
+        }
+    }, []);
+    if (mode === 'shown')
+        return _jsx(ErrorPage, { error: error, onRetry: retry });
+    return (_jsx(Empty, { className: "min-h-[50vh]", children: _jsxs(EmptyHeader, { children: [_jsx(EmptyMedia, { variant: "icon", children: _jsx(Spinner, {}) }), _jsx(EmptyDescription, { children: mode === 'reload' ? 'Updating to the new version' : 'Loading' })] }) }));
+}

package/dist/schedules.d.ts

@@ -0,0 +1,88 @@
+import { type ReactNode } from 'react';
+export interface ScheduleRun {
+    at: string;
+    ok: boolean;
+    detail: string;
+}
+/** One schedule as an app's API returns it. */
+export interface ScheduleItem {
+    id: string;
+    name: string;
+    on: boolean;
+    /** Minutes between runs. */
+    every: number;
+    /** `HH:MM`: the window's start (`window`) or the time of day (`daily`). */
+    from: string;
+    /** `HH:MM`: the window's end (`window`). */
+    to: string;
+    /** Days it runs, 0 = Sunday (`window`). */
+    days: number[];
+    tz: string;
+    /** `window`: a window and days; `outside`: whenever a window is closed; `daily`: once a day; `reports`: on report days. */
+    kind: 'window' | 'outside' | 'daily' | 'reports';
+    /** The Every choices in minutes (none: it runs once a day). */
+    choices: number[];
+    /** Fixed words for when it runs, for kinds whose times can't be changed. */
+    when?: string;
+    /** What it does: the data it inspects, processing, enrichment, output and cost. */
+    about: {
+        inspects: string;
+        processes: string;
+        enriches?: string;
+        outputs: string;
+        cost?: string;
+    };
+    last: ScheduleRun | null;
+    next: string | null;
+    /** Why it can't run now (a service not connected). */
+    waiting: string | null;
+    /** A the assistant brief: what it asks, its spend cap, Notify and its last run's chat. */
+    brief?: {
+        /** `outlook`: the market outlook, whose instructions are fixed; `brief`: the person's own. */
+        kind: 'outlook' | 'brief';
+        instructions: string;
+        cap_usd: number;
+        notify: boolean;
+        last: {
+            chat: string;
+            usd: number;
+        } | null;
+    };
+}
+export type ScheduleChange = Partial<Pick<ScheduleItem, 'on' | 'every' | 'from' | 'to' | 'days' | 'tz'>>;
+export interface BriefChange {
+    instructions?: string;
+    cap_usd?: number;
+    notify?: boolean;
+}
+/** How an app saves, adds and removes the assistant briefs (each change returns once the list is fresh). */
+export interface BriefActions {
+    save: (id: string, change: BriefChange) => Promise<void>;
+    /** Adds a brief; returns its schedule's id. */
+    create: (brief: {
+        name: string;
+        instructions: string;
+    }) => Promise<string>;
+    remove: (id: string) => Promise<void>;
+}
+type Save = (id: string, change: ScheduleChange) => Promise<void>;
+/** Opens the app's Logs filtered to one schedule's runs. */
+type Runs = (id: string) => void;
+/** The app's view of one schedule's newest runs (from its Logs). */
+type Recent = (id: string) => ReactNode;
+/** The Settings ▸ Schedules section's body. */
+export declare function SchedulesSection({ schedules, error, onSave, onRun, onRuns, recent, briefs, }: {
+    /** Undefined while loading. */
+    schedules?: ScheduleItem[];
+    error?: string | null;
+    onSave: Save;
+    /** Runs it now; returns the run. */
+    onRun: (id: string) => Promise<ScheduleRun | null>;
+    /** Opens Logs filtered to a schedule's runs; adds Runs buttons. */
+    onRuns?: Runs;
+    /** Draws a schedule's newest runs in its editor (else its last run). */
+    recent?: Recent;
+    /** The assistant briefs: their own fields in the editor, and ＋ Brief. */
+    briefs?: BriefActions;
+}): import("react").JSX.Element;
+export {};

package/dist/schedules.js

@@ -0,0 +1,221 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AlertTriangleIcon, CheckIcon, ListIcon, MessageSquareIcon, PlayIcon, PlusIcon, RefreshCwIcon, Trash2Icon, } from 'lucide-react';
+import { Fragment, useState } from 'react';
+import { useAssistant, useAssistantName } from './assistant-context.js';
+// Settings ▸ Schedules: the work an app runs for the person on its own, one
+// section for every app. An app passes its schedules (each says how it is shaped: a window, the
+// rest of the time, once a day or on report days) and how to save and run one; the shell draws the
+// list and the editor sheet. An app without schedules adds no section. The assistant briefs are schedules too: ✦ rows with their instructions, spend cap and Notify switch, ＋ Brief
+// to add one, and their last run's chat opens in the assistant.
+import { LumenConfirm } from './confirm.js';
+import { useIsMobile } from './hooks/use-mobile.js';
+import { LumenSelector } from './lumen-selector.js';
+import { IconButton } from './page.js';
+import { usePrefs } from './prefs.js';
+import { useShell } from './shell.js';
+import { Badge } from './ui/badge.js';
+import { Button } from './ui/button.js';
+import { Input } from './ui/input.js';
+import { Label } from './ui/label.js';
+import { Sheet, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, } from './ui/sheet.js';
+import { Skeleton } from './ui/skeleton.js';
+import { Switch } from './ui/switch.js';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from './ui/table.js';
+import { Textarea } from './ui/textarea.js';
+import { ToggleGroup, ToggleGroupItem } from './ui/toggle-group.js';
+const DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const ZONES = [
+    'America/Los_Angeles',
+    'America/Denver',
+    'America/Chicago',
+    'America/New_York',
+    'Europe/London',
+    'Asia/Kolkata',
+    'UTC',
+];
+const everyText = (m) => (m >= 1440 ? '1 day' : m >= 60 ? `${m / 60} h` : `${m} min`);
+/** `13:00` → `1:00 PM`. */
+const clockText = (hhmm) => {
+    const [h = 0, m = 0] = hhmm.split(':').map(Number);
+    return `${h % 12 || 12}:${String(m).padStart(2, '0')} ${h < 12 ? 'AM' : 'PM'}`;
+};
+const daysText = (days) => {
+    const d = [...days].sort();
+    if (d.length === 7)
+        return 'Every day';
+    if (d.join() === '1,2,3,4,5')
+        return 'Weekdays';
+    return d.map((x) => DAYS[x]).join(', ');
+};
+const zoneText = (tz) => tz.split('/').pop()?.replace('_', ' ') ?? tz;
+/** When it runs, in words. */
+function when(s) {
+    if (s.when)
+        return s.when;
+    if (s.kind === 'window')
+        return `${daysText(s.days)} ${clockText(s.from)}–${clockText(s.to)} ${zoneText(s.tz)}`;
+    return `Daily at ${clockText(s.from)} ${zoneText(s.tz)}`;
+}
+function useTime() {
+    const { timeZone } = usePrefs();
+    return (iso) => new Date(iso).toLocaleString('en-US', {
+        timeZone,
+        weekday: 'short',
+        hour: 'numeric',
+        minute: '2-digit',
+    });
+}
+function Last({ s, compact = false }) {
+    const time = useTime();
+    if (!s.last)
+        return _jsx("span", { className: "text-muted-foreground", children: "Not yet" });
+    return (_jsxs("span", { className: `flex min-w-0 items-center gap-1.5 ${s.last.ok ? '' : 'text-loss'}`, children: [s.last.ok ? (_jsx(CheckIcon, { className: "size-3.5 shrink-0 text-gain" })) : (_jsx(AlertTriangleIcon, { className: "size-3.5 shrink-0" })), _jsx("span", { className: "truncate", title: s.last.detail, children: compact ? time(s.last.at) : `${time(s.last.at)} · ${s.last.detail}` })] }));
+}
+function OnSwitch({ s, onSave }) {
+    const [pending, setPending] = useState(false);
+    return (_jsx(Switch, { "aria-label": `${s.name} on`, checked: s.on, disabled: pending, onClick: (e) => e.stopPropagation(), onCheckedChange: (on) => {
+            setPending(true);
+            void onSave(s.id, { on }).finally(() => setPending(false));
+        } }));
+}
+function Row({ label, children }) {
+    return (_jsxs("div", { className: "grid grid-cols-1 gap-1.5", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: label }), children] }));
+}
+/** At (a daily schedule), Days and Time zone: the schedule editor's and New brief's. */
+function TimeFields({ kind, draft, set, }) {
+    const zones = !draft.tz || ZONES.includes(draft.tz) ? ZONES : [draft.tz, ...ZONES];
+    return (_jsxs(_Fragment, { children: [kind === 'daily' ? (_jsx(Row, { label: "At", children: _jsx(Input, { type: "time", "aria-label": "At", className: "num w-32", value: draft.from, onChange: (e) => set({ from: e.target.value }) }) })) : null, _jsx(Row, { label: "Days", children: _jsx(ToggleGroup, { type: "multiple", variant: "outline", size: "sm", spacing: 1, className: "w-full", value: (draft.days ?? []).map(String), onValueChange: (v) => v.length && set({ days: v.map(Number) }), children: [1, 2, 3, 4, 5, 6, 0].map((d) => (_jsx(ToggleGroupItem, { value: String(d), className: "flex-1 px-0", children: DAYS[d] }, d))) }) }), _jsx(Row, { label: "Time zone", children: _jsx(LumenSelector, { label: "Time zone", className: "w-full", options: zones.map((z) => ({ value: z, label: z.replace('_', ' ') })), value: draft.tz, onChange: (tz) => set({ tz }) }) })] }));
+}
+/** One schedule's settings, with Run now. */
+function Editor({ s, onSave, onRun, onRuns, recent, briefs, onClose, }) {
+    const assistantName = useAssistantName();
+    const time = useTime();
+    const assistant = useAssistant();
+    const { closeSettings } = useShell();
+    const [brief, setBrief] = useState({
+        instructions: s.brief?.instructions,
+        cap_usd: s.brief?.cap_usd,
+        notify: s.brief?.notify,
+    });
+    const [confirm, setConfirm] = useState(false);
+    const own = s.brief?.kind === 'brief';
+    const last = s.brief?.last;
+    const [draft, setDraft] = useState({
+        on: s.on,
+        every: s.every,
+        from: s.from,
+        to: s.to,
+        days: s.days,
+        tz: s.tz,
+    });
+    const [busy, setBusy] = useState(null);
+    const [error, setError] = useState(null);
+    const [ran, setRan] = useState(null);
+    const set = (c) => setDraft((d) => ({ ...d, ...c }));
+    const act = async (what) => {
+        setBusy(what);
+        setError(null);
+        try {
+            if (what === 'save') {
+                if (s.brief && briefs) {
+                    const changed = {
+                        ...(own && brief.instructions?.trim() !== s.brief.instructions
+                            ? { instructions: brief.instructions?.trim() }
+                            : {}),
+                        ...(brief.cap_usd !== s.brief.cap_usd ? { cap_usd: brief.cap_usd } : {}),
+                        ...(brief.notify !== s.brief.notify ? { notify: brief.notify } : {}),
+                    };
+                    if (Object.keys(changed).length)
+                        await briefs.save(s.id, changed);
+                }
+                await onSave(s.id, draft);
+                onClose();
+            }
+            else
+                setRan(await onRun(s.id));
+        }
+        catch (err) {
+            setError(err.message);
+        }
+        finally {
+            setBusy(null);
+        }
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs(SheetHeader, { children: [_jsx(SheetTitle, { children: s.name }), _jsx(SheetDescription, { children: when(s) })] }), _jsxs("div", { className: "grid grid-cols-1 gap-5 overflow-y-auto px-4", children: [_jsx("dl", { className: "grid grid-cols-[auto_1fr] gap-x-3 gap-y-1.5 text-xs", children: [
+                            ['Inspects', s.about.inspects],
+                            ['Processes', s.about.processes],
+                            ['Enriches', s.about.enriches],
+                            ['Outputs', s.about.outputs],
+                            ['Cost', s.about.cost],
+                        ]
+                            .filter(([, v]) => v)
+                            .map(([k, v]) => (_jsxs(Fragment, { children: [_jsx("dt", { className: "text-muted-foreground", children: k }), _jsx("dd", { children: v })] }, k))) }), s.brief ? (_jsx(Row, { label: "Instructions", children: own ? (_jsx(Textarea, { "aria-label": "Instructions", rows: 5, maxLength: 4000, value: brief.instructions ?? '', onChange: (e) => setBrief((b) => ({ ...b, instructions: e.target.value })) })) : (_jsx("p", { className: "text-sm text-muted-foreground", children: s.brief.instructions })) })) : null, _jsxs("div", { className: "flex items-center justify-between", children: [_jsx(Label, { htmlFor: "sched-on", children: "On" }), _jsx(Switch, { id: "sched-on", checked: draft.on, onCheckedChange: (on) => set({ on }) })] }), s.choices.length ? (_jsx(Row, { label: "Every", children: _jsx(ToggleGroup, { type: "single", variant: "outline", size: "sm", value: String(draft.every), onValueChange: (v) => v && set({ every: Number(v) }), children: s.choices.map((m) => (_jsx(ToggleGroupItem, { value: String(m), className: "num", children: everyText(m) }, m))) }) })) : null, s.kind === 'window' ? (_jsx(_Fragment, { children: _jsx(Row, { label: "Window", children: _jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Input, { type: "time", "aria-label": "From", className: "num w-32", value: draft.from, onChange: (e) => set({ from: e.target.value }) }), _jsx("span", { className: "text-muted-foreground", children: "to" }), _jsx(Input, { type: "time", "aria-label": "To", className: "num w-32", value: draft.to, onChange: (e) => set({ to: e.target.value }) })] }) }) })) : null, s.kind === 'window' || s.kind === 'daily' ? (_jsx(TimeFields, { kind: s.kind, draft: draft, set: set })) : null, s.brief ? (_jsxs(_Fragment, { children: [_jsx(Row, { label: "Spend cap a run", children: _jsxs("div", { className: "flex items-center gap-2", children: [_jsx("span", { className: "text-muted-foreground", children: "$" }), _jsx(Input, { type: "number", "aria-label": "Spend cap a run, USD", className: "num w-24", min: 0.05, max: 5, step: 0.05, value: brief.cap_usd ?? '', onChange: (e) => setBrief((b) => ({ ...b, cap_usd: Number(e.target.value) })) })] }) }), _jsxs("div", { className: "flex items-center justify-between", children: [_jsx(Label, { htmlFor: "brief-notify", children: "Notify when ready" }), _jsx(Switch, { id: "brief-notify", checked: brief.notify ?? false, onCheckedChange: (notify) => setBrief((b) => ({ ...b, notify })) })] })] })) : null, s.waiting ? (_jsx("p", { className: "text-sm text-warning", children: s.waiting })) : s.next ? (_jsxs("p", { className: "text-sm text-muted-foreground", children: ["Next run ", time(s.next)] })) : null, recent && !ran ? (_jsx(Row, { label: "Last runs", children: recent(s.id) })) : (_jsx(Row, { label: "Last run", children: _jsx("span", { className: "text-sm", children: _jsx(Last, { s: ran ? { ...s, last: ran } : s }) }) })), last && assistant ? (_jsxs(Button, { variant: "outline", size: "sm", className: "justify-self-start", onClick: () => {
+                            assistant.loadChat(last.chat);
+                            assistant.setOpen(true);
+                            onClose();
+                            closeSettings();
+                        }, children: [_jsx(MessageSquareIcon, {}), "Open last run in ", assistantName, " \u00B7 ", _jsxs("span", { className: "num", children: ["$", last.usd.toFixed(2)] })] })) : null, error ? (_jsx("p", { role: "alert", className: "text-xs text-loss", children: error })) : null] }), _jsxs(SheetFooter, { className: "flex-row justify-end", children: [own && briefs ? (_jsxs(_Fragment, { children: [_jsx(IconButton, { icon: Trash2Icon, label: "Delete brief", variant: "destructive", disabled: busy !== null, onClick: () => setConfirm(true) }), _jsx(LumenConfirm, { open: confirm, onOpenChange: setConfirm, title: `Delete ${s.name.replace(/^✦ /, '')}?`, description: `Its schedule stops. Chats from its runs stay in ${assistantName}.`, onConfirm: () => {
+                                    setBusy('save');
+                                    void briefs
+                                        .remove(s.id)
+                                        .then(onClose)
+                                        .catch((err) => setError(err.message))
+                                        .finally(() => setBusy(null));
+                                } })] })) : null, onRuns ? (_jsx(IconButton, { icon: ListIcon, label: "All runs", variant: "outline", className: "mr-auto", onClick: () => onRuns(s.id) })) : null, _jsx(IconButton, { icon: busy === 'run' ? RefreshCwIcon : PlayIcon, busy: busy === 'run', label: busy === 'run' ? 'Running…' : 'Run now', variant: "outline", disabled: busy !== null || Boolean(s.waiting), onClick: () => void act('run') }), _jsxs(Button, { size: "sm", disabled: busy !== null, onClick: () => void act('save'), children: [_jsx(CheckIcon, {}), "Save"] })] })] }));
+}
+/** The Settings ▸ Schedules section's body. */
+export function SchedulesSection({ schedules, error, onSave, onRun, onRuns, recent, briefs, }) {
+    const isMobile = useIsMobile();
+    const { closeSettings } = useShell();
+    const [open, setOpen] = useState(null);
+    const [adding, setAdding] = useState(false);
+    // Logs is a page: close the editor and Settings on the way there.
+    const toRuns = onRuns
+        ? (id) => {
+            setOpen(null);
+            closeSettings();
+            onRuns(id);
+        }
+        : undefined;
+    const editing = schedules?.find((s) => s.id === open);
+    const { timeZone } = usePrefs();
+    if (error)
+        return _jsx("p", { className: "text-sm text-loss", children: error });
+    if (!schedules)
+        return _jsx(Skeleton, { className: "h-48 w-full" });
+    return (_jsxs(_Fragment, { children: [isMobile ? (_jsx("div", { className: "grid grid-cols-1 divide-y rounded-lg border", children: schedules.map((s) => (_jsxs("button", { type: "button", className: "grid grid-cols-[1fr_auto] items-center gap-x-3 gap-y-1 p-3 text-left hover:bg-muted/50", onClick: () => setOpen(s.id), children: [_jsx("span", { className: "font-medium", children: s.name }), _jsx(OnSwitch, { s: s, onSave: onSave }), _jsxs("span", { className: "col-span-2 text-xs text-muted-foreground", children: [s.kind === 'daily' ? '' : `Every ${everyText(s.every)} · `, when(s)] }), _jsx("span", { className: "col-span-2 text-xs", children: s.waiting ? _jsx("span", { className: "text-warning", children: s.waiting }) : _jsx(Last, { s: s }) })] }, s.id))) })) : (_jsx("div", { className: "overflow-x-auto overflow-y-hidden rounded-lg border", children: _jsxs(Table, { children: [_jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { className: "w-12", children: "On" }), _jsx(TableHead, { children: "Schedule" }), _jsx(TableHead, { children: "When" }), _jsx(TableHead, { children: "Last run" }), onRuns ? _jsx(TableHead, { className: "w-0" }) : null] }) }), _jsx(TableBody, { children: schedules.map((s) => (_jsxs(TableRow, { className: "cursor-pointer", onClick: () => setOpen(s.id), children: [_jsx(TableCell, { children: _jsx(OnSwitch, { s: s, onSave: onSave }) }), _jsx(TableCell, { className: "font-medium", children: s.name }), _jsxs(TableCell, { className: "max-w-36 truncate text-muted-foreground", children: [s.kind === 'daily' ? '' : `Every ${everyText(s.every)} · `, when(s)] }), _jsx(TableCell, { className: "max-w-48", children: s.waiting ? (_jsx(Badge, { variant: "outline", className: "text-warning", title: s.waiting, children: "Not connected" })) : (_jsx(Last, { s: s, compact: true })) }), onRuns ? (_jsx(TableCell, { children: _jsx(IconButton, { icon: ListIcon, label: `${s.name} runs`, onClick: (e) => {
+                                                e.stopPropagation();
+                                                toRuns?.(s.id);
+                                            } }) })) : null] }, s.id))) })] }) })), _jsxs("div", { className: "flex flex-wrap items-center justify-between gap-2", children: [_jsxs("p", { className: "text-xs text-muted-foreground", children: ["Times shown in ", timeZone.replace('_', ' '), ". Each run is a line in Logs."] }), briefs ? (_jsxs(Button, { variant: "outline", size: "sm", onClick: () => setAdding(true), children: [_jsx(PlusIcon, {}), "Brief"] })) : null] }), briefs ? (_jsx(Sheet, { open: adding, onOpenChange: setAdding, children: _jsx(SheetContent, { side: isMobile ? 'bottom' : 'right', className: "gap-4", children: _jsx(NewBrief, { create: async (b, time) => {
+                            const id = await briefs.create(b);
+                            await onSave(id, time);
+                            return id;
+                        }, onDone: () => setAdding(false) }) }) })) : null, _jsx(Sheet, { open: Boolean(editing), onOpenChange: (o) => !o && setOpen(null), children: _jsx(SheetContent, { side: isMobile ? 'bottom' : 'right', className: "gap-4", children: editing ? (_jsx(Editor, { s: editing, onSave: onSave, onRun: onRun, onRuns: toRuns, recent: recent, briefs: briefs, onClose: () => setOpen(null) }, editing.id)) : null }) })] }));
+}
+/** ＋ Brief: a name, what the assistant should work out, and when (daily at 8:00 AM Pacific on weekdays to start). */
+function NewBrief({ create, onDone, }) {
+    const assistantName = useAssistantName();
+    const [name, setName] = useState('');
+    const [instructions, setInstructions] = useState('');
+    const [time, setTime] = useState({
+        from: '08:00',
+        days: [1, 2, 3, 4, 5],
+        tz: 'America/Los_Angeles',
+    });
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    const add = async () => {
+        setBusy(true);
+        setError(null);
+        try {
+            onDone(await create({ name: name.trim(), instructions: instructions.trim() }, time));
+        }
+        catch (err) {
+            setError(err.message);
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs(SheetHeader, { children: [_jsx(SheetTitle, { children: "New brief" }), _jsxs(SheetDescription, { children: [assistantName, " works it out on a schedule, reads only, and sends it when it is ready."] })] }), _jsxs("div", { className: "grid grid-cols-1 gap-5 overflow-y-auto px-4", children: [_jsx(Row, { label: "Name", children: _jsx(Input, { "aria-label": "Name", maxLength: 60, placeholder: "Options brief", value: name, onChange: (e) => setName(e.target.value) }) }), _jsx(Row, { label: "Instructions", children: _jsx(Textarea, { "aria-label": "Instructions", rows: 6, maxLength: 4000, placeholder: `What ${assistantName} should look at and report, e.g. my short options expiring this week with their delta and P&L.`, value: instructions, onChange: (e) => setInstructions(e.target.value) }) }), _jsx(TimeFields, { kind: "daily", draft: time, set: (c) => setTime((t) => ({ ...t, ...c })) }), error ? (_jsx("p", { role: "alert", className: "text-xs text-loss", children: error })) : null] }), _jsx(SheetFooter, { className: "flex-row justify-end", children: _jsxs(Button, { size: "sm", disabled: busy || !name.trim() || !instructions.trim(), onClick: () => void add(), children: [_jsx(PlusIcon, {}), "Add brief"] }) })] }));
+}

package/dist/settings.d.ts

@@ -0,0 +1,51 @@
+import { SunIcon } from 'lucide-react';
+import { type ReactNode } from 'react';
+/** A section an app adds to Settings, listed under the app's name. */
+export interface SettingsSectionDef {
+    id: string;
+    title: string;
+    icon: typeof SunIcon;
+    description?: ReactNode;
+    content: ReactNode;
+    /** Listed indented under the section before it (the assistant ▸ Model providers). */
+    sub?: boolean;
+    /** What the section's footer holds (a status line, Revert and Save). The footer is pinned under
+     *  every section, empty when it has nothing; `SettingsFooter` fills it too. */
+    footer?: ReactNode;
+}
+/** Renders its children in the section header, right of the title. */
+export declare function SettingsActions({ children }: {
+    children: ReactNode;
+}): import("react").ReactPortal | null;
+/** Renders its children in the open section's footer, from anywhere in the section's content. */
+export declare function SettingsFooter({ children }: {
+    children: ReactNode;
+}): import("react").ReactPortal | null;
+/** One setting: title and description on the left, its control on the right. */
+export declare function SettingRow({ label, description, htmlFor, children, }: {
+    label: string;
+    description?: ReactNode;
+    htmlFor?: string;
+    children: ReactNode;
+}): import("react").JSX.Element | null;
+/** Light, dark or system: in Settings with labels, in the profile menu as icons with tooltips. */
+export declare function ThemeToggle({ compact }: {
+    compact?: boolean;
+}): import("react").JSX.Element;
+/** Every Settings section in the order the dialog lists them: General, the product's, the app's. */
+export declare function allSettings(profile: ReactNode | undefined, shared?: SettingsSectionDef[], sections?: SettingsSectionDef[]): SettingsSectionDef[];
+export declare function LumenSettings({ open, section, onOpen, onClose, appLabel, profile, sections, shared, sharedLabel, }: {
+    open: boolean;
+    /** The section shown; unknown ids show Profile. */
+    section: string;
+    onOpen: (section: string) => void;
+    onClose: () => void;
+    /** The app's name, heading its own sections. */
+    appLabel: string;
+    /** Profile's content, the first General section; none without it. */
+    profile?: ReactNode;
+    sections?: SettingsSectionDef[];
+    /** Sections the product adds to every app (the assistant), listed under `sharedLabel` after General. */
+    shared?: SettingsSectionDef[];
+    sharedLabel?: string;
+}): import("react").JSX.Element;