@hanzo/rooms 0.1.0

package/dist/bots/Bots.js

@@ -0,0 +1,456 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The Bots Room.
+//
+// Bots are autonomous workers for your organization: each has a model,
+// instructions, tools, and a record of everything it has accomplished.
+//
+// In live mode, this connects directly to your organization's bots and sessions.
+// When visiting without an account, an interactive Example Workspace lets you
+// explore how bots use computers to automate sales, triage inboxes, and review code.
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Monitor, Plus, Search, Send, Trash2 } from 'lucide-react';
+import { useIam } from '@hanzo/iam/react';
+import { useAi, ENSO } from '../lib/ai.js';
+import { say } from '../failure.js';
+import { Input, Text, XStack, YStack } from '@hanzo/gui';
+import { Button } from '@hanzo/ui';
+import { Lights } from './Lights.js';
+import { Face } from './face.js';
+import { Runtime } from './runtime.js';
+import { DIM, FAINT, GROUND, INK, LINE, RAISED, SURFACE } from './ink.js';
+import { BARE, BOXED, CARD, CLIP, GHOST, LABEL, NOTE, TAB } from './kit.js';
+import { ALWAYS, ONCE, launch, sessions, steer } from './api.js';
+/** How long ago, in the words a roster row has space for. */
+function when(iso) {
+    if (!iso)
+        return '';
+    const t = new Date(iso);
+    if (Number.isNaN(t.getTime()))
+        return '';
+    const days = Math.floor((Date.now() - t.getTime()) / 86_400_000);
+    if (days === 0)
+        return t.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    if (days === 1)
+        return 'Yesterday';
+    if (days < 7)
+        return t.toLocaleDateString([], { weekday: 'short' });
+    return t.toLocaleDateString([], { month: 'short', day: 'numeric' });
+}
+/** What a run cost, from the fields the run actually recorded. */
+function cost(r) {
+    const tokens = (r.promptTokens ?? 0) + (r.completionTokens ?? 0);
+    return [r.model, r.durationMs ? `${(r.durationMs / 1000).toFixed(1)}s` : '', tokens ? `${tokens} tokens` : '']
+        .filter(Boolean)
+        .join(' · ');
+}
+/** When something happened, as a number to sort by. */
+const at = (iso) => {
+    const t = iso ? new Date(iso).getTime() : NaN;
+    return Number.isNaN(t) ? 0 : t;
+};
+/** A session the platform still considers open. Only these can be steered:
+ *  the route takes a command for a finished session and records it against a
+ *  log nothing is reading, so a control on one is a control over nothing. */
+const open = (s) => s.status === 'running' || s.status === 'paused';
+/** A Bot's recorded runs as the turns they were. */
+function turns(detail) {
+    return (detail?.recentRuns ?? []).flatMap((r) => {
+        const when = at(r.createdAt);
+        const out = [];
+        if (r.input)
+            out.push({ id: `${r.id}-in`, at: when, who: 'you', text: r.input });
+        out.push({
+            id: `${r.id}-out`,
+            at: when + 1,
+            who: 'bot',
+            text: r.error || r.output || 'This run recorded no output.',
+            note: cost(r),
+            failed: Boolean(r.error),
+        });
+        return out;
+    });
+}
+const EXAMPLE_BOTS = [
+    {
+        id: 'bot-sales-outbound',
+        avatar: '/bots/sales-outbound.png',
+        name: 'Sales Outbound',
+        description: 'Prospecting, lead qualification, and cold outreach',
+        model: 'claude-3-5-sonnet',
+        executionMode: ALWAYS,
+        schedule: '0 9 * * 1-5',
+        updatedAt: new Date(Date.now() - 1000 * 60 * 12).toISOString(),
+    },
+    {
+        id: 'bot-chief',
+        avatar: '/bots/chief.png',
+        name: 'Chief',
+        description: 'Executive briefing, team updates, and orchestration',
+        model: 'claude-3-5-sonnet',
+        executionMode: ALWAYS,
+        schedule: '0 8 * * *',
+        updatedAt: new Date(Date.now() - 1000 * 60 * 45).toISOString(),
+    },
+    {
+        id: 'bot-inbox-manager',
+        avatar: '/bots/inbox-manager.png',
+        name: 'Inbox Manager',
+        description: 'Triage email, draft responses, and surface urgent items',
+        model: 'claude-3-5-sonnet',
+        executionMode: ALWAYS,
+        schedule: '*/15 * * * *',
+        updatedAt: new Date(Date.now() - 1000 * 60 * 90).toISOString(),
+    },
+    {
+        id: 'bot-code-reviewer',
+        name: 'Code Reviewer',
+        description: 'Analyze pull requests, check test suites, and style',
+        model: 'claude-3-5-sonnet',
+        executionMode: ONCE,
+        updatedAt: new Date(Date.now() - 1000 * 60 * 180).toISOString(),
+    },
+    {
+        id: 'bot-research-analyst',
+        name: 'Research Analyst',
+        description: 'Track industry trends, competitive moves, and filings',
+        model: 'claude-3-5-sonnet',
+        executionMode: ONCE,
+        updatedAt: new Date(Date.now() - 1000 * 60 * 300).toISOString(),
+    },
+];
+const EXAMPLE_ACTIONS = {
+    'Sales Outbound': {
+        title: 'Computer',
+        status: 'Done',
+        summary: 'Reviewed 52 new outbound leads across target accounts. Qualified 18 high-fit profiles and prepared tailored email drafts.',
+        tasks: [
+            'Verified domain deliverability and prospect contact records',
+            'Extracted buyer intent signals from company milestones',
+            'Queued 18 personalized emails for Armand’s review',
+        ],
+    },
+    'Chief': {
+        title: 'Computer',
+        status: 'Done',
+        summary: 'Compiled morning briefing, synced calendar events, and highlighted team priorities.',
+        tasks: [
+            'Aggregated GitHub pull requests and release milestones',
+            'Organized 3 priority decisions for today',
+            'Synchronized executive calendar and shared prep notes',
+        ],
+    },
+    'Inbox Manager': {
+        title: 'Computer',
+        status: 'Done',
+        summary: 'Triaged 34 unread messages, flagged 4 urgent requests, and drafted replies for approval.',
+        tasks: [
+            'Categorized incoming inquiries by priority and topic',
+            'Drafted context-aware responses citing knowledge base docs',
+            'Scheduled followup reminders for unresolved partner threads',
+        ],
+    },
+    'Code Reviewer': {
+        title: 'Computer',
+        status: 'Done',
+        summary: 'Analyzed pull request #142 for architectural consistency, security considerations, and edge cases.',
+        tasks: [
+            'Verified zero memory leaks and confirmed strict typing',
+            'Validated test suite passes across all target environments',
+            'Posted inline review suggestions for error handling',
+        ],
+    },
+    'Research Analyst': {
+        title: 'Computer',
+        status: 'Done',
+        summary: 'Indexed frontier model benchmarks, competitive releases, and performance telemetry.',
+        tasks: [
+            'Indexed latest release notes and technical benchmarks',
+            'Created comparative capability matrix',
+            'Generated summary digest for the engineering team',
+        ],
+    },
+};
+export function Bots() {
+    const { client, ready } = useAi();
+    const { user, isAuthenticated } = useIam();
+    // A client EXISTS signed out — `useAi` hands back an anonymous one so the
+    // free chat lane works — so holding one is not proof of a reader. Every read
+    // below is org-scoped and answers 403 without a session, so this is the gate.
+    const live = Boolean(client && isAuthenticated && ready);
+    const [roster, setRoster] = useState([]);
+    const [rosterFailed, setRosterFailed] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [query, setQuery] = useState('');
+    const [picked, setPicked] = useState('');
+    const [detail, setDetail] = useState(null);
+    const [own, setOwn] = useState([]);
+    const [draft, setDraft] = useState('');
+    const [trialTurns, setTrialTurns] = useState([]);
+    const [running, setRunning] = useState(false);
+    const [failed, setFailed] = useState(null);
+    const [pane, setPane] = useState(false);
+    const [making, setMaking] = useState(false);
+    const [cron, setCron] = useState('');
+    const read = useCallback(async () => {
+        if (!client)
+            return;
+        setLoading(true);
+        try {
+            setRoster(await client.agents.list());
+            setRosterFailed(null);
+        }
+        catch (e) {
+            setRosterFailed(say(e, 'this org’s bots'));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client]);
+    useEffect(() => {
+        if (live)
+            void read();
+    }, [live, read]);
+    // In live mode, use platform roster. When exploring as a visitor, show example workspace bots.
+    const activeRoster = useMemo(() => {
+        if (live && roster.length > 0)
+            return roster;
+        if (!live)
+            return EXAMPLE_BOTS;
+        return roster;
+    }, [live, roster]);
+    const shown = useMemo(() => {
+        const q = query.trim().toLowerCase();
+        if (!q)
+            return activeRoster;
+        return activeRoster.filter((b) => b.name.toLowerCase().includes(q) || (b.description ?? '').toLowerCase().includes(q));
+    }, [activeRoster, query]);
+    const bot = useMemo(() => activeRoster.find((b) => b.name === picked) ?? shown[0] ?? activeRoster[0] ?? null, [activeRoster, shown, picked]);
+    // Its record and its work, re-read after anything this room does to it —
+    // the platform's answer is the only account of what happened.
+    const refresh = useCallback(async () => {
+        if (!client || !bot)
+            return;
+        const [d, s] = await Promise.allSettled([client.agents.get(bot.name), sessions(client, bot.name)]);
+        if (d.status === 'fulfilled')
+            setDetail(d.value);
+        setOwn(s.status === 'fulfilled' ? s.value : []);
+    }, [client, bot]);
+    useEffect(() => {
+        if (!client || !bot) {
+            setDetail(null);
+            setOwn([]);
+            return;
+        }
+        const stop = new AbortController();
+        setCron(bot.schedule ?? '');
+        client.agents
+            .get(bot.name, { signal: stop.signal })
+            .then(setDetail)
+            .catch(() => {
+            if (!stop.signal.aborted)
+                setDetail(null);
+        });
+        // No limit of its own. The route has no per-agent filter, so the page it
+        // answers is the ORG's and the narrowing happens after — ask for twenty
+        // and a bot whose work is older than the org's twenty newest sessions
+        // reads as having none.
+        sessions(client, bot.name, undefined, stop.signal)
+            .then(setOwn)
+            .catch(() => setOwn([]));
+        return () => stop.abort();
+    }, [client, bot]);
+    // ONE STREAM, IN THE ORDER IT HAPPENED. A run and a session are two records
+    // of the same Bot working, so they are read together and sorted by the clock
+    // the platform put on them — newest at the bottom, where a reader who has
+    // just asked for something is looking.
+    const computerAction = bot ? EXAMPLE_ACTIONS[bot.name] ?? null : null;
+    const stream = useMemo(() => {
+        if (!live) {
+            return trialTurns.map((t) => ({ at: t.at, key: t.id, turn: t, session: null }));
+        }
+        return [
+            ...turns(detail).map((t) => ({ at: t.at, key: t.id, turn: t, session: null })),
+            ...own.map((s) => ({ at: at(s.updatedAt || s.startedAt || s.createdAt), key: s.id, turn: null, session: s })),
+        ].sort((a, b) => a.at - b.at);
+    }, [live, detail, own, trialTurns]);
+    const always = bot?.executionMode === ALWAYS;
+    // Newest last means the newest is off-screen on a Bot with any history, so
+    // the stream opens where a reader is looking rather than at its oldest run.
+    const foot = useRef(null);
+    useEffect(() => {
+        foot.current?.scrollIntoView({ block: 'end' });
+    }, [stream]);
+    /** One task, run now. */
+    const run = useCallback(async (e) => {
+        if (e)
+            e.preventDefault();
+        const input = draft.trim();
+        if (!bot || !input || running)
+            return;
+        if (!live) {
+            setDraft('');
+            const userTurn = { id: `trial-${Date.now()}-in`, at: Date.now(), who: 'you', text: input };
+            setTrialTurns((prev) => [...prev, userTurn]);
+            setTimeout(() => {
+                const botTurn = {
+                    id: `trial-${Date.now()}-out`,
+                    at: Date.now(),
+                    who: 'bot',
+                    text: `Received: "${input}". Running on ${bot.model} with computer tools enabled. Sign in to your organization to deploy bots into production.`,
+                    note: `${bot.model} · 0.8s · 142 tokens`,
+                };
+                setTrialTurns((prev) => [...prev, botTurn]);
+            }, 400);
+            return;
+        }
+        if (!client)
+            return;
+        setRunning(true);
+        setFailed(null);
+        try {
+            await client.agents.run(bot.name, input);
+            setDraft('');
+            await refresh();
+        }
+        catch (err) {
+            setFailed(err instanceof Error ? err.message : String(err));
+        }
+        finally {
+            setRunning(false);
+        }
+    }, [live, client, bot, draft, running, refresh]);
+    /** Stays up, or runs when asked. The platform REFUSES long-running without a
+     *  cron — measured, 400 naming the field — so the cron is asked for beside
+     *  the switch rather than guessed at here. */
+    const keepUp = useCallback(async () => {
+        if (!client || !bot)
+            return;
+        setFailed(null);
+        try {
+            const saved = always
+                ? await client.agents.update(bot.name, { executionMode: ONCE })
+                : await client.agents.update(bot.name, { executionMode: ALWAYS, schedule: cron.trim() });
+            setRoster((r) => r.map((b) => (b.name === saved.name ? saved : b)));
+        }
+        catch (e) {
+            setFailed(e instanceof Error ? e.message : String(e));
+        }
+    }, [client, bot, always, cron]);
+    const retire = useCallback(async () => {
+        if (!client || !bot)
+            return;
+        setFailed(null);
+        try {
+            await client.agents.delete(bot.name);
+            setPicked('');
+            await read();
+        }
+        catch (e) {
+            setFailed(say(e, 'this bot', 'save'));
+        }
+    }, [client, bot, read]);
+    return (_jsxs(XStack, { width: "100%", height: "100%", overflow: "hidden", bg: GROUND, "$max-lg": { overflowX: 'auto', overflowY: 'hidden' }, "$platform-web": { scrollSnapType: 'x mandatory' }, children: [_jsxs(YStack, { width: 280, minW: 280, height: "100%", bg: GROUND, borderRightWidth: 1, borderColor: LINE, "$max-lg": { width: '85%', maxW: 320 }, "$platform-web": { scrollSnapAlign: 'start' }, children: [_jsxs(XStack, { pt: 16, px: 18, pb: 12, items: "center", justify: "space-between", children: [_jsx(Lights, {}), _jsx(XStack, { ...GHOST, title: live ? 'New bot' : 'Sign in to keep a bot', onClick: () => setMaking((m) => !m), "aria-label": "New bot", "aria-expanded": making, disabled: !live, opacity: live ? 1 : 0.4, children: _jsx(Plus, { size: 18, color: DIM }) })] }), making && live ? (_jsx(Hire, { onDone: async (made) => {
+                            setMaking(false);
+                            setPicked(made.name);
+                            await read();
+                        }, onCancel: () => setMaking(false) })) : null, _jsx(YStack, { px: 14, pb: 12, children: _jsxs(XStack, { items: "center", gap: 8, bg: SURFACE, borderWidth: 1, borderColor: LINE, rounded: 8, px: 12, py: 8, children: [_jsx(Search, { size: 14, color: DIM, "aria-hidden": true }), _jsx(Input, { ...BARE, value: query, onChange: (e) => setQuery(e.target.value), placeholder: "Search", "aria-label": "Search bots", fontSize: "$2", flex: 1, minW: 0 })] }) }), _jsxs(YStack, { "data-hz": "roster", flex: 1, overflowY: "auto", px: 10, gap: 2, children: [live && rosterFailed ? (_jsx(Text, { ...NOTE, children: rosterFailed })) : live && loading && roster.length === 0 ? (_jsx(Text, { ...NOTE, children: "Reading the roster\u2026" })) : live && shown.length === 0 ? (_jsx(Text, { ...NOTE, children: roster.length === 0 ? 'This org keeps no bots yet.' : 'No bot matches that.' })) : null, shown.map((b) => {
+                                const on = bot?.name === b.name;
+                                return (_jsxs(XStack, { render: "button", type: 'button', "data-hz": "bot", "data-name": b.name, "aria-current": on, onClick: () => setPicked(b.name), items: "center", gap: 12, px: 12, py: 10, rounded: 10, bg: on ? SURFACE : 'transparent', borderWidth: 0, cursor: "pointer", width: "100%", children: [_jsx(Face, { bot: b, size: 36 }), _jsxs(YStack, { flex: 1, minW: 0, children: [_jsxs(XStack, { items: "center", justify: "space-between", gap: 8, children: [_jsx(Text, { fontSize: "$2", fontWeight: "600", color: on ? INK : DIM, children: b.name }), _jsx(Text, { fontSize: "$1", color: FAINT, whiteSpace: "nowrap", children: when(b.updatedAt) })] }), _jsx(Text, { ...CLIP, fontSize: "$2", color: DIM, text: "left", children: b.description || `${b.model}${b.runs ? ` · ${b.runs} runs` : ''}` })] })] }, b.id || b.name));
+                            })] }), _jsxs(XStack, { px: 16, py: 14, borderTopWidth: 1, borderColor: LINE, items: "center", gap: 12, children: [_jsx(Text, { "aria-hidden": true, display: "flex", width: 32, height: 32, shrink: 0, rounded: 9999, bg: SURFACE, borderWidth: 1, borderColor: LINE, items: "center", justify: "center", fontSize: "$2", fontWeight: "600", color: DIM, children: (user?.name || (live ? '·' : 'Armand Segall')).trim().charAt(0).toUpperCase() }), _jsxs(YStack, { flex: 1, minW: 0, children: [_jsx(Text, { fontSize: "$2", fontWeight: "600", color: INK, children: user?.name || (live ? 'Signed in' : 'Armand Segall') }), _jsx(Text, { ...CLIP, fontSize: "$1", color: FAINT, children: user?.email || (live ? 'Active Workspace' : 'armand@example.com · Example Workspace') })] })] })] }), _jsxs(YStack, { flex: 1, minW: 0, height: "100%", position: "relative", bg: GROUND, "$max-lg": { width: '100%', minW: '100%', shrink: 0, overflowX: 'hidden' }, "$platform-web": { scrollSnapAlign: 'start' }, children: [_jsxs(XStack, { height: 60, borderBottomWidth: 1, borderColor: LINE, items: "center", justify: "space-between", px: 16, gap: 12, children: [_jsxs(XStack, { items: "center", gap: 10, minW: 0, shrink: 1, children: [bot ? _jsx(Face, { bot: bot, size: 28 }) : null, _jsxs(YStack, { minW: 0, shrink: 1, children: [_jsx(Text, { ...CLIP, "data-hz": "head", fontSize: "$3", fontWeight: "600", color: INK, children: bot?.name || 'No bot' }), _jsx(Text, { ...CLIP, "data-hz": "mode", fontSize: "$1", color: FAINT, children: bot ? `${bot.model} · ${bot.executionMode || ONCE}${bot.schedule ? ` · ${bot.schedule}` : ''}` : '' })] })] }), bot ? (_jsxs(XStack, { items: "center", gap: 8, shrink: 0, children: [!always ? (_jsx(Input, { ...BOXED, "data-hz": "cron", value: cron, onChange: (e) => setCron(e.target.value), placeholder: "0 * * * *", "aria-label": "Schedule, as a 5-field cron", width: 104, fontSize: "$1" })) : null, _jsx(Button, { size: "sm", variant: always ? 'primary' : 'default', rounded: 999, title: always ? 'Run only when asked' : 'Keep this bot up on a schedule', "data-hz": "always", onClick: keepUp, "aria-pressed": always, children: "24/7" }), _jsx(Button, { size: "sm", variant: "primary", title: "Open a session for this bot", "data-hz": "open", onClick: async () => {
+                                            if (!client || !bot)
+                                                return;
+                                            setFailed(null);
+                                            try {
+                                                await launch(client, bot.name, `${bot.name} session`);
+                                                await refresh();
+                                            }
+                                            catch (e) {
+                                                setFailed(e instanceof Error ? e.message : String(e));
+                                            }
+                                        }, children: "Open a session" }), _jsx(XStack, { ...GHOST, title: 'What this bot has', "data-hz": "runtime", onClick: () => setPane((p) => !p), "aria-label": "Runtime", "aria-pressed": pane, bg: pane ? SURFACE : 'transparent', children: _jsx(Monitor, { size: 18, color: pane ? INK : DIM }) }), _jsx(XStack, { ...GHOST, title: 'Retire', "data-hz": "retire", onClick: retire, "aria-label": `Retire ${bot.name}`, children: _jsx(Trash2, { size: 16, color: DIM }) })] })) : null] }), _jsxs(XStack, { flex: 1, minH: 0, children: [_jsxs(YStack, { flex: 1, minW: 0, overflow: "hidden", children: [_jsxs(YStack, { "data-hz": "stream", flex: 1, overflowY: "auto", px: 32, py: 24, gap: 16, children: [!bot ? (_jsx(Text, { ...NOTE, children: live
+                                                    ? 'Nothing is kept yet. A bot is a model, a standing instruction and a record of what it has done — press + to keep one.'
+                                                    : 'Select a bot to begin.' })) : null, bot && detail?.instructions ? (_jsxs(YStack, { ...CARD, children: [_jsx(Text, { ...LABEL, children: "Standing instruction" }), _jsx(Text, { render: "p", fontSize: "$2", lineHeight: "1.3rem", color: DIM, whiteSpace: "pre-wrap", children: detail.instructions })] })) : null, computerAction ? (_jsxs(YStack, { ...CARD, "data-hz": "computer-card", children: [_jsxs(XStack, { items: "center", justify: "space-between", children: [_jsxs(XStack, { items: "center", gap: 8, children: [_jsx(Monitor, { size: 15, color: INK }), _jsx(Text, { fontSize: "$2", fontWeight: "600", color: INK, children: computerAction.title })] }), _jsx(Text, { display: "inline-flex", items: "center", px: 8, py: 2, rounded: 999, fontSize: "$1", fontWeight: "600", bg: SURFACE, color: DIM, borderWidth: 1, borderColor: LINE, children: computerAction.status })] }), _jsx(Text, { render: "p", fontSize: "$2", lineHeight: "1.26rem", color: INK, children: computerAction.summary }), _jsx(YStack, { gap: 5, mt: 4, children: computerAction.tasks.map((task, idx) => (_jsxs(XStack, { items: "center", gap: 8, children: [_jsx(YStack, { width: 4, height: 4, shrink: 0, rounded: 9999, bg: FAINT }), _jsx(Text, { fontSize: "$2", color: DIM, children: task })] }, idx))) })] })) : null, bot && stream.length === 0 && !computerAction ? (_jsx(Text, { ...NOTE, children: "Nothing has been run yet. Ask for something below and the run is recorded here." })) : null, stream.map(({ key, turn, session }) => session ? (_jsx(Live, { session: session, onChange: refresh }, key)) : turn ? (_jsxs(Text, { render: "div", "data-hz": turn.who === 'you' ? 'asked' : 'answered', self: turn.who === 'you' ? 'flex-end' : 'flex-start', maxW: 620, rounded: 14, px: 16, py: 12, fontSize: "$3", lineHeight: "1.35625rem", whiteSpace: "pre-wrap", bg: turn.who === 'you' ? SURFACE : RAISED, borderWidth: 1, borderColor: LINE, color: turn.failed ? DIM : INK, children: [turn.text, turn.note ? (_jsx(Text, { display: "block", mt: 6, fontSize: "$1", lineHeight: "1.0656rem", color: FAINT, children: turn.failed ? `failed · ${turn.note}` : turn.note })) : null] }, key)) : null), _jsx("div", { ref: foot })] }), _jsxs(YStack, { pt: 16, px: 32, pb: 24, children: [failed ? _jsx(Text, { ...NOTE, px: 0, pt: 0, pb: 8, children: failed }) : null, _jsxs(XStack, { render: "form", onSubmit: run, items: "center", gap: 12, bg: SURFACE, borderWidth: 1, borderColor: LINE, rounded: 26, pt: 6, pr: 8, pb: 6, pl: 16, children: [_jsx(Input, { ...BARE, "data-hz": "ask", value: draft, onChange: (e) => setDraft(e.target.value), placeholder: bot ? `Message ${bot.name}` : 'Message bot...', "aria-label": "Task", disabled: !bot || running, flex: 1, fontSize: "$3" }), _jsx(Button, { type: "submit", variant: "primary", size: "icon", rounded: 9999, title: "Run this task", "data-hz": "run", disabled: !bot || running || !draft.trim(), "aria-label": "Run this task", children: _jsx(Send, { size: 16 }) })] }), _jsx(Text, { render: "p", mt: 8, fontSize: "$1", color: FAINT, children: running
+                                                    ? 'Running. The recorded run appears above when the platform answers.'
+                                                    : bot
+                                                        ? `Runs on ${bot.model}, recorded against ${bot.name}.`
+                                                        : '' })] })] }), pane && bot ? _jsx(Runtime, { bot: bot }) : null] })] })] }));
+}
+/**
+ * One session of this Bot's, and — while it is still open — the three things
+ * the route lets you say to it.
+ *
+ * A FINISHED SESSION HAS NO CONTROLS. The route accepts a command for one and
+ * records it against a log nothing is reading, so drawing Pause beside a run
+ * that ended an hour ago is a control over nothing.
+ *
+ * `forwarded` is the platform's own word for whether a runner was listening: a
+ * command is always RECORDED, and only sometimes delivered. Saying which is the
+ * difference between a control and a button that appears to work.
+ */
+function Live({ session, onChange }) {
+    const { client } = useAi();
+    const [said, setSaid] = useState(null);
+    const command = async (verb) => {
+        if (!client)
+            return;
+        try {
+            const r = await steer(client, session.id, verb);
+            setSaid(r.forwarded ? `${verb} delivered` : `${verb} recorded — no runner is attached to this session`);
+            await onChange();
+        }
+        catch (e) {
+            setSaid(say(e, 'this session', 'save'));
+        }
+    };
+    return (_jsxs(YStack, { ...CARD, "data-hz": "session", "data-status": session.status, children: [_jsxs(XStack, { items: "baseline", justify: "space-between", gap: 8, children: [_jsx(Text, { fontSize: "$2", fontWeight: "600", color: INK, children: session.title || 'Session' }), _jsxs(Text, { fontSize: "$1", color: FAINT, children: [session.status, " \u00B7 ", session.events ?? 0, " turns"] })] }), session.lastEvent?.preview ? (_jsx(Text, { ...CLIP, render: "p", fontSize: "$1", lineHeight: "1.03125rem", fontFamily: "$mono", color: FAINT, children: session.lastEvent.preview })) : null, open(session) ? (_jsxs(XStack, { gap: 6, children: [_jsx(Text, { ...TAB, "data-hz": "pause", onClick: () => command('pause'), children: "Pause" }), _jsx(Text, { ...TAB, "data-hz": "resume", onClick: () => command('resume'), children: "Resume" }), _jsx(Text, { ...TAB, "data-hz": "stop", onClick: () => command('stop'), children: "Stop" })] })) : null, said ? _jsx(Text, { render: "p", fontSize: "$1", color: FAINT, children: said }) : null] }));
+}
+/**
+ * Keeping a Bot.
+ *
+ * The model is checked against the gateway's served catalogue at create time,
+ * so the field OFFERS that catalogue rather than a name this file invented: a
+ * model this deployment cannot serve is refused with a 400 naming it, and the
+ * platform's own sentence is what a reader is shown.
+ */
+function Hire({ onDone, onCancel }) {
+    const { client } = useAi();
+    const [name, setName] = useState('');
+    const [model, setModel] = useState(ENSO);
+    const [about, setAbout] = useState('');
+    const [orders, setOrders] = useState('');
+    const [busy, setBusy] = useState(false);
+    const [failed, setFailed] = useState(null);
+    const [served, setServed] = useState([]);
+    useEffect(() => {
+        if (!client)
+            return;
+        const stop = new AbortController();
+        client.models
+            .list({ signal: stop.signal })
+            .then(setServed)
+            .catch(() => setServed([]));
+        return () => stop.abort();
+    }, [client]);
+    return (_jsxs(YStack, { render: "form", onSubmit: async (e) => {
+            e.preventDefault();
+            if (!client || busy || !name.trim())
+                return;
+            setBusy(true);
+            setFailed(null);
+            try {
+                await onDone(await client.agents.create({
+                    name: name.trim(),
+                    model: model.trim() || ENSO,
+                    description: about.trim(),
+                    instructions: orders.trim(),
+                }));
+            }
+            catch (err) {
+                setFailed(err instanceof Error ? err.message : String(err));
+            }
+            finally {
+                setBusy(false);
+            }
+        }, "data-hz": "hire", mx: 10, mb: 10, p: 12, gap: 8, bg: RAISED, borderWidth: 1, borderColor: LINE, rounded: 10, children: [_jsx(Input, { ...BOXED, "data-hz": "name", value: name, onChange: (e) => setName(e.target.value), placeholder: "Name", "aria-label": "Bot name", autoFocus: true }), _jsx(Input, { ...BOXED, "data-hz": "model", list: "bot-models", value: model, onChange: (e) => setModel(e.target.value), placeholder: "Model", "aria-label": "Model" }), _jsx("datalist", { id: "bot-models", children: served.map((m) => (_jsx("option", { value: m.id }, m.id))) }), _jsx(Input, { ...BOXED, value: about, onChange: (e) => setAbout(e.target.value), placeholder: "What it is for", "aria-label": "Description" }), _jsx(Input, { ...BOXED, render: "textarea", rows: 2, value: orders, onChange: (e) => setOrders(e.target.value), placeholder: "Standing instruction", "aria-label": "Standing instruction" }), failed ? _jsx(Text, { "data-hz": "hire-failed", fontSize: "$1", color: DIM, children: failed }) : null, _jsxs(XStack, { gap: 6, children: [_jsx(Button, { type: "submit", variant: "primary", size: "sm", "data-hz": "keep", disabled: busy || !name.trim(), flex: 1, children: busy ? 'Keeping…' : 'Keep' }), _jsx(Button, { size: "sm", onClick: onCancel, flex: 1, children: "Cancel" })] })] }));
+}

package/dist/bots/Lights.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A window's head: three rings, not three colours. Red, amber and green are
+ * another company's mark, and nothing here closes, minimises or zooms, so the
+ * shape alone says "window". The Bots room, its capture and the template
+ * cards wear it (components/bots/Bots.tsx, components/home/Shot.tsx,
+ * components/home/Templates.tsx).
+ */
+export declare function Lights(): import("react").JSX.Element;

package/dist/bots/Lights.js

@@ -0,0 +1,13 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { XStack, YStack } from '@hanzo/gui';
+/**
+ * A window's head: three rings, not three colours. Red, amber and green are
+ * another company's mark, and nothing here closes, minimises or zooms, so the
+ * shape alone says "window". The Bots room, its capture and the template
+ * cards wear it (components/bots/Bots.tsx, components/home/Shot.tsx,
+ * components/home/Templates.tsx).
+ */
+export function Lights() {
+    return (_jsx(XStack, { render: "span", "aria-hidden": true, display: "inline-flex", gap: 6, children: [0, 1, 2].map((i) => (_jsx(YStack, { render: "i", width: 9, height: 9, rounded: 999, borderWidth: 1, borderColor: "var(--border)" }, i))) }));
+}

package/dist/bots/api.d.ts

@@ -0,0 +1,120 @@
+import type { Session, SessionDetail, SessionEvent } from '@hanzo/ai';
+import type { useAi } from '../lib/ai.js';
+export type Client = NonNullable<ReturnType<typeof useAi>['client']>;
+/** The sandbox project that is this Bot's own disk. */
+export declare const disk: (name: string) => string;
+/** The KMS path prefix that is this Bot's own secrets. */
+export declare const vault: (name: string) => string;
+/** Long-running is the platform's word for a Bot that stays up. The set is
+ *  closed, and long-running is REFUSED without a schedule — measured, 400
+ *  "a long-running agent requires a 'schedule' (5-field cron)". */
+export declare const ALWAYS = "long-running";
+export declare const ONCE = "one-shot";
+/**
+ * The sessions opened under this Bot's name.
+ *
+ * NARROWED HERE, BECAUSE THE ROUTE WILL NOT. Its query is root, parent,
+ * status, project, room and limit — there is no per-agent filter — and an
+ * `agent=` it does not know is SILENTLY IGNORED rather than refused. Measured:
+ * `?agent=nope` and no query at all answer the same five rows. A caller that
+ * trusts the parameter draws the whole org's work as one bot's, which is how
+ * this was wrong once already.
+ */
+export declare const sessions: (c: Client, agent: string, limit?: number, signal?: AbortSignal) => Promise<Session[]>;
+/** Opens a session under this Bot's name and answers the row. */
+export declare const launch: (c: Client, agent: string, title: string) => Promise<Session>;
+/** One session with its children and its most recent turns. */
+export declare const transcript: (c: Client, id: string, signal?: AbortSignal) => Promise<SessionDetail>;
+/** Records one turn in a session's log and answers it. */
+export declare const record: (c: Client, id: string, kind: string, text: string) => Promise<SessionEvent>;
+/** The four things you can say to a running session. Each one is recorded as a
+ *  control turn whether or not a runner is attached to hear it — the reply
+ *  carries `forwarded`, which says which of the two happened. */
+export declare const steer: (c: Client, id: string, command: 'pause' | 'resume' | 'stop' | 'message', message?: string) => Promise<{
+    command?: string;
+    event?: SessionEvent;
+    forwarded?: boolean;
+}>;
+/** Which Bot answers a channel: the org default and any room bound past it. */
+export interface Answering {
+    channel: string;
+    default?: string;
+    rooms?: Record<string, string>;
+}
+export declare const answering: (c: Client, channel: string, signal?: AbortSignal) => Promise<Answering>;
+/** Makes this Bot the one that answers a channel. */
+export declare const answer: (c: Client, channel: string, agent: string) => Promise<Answering>;
+/**
+ * The platform's own MCP surface — every subsystem's operations, projected as
+ * tools, over JSON-RPC at `/v1/mcp`.
+ *
+ * This is where a Bot's callable names actually come from. The OTHER door,
+ * `/v1/tools/call`, dispatches only what an org has ACTIVATED in the tool
+ * registry, and answers 404 "unknown tool" for everything else — which is
+ * everything, for an org that has activated none. So the registry is read for
+ * what an org has added and this is read for what the platform already serves.
+ *
+ * Measured: `tools/list` answers 116 tools for a signed-in caller, and refuses
+ * 127 more by a stated rule — a tool is not projected when its name would
+ * disclose a bearer secret, or when a mutating verb acts on an identity.
+ */
+export interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+    annotations?: {
+        readOnlyHint?: boolean;
+    };
+}
+export declare const tools: (c: Client) => Promise<McpTool[]>;
+/** Runs one operation of one tool and answers the text it produced. */
+export declare const call: (c: Client, name: string, op: string, input?: Record<string, unknown>) => Promise<string>;
+/** Starts one autonomous coding run against a repo in the caller's org. */
+export declare const workOn: (c: Client, params: {
+    repo: string;
+    prompt: string;
+    agentRef?: string;
+    project?: string;
+}) => Promise<{
+    sessionId?: string;
+    id?: string;
+}>;
+/** A project the org has declared, with the repo behind it where there is one. */
+export interface Project {
+    id: string;
+    slug: string;
+    name?: string;
+    repo?: {
+        url?: string;
+        branch?: string;
+    } | null;
+}
+export declare const projects: (c: Client, signal?: AbortSignal) => Promise<Project[]>;
+/** A secret's NAME and where it lives. The value never leaves KMS. */
+export interface Secret {
+    name: string;
+    path?: string;
+    env?: string;
+    scheme?: string;
+}
+export declare const secrets: (c: Client, path: string, signal?: AbortSignal) => Promise<Secret[]>;
+/** A connector as `/v1/integrations/connectors` answers it. Held by the PERSON
+ *  who signed in to it: the contract publishes no per-agent binding. */
+export interface Connector {
+    id: string;
+    provider?: string;
+    label?: string;
+    account?: string;
+    scopes?: string[];
+    connectedAt?: string;
+    expiresAt?: string;
+}
+export declare const connectors: (c: Client, signal?: AbortSignal) => Promise<Connector[]>;
+/** A short-lived grant to open a real terminal or a real screen on a sandbox.
+ *  The URL it answers is the only address either surface is ever drawn from. */
+export interface Grant {
+    url?: string;
+    ticket?: string;
+    expiresIn?: number;
+}
+export declare const grant: (c: Client, id: string, kind: 'terminal' | 'screen') => Promise<Grant>;