@hanzo/rooms 0.1.0

package/dist/bots/api.js

@@ -0,0 +1,75 @@
+'use client';
+const SESSION = '/v1/agents/sessions';
+// ── What a Bot owns ─────────────────────────────────────────────────────────
+//
+// A Bot is not a row in a list of prompts; it is a worker with things of its
+// own. Most are fields on the record — the tools it may call, the machine it
+// runs on, the clock it wakes to, the identity it acts as — and two are named
+// spaces derived from its name:
+//
+//   its DISK, because a sandbox volume is named per (org, project) and the name
+//   is deterministic, so leasing `bot-<name>` twice finds the same disk and the
+//   Bot's runtime state survives a lease that ended;
+//
+//   its SECRETS, because `/v1/kms/secrets` filters by `path`, so a Bot's
+//   credentials sit under a prefix nothing else reads.
+/** The sandbox project that is this Bot's own disk. */
+export const disk = (name) => `bot-${name}`;
+/** The KMS path prefix that is this Bot's own secrets. */
+export const vault = (name) => `bots/${name}`;
+/** 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 const ALWAYS = 'long-running';
+export const ONCE = 'one-shot';
+// ── Its work ────────────────────────────────────────────────────────────────
+/**
+ * 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 const sessions = (c, agent, limit = 200, signal) => c.http
+    .collection('sessions', { path: SESSION, query: { limit }, signal })
+    .then((rows) => rows.filter((s) => s.agent === agent));
+/** Opens a session under this Bot's name and answers the row. */
+export const launch = (c, agent, title) => c.http.json({ method: 'POST', path: SESSION, body: { agent, title } });
+/** One session with its children and its most recent turns. */
+export const transcript = (c, id, signal) => c.http.json({ path: `${SESSION}/${encodeURIComponent(id)}`, signal });
+/** Records one turn in a session's log and answers it. */
+export const record = (c, id, kind, text) => c.http.json({ method: 'POST', path: `${SESSION}/${encodeURIComponent(id)}/events`, body: { kind, text } });
+/** 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 const steer = (c, id, command, message) => c.http.json({
+    method: 'POST',
+    path: `${SESSION}/${encodeURIComponent(id)}/${command}`,
+    body: message === undefined ? {} : { message },
+});
+export const answering = (c, channel, signal) => c.http.json({ path: '/v1/channels/agent', query: { channel }, signal });
+/** Makes this Bot the one that answers a channel. */
+export const answer = (c, channel, agent) => c.http.json({ method: 'PUT', path: '/v1/channels/agent', body: { channel, default: agent } });
+const rpc = (c, method, params) => c.http
+    .json({
+    method: 'POST',
+    path: '/v1/mcp',
+    body: { jsonrpc: '2.0', id: 1, method, params },
+})
+    .then((r) => {
+    if (r.error)
+        throw new Error(r.error.message || 'the tool refused');
+    return r.result;
+});
+export const tools = (c) => rpc(c, 'tools/list').then((r) => r.tools ?? []);
+/** Runs one operation of one tool and answers the text it produced. */
+export const call = (c, name, op, input = {}) => rpc(c, 'tools/call', { name, arguments: { op, input } }).then((r) => (r.content ?? []).map((p) => p.text ?? '').join('\n'));
+/** Starts one autonomous coding run against a repo in the caller's org. */
+export const workOn = (c, params) => c.http.json({ method: 'POST', path: '/v1/agents/coding', body: params });
+export const projects = (c, signal) => c.http.json({ path: '/v1/projects', signal });
+export const secrets = (c, path, signal) => c.http.collection('secrets', { path: '/v1/kms/secrets', query: { path }, signal });
+export const connectors = (c, signal) => c.http.collection('connectors', { path: '/v1/integrations/connectors', signal });
+export const grant = (c, id, kind) => c.http.json({ method: 'POST', path: `/v1/sandbox/${encodeURIComponent(id)}/${kind}/ticket` });

package/dist/bots/face.d.ts

@@ -0,0 +1,5 @@
+import type { Agent } from '@hanzo/ai';
+export declare function Face({ bot, size }: {
+    bot: Pick<Agent, 'name' | 'avatar' | 'emoji'>;
+    size?: number;
+}): import("react").JSX.Element;

package/dist/bots/face.js

@@ -0,0 +1,13 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text, YStack } from '@hanzo/gui';
+import { INK, LINE, SURFACE } from './ink.js';
+export function Face({ bot, size = 36 }) {
+    const round = { width: size, height: size, shrink: 0, rounded: 9999, borderWidth: 1, borderColor: LINE };
+    if (bot.avatar)
+        return _jsx(YStack, { render: "img", src: bot.avatar, alt: '', "aria-hidden": true, ...round, objectFit: "cover" });
+    // The glyph scales with the disc, so its size is a number of pixels rather
+    // than a rung; the leading is the size itself, which centres it.
+    const glyph = Math.round(size * (bot.emoji ? 0.5 : 0.4));
+    return (_jsx(YStack, { "aria-hidden": true, ...round, items: "center", justify: "center", bg: SURFACE, userSelect: 'none', children: _jsx(Text, { color: INK, fontSize: glyph, lineHeight: glyph, fontWeight: "600", children: bot.emoji || (bot.name || '?').trim().charAt(0).toUpperCase() }) }));
+}

package/dist/bots/ink.d.ts

@@ -0,0 +1,7 @@
+export declare const GROUND = "var(--background)";
+export declare const RAISED = "var(--surface-1)";
+export declare const INK = "var(--foreground)";
+export declare const DIM = "var(--muted-foreground)";
+export declare const FAINT = "$faint";
+export declare const LINE = "var(--border)";
+export declare const SURFACE = "var(--surface-card-quiet)";

package/dist/bots/ink.js

@@ -0,0 +1,29 @@
+// The ramp this room is drawn in.
+//
+// Greyscale, because nothing on this screen is a category: a Bot is not red and
+// a session is not green. What used to stand here was seven personas each given
+// a colour from a table in the source, which told a reader which of seven
+// fictional workers they were looking at and could not survive the eighth.
+//
+// Status is said in words. A colour that means "done" has to be learned; the
+// word does not, and it survives a reader who cannot see it.
+//
+// ROLES, NOT VALUES. These were seven literals — black ground, white ink, white
+// at four opacities — which reads right in dark by coincidence and cannot
+// retune. On the light theme the room came out an island: the rail and the
+// column beside it followed the page while everything these painted stayed
+// night, which is also what a screenshot of the room then carried onto the
+// landing. Naming the role hands the decision to @hanzo/design, which tunes
+// both grounds already.
+//
+// The loud controls are @hanzo/ui's primary Button, so their fill is design's
+// accent and follows whatever @hanzo/appearance sets; this ramp holds no pair.
+export const GROUND = 'var(--background)';
+export const RAISED = 'var(--surface-1)';
+export const INK = 'var(--foreground)';
+export const DIM = 'var(--muted-foreground)';
+// The dimmest ink is gui's `$faint` rung, a theme token: design's
+// --text-tertiary is 4.32:1 on the light ground, under text's 4.5.
+export const FAINT = '$faint';
+export const LINE = 'var(--border)';
+export const SURFACE = 'var(--surface-card-quiet)';

package/dist/bots/kit.d.ts

@@ -0,0 +1,113 @@
+/** A bare icon control: no ground, a 6px pad, the glyph centred. The glyph
+ *  takes its ink itself — a frame carries no text colour to hand down. */
+export declare const GHOST: {
+    readonly render: 'button';
+    readonly type: 'button';
+    readonly p: 6;
+    readonly rounded: 6;
+    readonly bg: 'transparent';
+    readonly borderWidth: 0;
+    readonly items: 'center';
+    readonly justify: 'center';
+    readonly cursor: 'pointer';
+};
+/** The small outlined control every action here is. A `Text`, so the label's
+ *  size and ink are the button's and an icon beside it paints in `currentColor`. */
+export declare const TAB: {
+    readonly render: 'button';
+    readonly type: 'button';
+    readonly display: 'inline-flex';
+    readonly items: 'center';
+    readonly gap: 5;
+    readonly px: 10;
+    readonly py: 5;
+    readonly rounded: 7;
+    readonly fontSize: '$1';
+    readonly fontWeight: '600';
+    readonly borderWidth: 1;
+    readonly borderColor: "var(--border)";
+    readonly bg: 'transparent';
+    readonly color: "var(--muted-foreground)";
+    readonly cursor: 'pointer';
+};
+/** A field with its chrome off, inside a row that draws the edge. Its padding
+ *  is still @hanzo/design's base field gutter. */
+export declare const BARE: {
+    readonly unstyled: true;
+    readonly color: "var(--foreground)";
+    readonly placeholderTextColor: '$placeholderColor';
+};
+/** A field that draws its own edge. */
+export declare const BOXED: {
+    readonly unstyled: true;
+    readonly width: '100%';
+    readonly px: 10;
+    readonly py: 7;
+    readonly rounded: 8;
+    readonly bg: "var(--surface-card-quiet)";
+    readonly borderWidth: 1;
+    readonly borderColor: "var(--border)";
+    readonly color: "var(--foreground)";
+    readonly fontSize: '$2';
+    readonly placeholderTextColor: '$placeholderColor';
+};
+/** The platform's select, wearing the same edge as `BOXED`. */
+export declare const PICK: {
+    readonly width: '100%';
+    readonly rounded: 8;
+    readonly bg: "var(--surface-card-quiet)";
+    readonly borderColor: "var(--border)";
+    readonly color: "var(--foreground)";
+    readonly fontSize: '$2';
+};
+/** A raised card in the stream. */
+export declare const CARD: {
+    readonly bg: "var(--surface-1)";
+    readonly borderWidth: 1;
+    readonly borderColor: "var(--border)";
+    readonly rounded: 14;
+    readonly p: 16;
+    readonly gap: 8;
+    readonly maxW: 620;
+};
+/** A section's small-caps heading. */
+export declare const LABEL: {
+    readonly render: 'h3';
+    readonly fontSize: '$1';
+    readonly fontWeight: '600';
+    readonly letterSpacing: 0.6;
+    readonly color: "$faint";
+    readonly textTransform: 'uppercase';
+};
+/** A sentence the room says when it has nothing else to draw. */
+export declare const NOTE: {
+    readonly render: 'p';
+    readonly px: 12;
+    readonly py: 10;
+    readonly fontSize: '$2';
+    readonly lineHeight: '1.3rem';
+    readonly color: "var(--muted-foreground)";
+};
+/** One line, cut with an ellipsis where it runs out of room. */
+export declare const CLIP: {
+    readonly whiteSpace: 'nowrap';
+    readonly overflow: 'hidden';
+    readonly textOverflow: 'ellipsis';
+};
+/** What a run printed: a bounded block of mono that scrolls. */
+export declare const OUT: {
+    readonly render: 'pre';
+    readonly display: 'block';
+    readonly maxH: 180;
+    readonly overflowY: 'auto';
+    readonly p: 10;
+    readonly rounded: 8;
+    readonly bg: "var(--surface-card-quiet)";
+    readonly borderWidth: 1;
+    readonly borderColor: "var(--border)";
+    readonly fontFamily: '$mono';
+    readonly fontSize: '$1';
+    readonly lineHeight: '1.03125rem';
+    readonly whiteSpace: 'pre-wrap';
+    readonly color: "var(--foreground)";
+};

package/dist/bots/kit.js

@@ -0,0 +1,43 @@
+// The controls and surfaces the Bots room is drawn from, as gui props.
+//
+// The room and its runtime pane spelled the same tab, field and label twice
+// each; they are stated once here and spread where they are drawn. Each is a
+// plain prop object, so a call site adds to one and never needs a style.
+import { DIM, FAINT, INK, LINE, RAISED, SURFACE } from './ink.js';
+/** A bare icon control: no ground, a 6px pad, the glyph centred. The glyph
+ *  takes its ink itself — a frame carries no text colour to hand down. */
+export const GHOST = {
+    render: 'button', type: 'button', p: 6, rounded: 6, bg: 'transparent', borderWidth: 0,
+    items: 'center', justify: 'center', cursor: 'pointer',
+};
+/** The small outlined control every action here is. A `Text`, so the label's
+ *  size and ink are the button's and an icon beside it paints in `currentColor`. */
+export const TAB = {
+    render: 'button', type: 'button', display: 'inline-flex', items: 'center', gap: 5, px: 10, py: 5, rounded: 7,
+    fontSize: '$1', fontWeight: '600', borderWidth: 1, borderColor: LINE, bg: 'transparent', color: DIM, cursor: 'pointer',
+};
+/** A field with its chrome off, inside a row that draws the edge. Its padding
+ *  is still @hanzo/design's base field gutter. */
+export const BARE = { unstyled: true, color: INK, placeholderTextColor: '$placeholderColor' };
+/** A field that draws its own edge. */
+export const BOXED = {
+    unstyled: true, width: '100%', px: 10, py: 7, rounded: 8, bg: SURFACE, borderWidth: 1, borderColor: LINE,
+    color: INK, fontSize: '$2', placeholderTextColor: '$placeholderColor',
+};
+/** The platform's select, wearing the same edge as `BOXED`. */
+export const PICK = { width: '100%', rounded: 8, bg: SURFACE, borderColor: LINE, color: INK, fontSize: '$2' };
+/** A raised card in the stream. */
+export const CARD = { bg: RAISED, borderWidth: 1, borderColor: LINE, rounded: 14, p: 16, gap: 8, maxW: 620 };
+/** A section's small-caps heading. */
+export const LABEL = {
+    render: 'h3', fontSize: '$1', fontWeight: '600', letterSpacing: 0.6, color: FAINT, textTransform: 'uppercase',
+};
+/** A sentence the room says when it has nothing else to draw. */
+export const NOTE = { render: 'p', px: 12, py: 10, fontSize: '$2', lineHeight: '1.3rem', color: DIM };
+/** One line, cut with an ellipsis where it runs out of room. */
+export const CLIP = { whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis' };
+/** What a run printed: a bounded block of mono that scrolls. */
+export const OUT = {
+    render: 'pre', display: 'block', maxH: 180, overflowY: 'auto', p: 10, rounded: 8, bg: SURFACE, borderWidth: 1,
+    borderColor: LINE, fontFamily: '$mono', fontSize: '$1', lineHeight: '1.03125rem', whiteSpace: 'pre-wrap', color: INK,
+};

package/dist/bots/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { Agent } from '@hanzo/ai';
+export declare function Runtime({ bot }: {
+    bot: Agent;
+}): import("react").JSX.Element;

package/dist/bots/runtime.js

@@ -0,0 +1,326 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// WHAT ONE BOT HAS.
+//
+// A Bot is a worker, and a worker owns things. The platform holds each one
+// somewhere, and this pane is one section per thing:
+//
+//   its MACHINE   `computeRef`, an id from /v1/agents/targets
+//   its COMPUTER  a sandbox leased on the project `bot-<name>`, which is this
+//                 Bot's disk: a volume is named per (org, project) and the name
+//                 is deterministic, so the same disk comes back after a lease ends
+//   its TOOLS     `tools[]` — the names this Bot may call, out of the platform's
+//                 own MCP surface plus whatever the org has registered
+//   its CHANNELS  the rooms it answers, from /v1/channels/agent
+//   its CODE      an autonomous run against one of the org's repos
+//   its SECRETS   the KMS names under `bots/<name>`
+//
+// ONE THING A READER WILL LOOK FOR IS NOT THE BOT'S: a connector is held by the
+// PERSON who signed in to it, and the contract publishes no route binding one to
+// an agent. It is listed as what it is, with no switch to press.
+//
+// The screen and the terminal are real or they are absent. Each is a URL the
+// platform mints against a sandbox that exists; where there is no sandbox there
+// is no window, and where the mint is refused the refusal is what is drawn.
+import { useCallback, useEffect, useState } from 'react';
+import { Play, Square, X } from 'lucide-react';
+import { useOrganizations } from '@hanzo/iam/react';
+import { useAi } from '../lib/ai.js';
+import { say } from '../failure.js';
+import { Input, Text, XStack, YStack } from '@hanzo/gui';
+import { Picker } from '@hanzo/ui';
+import { DIM, FAINT, GROUND, INK, LINE } from './ink.js';
+import { BOXED, LABEL, OUT, PICK, TAB } from './kit.js';
+import { answer, answering, call, connectors as readConnectors, disk, grant, projects as readProjects, secrets as readSecrets, tools as readTools, vault, workOn, } from './api.js';
+export function Runtime({ bot }) {
+    const { client } = useAi();
+    const { currentOrg } = useOrganizations();
+    const org = currentOrg?.displayName || currentOrg?.name || '';
+    const project = disk(bot.name);
+    const [machines, setMachines] = useState([]);
+    const [boxes, setBoxes] = useState([]);
+    const [servers, setServers] = useState([]);
+    const [skills, setSkills] = useState([]);
+    const [activated, setActivated] = useState([]);
+    const [published, setPublished] = useState([]);
+    const [links, setLinks] = useState([]);
+    const [rooms, setRooms] = useState([]);
+    const [keys, setKeys] = useState([]);
+    const [repos, setRepos] = useState([]);
+    const [why, setWhy] = useState({});
+    const blame = useCallback((k, e, subject) => {
+        setWhy((w) => ({ ...w, [k]: say(e, subject) }));
+    }, []);
+    const survey = useCallback(async () => {
+        if (!client)
+            return;
+        await Promise.all([
+            client.machines.list().then(setMachines).catch((e) => blame('machine', e, 'this org’s machines')),
+            client.sandboxes.list({ project }).then(setBoxes).catch((e) => blame('box', e, 'this bot’s computer')),
+            client.tools.mcp().then(setServers).catch((e) => blame('mcp', e, 'this org’s MCP servers')),
+            client.tools.skills().then((s) => setSkills(s.tools ?? [])).catch((e) => blame('skill', e, 'this org’s skills')),
+            client.tools.activation().then((a) => setActivated(a.enabled ?? [])).catch(() => setActivated([])),
+            readTools(client).then(setPublished).catch((e) => blame('served', e, 'the platform’s tools')),
+            readConnectors(client).then(setLinks).catch((e) => blame('link', e, 'your connectors')),
+            client.channels.list().then(setRooms).catch((e) => blame('room', e, 'this org’s channels')),
+            readSecrets(client, vault(bot.name)).then(setKeys).catch((e) => blame('key', e, 'this bot’s secrets')),
+            readProjects(client).then(setRepos).catch((e) => blame('repo', e, 'this org’s repos')),
+        ]);
+    }, [client, project, bot.name, blame]);
+    useEffect(() => {
+        void survey();
+    }, [survey]);
+    return (_jsxs(YStack, { render: "aside", "aria-label": `${bot.name} runtime`, "data-hz": "runtime-pane", width: 360, shrink: 0, overflowY: "auto", borderLeftWidth: 1, borderColor: LINE, bg: GROUND, children: [_jsxs(Part, { title: "Runtime", children: [_jsxs(Line, { children: [bot.name, " runs for ", _jsx(Text, { color: INK, children: org || 'your org' }), bot.serviceAccountId ? ` as ${bot.serviceAccountId}` : '', ". Nothing on this panel crosses into another org."] }), bot.schedule ? (_jsxs(Line, { children: ["Wakes on ", _jsx(Text, { color: INK, children: bot.schedule }), bot.executionMode ? ` (${bot.executionMode})` : '', "."] })) : null] }), _jsx(Machine, { bot: bot, machines: machines, why: why.machine }), _jsx(Computer, { bot: bot, box: boxes[0] ?? null, project: project, why: why.box, onChange: survey }), _jsx(Tools, { bot: bot, servers: servers, skills: skills, published: published, activated: activated, why: why.served ?? why.mcp ?? why.skill }), _jsx(Channels, { bot: bot, rooms: rooms, why: why.room }), _jsx(Code, { bot: bot, repos: repos, why: why.repo }), _jsx(Secrets, { bot: bot, keys: keys, why: why.key }), _jsx(Held, { links: links, why: why.link })] }));
+}
+/** The machine this Bot runs on. The list is the org's; the binding is the Bot's. */
+function Machine({ bot, machines, why }) {
+    const { client } = useAi();
+    const [bound, setBound] = useState(bot.computeRef ?? '');
+    const [failed, setFailed] = useState(null);
+    useEffect(() => setBound(bot.computeRef ?? ''), [bot.computeRef]);
+    return (_jsxs(Part, { title: "Machine", children: [why ? _jsx(Line, { children: why }) : null, !why && machines.length === 0 ? (_jsx(Line, { children: "No machine is registered to this org, so this bot runs wherever the platform places it." })) : null, machines.length > 0 ? (_jsxs(Picker, { ...PICK, value: bound, "aria-label": "Machine", onChange: async (e) => {
+                    const id = e.target.value;
+                    setBound(id);
+                    if (!client)
+                        return;
+                    try {
+                        await client.agents.update(bot.name, { computeRef: id });
+                        setFailed(null);
+                    }
+                    catch (err) {
+                        setFailed(say(err, 'this bot', 'save'));
+                    }
+                }, children: [_jsx("option", { value: "", children: "Unbound" }), machines.map((m) => (_jsxs("option", { value: m.id, children: [m.label || m.host || m.id, m.status ? ` — ${m.status}` : ''] }, m.id)))] })) : null, failed ? _jsx(Line, { children: failed }) : null] }));
+}
+/**
+ * This Bot's computer.
+ *
+ * A `desktop` lease has a screen and every lease has a terminal; both are opened
+ * through a ticket the platform mints against THIS sandbox, and the iframe points
+ * at the URL that came back. There is no other source for either window.
+ *
+ * MEASURED 2026-09-07: every class of lease is refused by the fleet —
+ * `exec` and `desktop` with "pod … not running after 2m0s", `dev` with
+ * "admin credentials: DO_API_TOKEN not configured" — and `/v1/exec`, the other
+ * door onto the same pool, answers the first of those. So the terminal, the
+ * screen and running code are all one outage, and the refusal is the whole of
+ * what this section can honestly show until the pool comes back.
+ */
+function Computer({ bot, box, project, why, onChange, }) {
+    const { client } = useAi();
+    const [busy, setBusy] = useState(false);
+    const [failed, setFailed] = useState(null);
+    const [command, setCommand] = useState('');
+    const [ran, setRan] = useState(null);
+    const [window, setWindow] = useState(null);
+    const attempt = useCallback(async (what, act) => {
+        if (!client || busy)
+            return;
+        setBusy(true);
+        setFailed(null);
+        try {
+            await act();
+        }
+        catch (e) {
+            // The fleet's own words. A sandbox that will not start is the reader's
+            // situation and only the fleet knows why, so it is not translated away.
+            setFailed(`${what}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [client, busy]);
+    const open = (kind) => attempt(`Could not open the ${kind}`, async () => {
+        if (!client || !box)
+            return;
+        const g = await grant(client, box.id, kind);
+        if (!g.url)
+            throw new Error('the platform minted no address');
+        setWindow({ kind, url: g.url });
+    });
+    return (_jsxs(Part, { title: "Computer", children: [_jsxs(Line, { children: ["Its own disk, ", _jsx(Text, { render: "code", fontSize: "$1", color: INK, children: project }), ". A lease on this project finds the same disk every time, so what this bot writes outlives the lease."] }), why ? _jsx(Line, { children: why }) : null, box ? (_jsxs(_Fragment, { children: [_jsxs(Row, { children: [_jsxs(Text, { fontSize: "$2", color: INK, "data-hz": "box", children: [box.class ?? 'sandbox', " \u00B7 ", box.status ?? 'unknown'] }), _jsx(Text, { fontSize: "$1", color: FAINT, children: box.id.slice(0, 14) })] }), box.status === 'pending' ? (_jsx(Line, { children: "Waiting for the fleet to place it. Nothing can be opened on it until it is running." })) : null, box.status === 'error' ? _jsx(Line, { children: box.error || 'The fleet could not start it.' }) : null, _jsxs(XStack, { gap: 6, flexWrap: "wrap", children: [box.status === 'running' ? (_jsx(Text, { ...TAB, onClick: () => open('terminal'), disabled: busy, children: "Terminal" })) : null, box.status === 'running' && box.class === 'desktop' ? (_jsx(Text, { ...TAB, onClick: () => open('screen'), disabled: busy, children: "Screen" })) : null, _jsxs(Text, { ...TAB, disabled: busy, onClick: () => attempt('Could not stop it', async () => {
+                                    await client.sandboxes.stop({ id: box.id });
+                                }), children: [_jsx(Square, { size: 11, "aria-hidden": true }), "Stop"] }), _jsxs(Text, { ...TAB, disabled: busy, onClick: () => attempt('Could not end the lease', async () => {
+                                    await client.sandboxes.end({ id: box.id });
+                                    setWindow(null);
+                                    await onChange();
+                                }), children: [_jsx(X, { size: 11, "aria-hidden": true }), "End"] })] }), window ? (_jsx(YStack, { render: "iframe", src: window.url, title: `${bot.name} ${window.kind}`, width: "100%", height: 240, borderWidth: 1, borderColor: LINE, rounded: 8, bg: GROUND })) : null, _jsxs(XStack, { render: "form", onSubmit: (e) => {
+                            e.preventDefault();
+                            void attempt('Could not run it', async () => {
+                                setRan(await client.sandboxes.run({ id: box.id, command }));
+                            });
+                        }, display: box.status === 'running' ? 'flex' : 'none', gap: 6, children: [_jsx(Input, { ...BOXED, flex: 1, minW: 0, value: command, onChange: (e) => setCommand(e.target.value), placeholder: "Command", "aria-label": "Command to run in this bot's computer" }), _jsxs(Text, { ...TAB, type: 'submit', disabled: busy || !command.trim(), children: [_jsx(Play, { size: 11, "aria-hidden": true }), "Run"] })] }), ran ? (_jsxs(Text, { ...OUT, children: [(ran.stdout ?? '') + (ran.stderr ?? ''), `\nexit ${ran.exitCode ?? 0}`] })) : null] })) : (_jsxs(_Fragment, { children: [_jsx(Line, { children: "No computer is leased. A lease is what a terminal, a screen and a command all hang off, so until one starts there is nothing here to open." }), _jsxs(XStack, { gap: 6, flexWrap: "wrap", children: [_jsx(Text, { ...TAB, "data-hz": "lease", disabled: busy, onClick: () => attempt('Could not lease a computer', async () => {
+                                    await client.sandboxes.lease({ class: 'dev', project });
+                                    await onChange();
+                                }), children: busy ? 'Leasing…' : 'Lease a computer' }), _jsx(Text, { ...TAB, "data-hz": "lease-desktop", disabled: busy, onClick: () => attempt('Could not lease a screen', async () => {
+                                    await client.sandboxes.lease({ class: 'desktop', project });
+                                    await onChange();
+                                }), children: busy ? 'Leasing…' : 'Lease a screen' })] })] })), failed ? _jsx(Line, { "data-hz": "computer-failed", children: failed }) : null] }));
+}
+/**
+ * What this Bot may call, and calling one.
+ *
+ * `tools[]` on the agent record is the Bot's OWN permission set, and it is a
+ * PATCH to this Bot and nothing else — another Bot in the same org keeps its
+ * own list. The names come from three places, and they are three because the
+ * platform keeps them in three:
+ *
+ *   PLATFORM   `/v1/mcp` tools/list — every subsystem's operations, projected.
+ *              116 for a signed-in caller, with 127 more refused by a stated
+ *              rule the endpoint publishes. This is the set that can be CALLED.
+ *   MCP        the org's own registered servers, `/v1/tools/mcp/servers`.
+ *   SKILL      the org's authored skills, `/v1/tools/skills`.
+ *
+ * A name from the last two is dispatchable only once the org ACTIVATES it —
+ * `/v1/tools/call` answers 404 "unknown tool" for everything outside the
+ * activated set — so an inactive one is labelled rather than drawn as ready.
+ *
+ * The call below runs against this Bot's granted set and nothing wider, which
+ * is what makes the grant mean something on this screen rather than only in
+ * the record.
+ */
+function Tools({ bot, servers, skills, published, activated, why, }) {
+    const { client } = useAi();
+    const [held, setHeld] = useState(bot.tools ?? []);
+    const [failed, setFailed] = useState(null);
+    const [pick, setPick] = useState('');
+    const [op, setOp] = useState('');
+    const [ran, setRan] = useState(null);
+    const [busy, setBusy] = useState(false);
+    useEffect(() => setHeld(bot.tools ?? []), [bot.tools, bot.name]);
+    useEffect(() => setPick((p) => (held.includes(p) ? p : (held[0] ?? ''))), [held]);
+    const offered = [
+        ...published.map((t) => ({ name: t.name, from: 'platform', ready: true })),
+        ...servers.map((s) => ({ name: s.name || s.id, from: 'MCP', ready: activated.includes(s.name || s.id) })),
+        ...skills.map((s) => ({ name: s.name, from: 'skill', ready: activated.includes(s.name) })),
+    ];
+    const flip = async (name) => {
+        const next = held.includes(name) ? held.filter((t) => t !== name) : [...held, name];
+        setHeld(next);
+        if (!client)
+            return;
+        try {
+            await client.agents.update(bot.name, { tools: next });
+            setFailed(null);
+        }
+        catch (e) {
+            setFailed(say(e, 'this bot', 'save'));
+        }
+    };
+    return (_jsxs(Part, { title: "Tools", children: [why ? _jsx(Line, { children: why }) : null, offered.length === 0 && !why ? (_jsx(Line, { children: "Nothing publishes a tool for this org yet, so there is nothing to grant." })) : null, _jsx(YStack, { "data-hz": "tools", maxH: 200, overflowY: "auto", gap: 4, children: offered.map((t) => (_jsxs(XStack, { render: "label", items: "center", justify: "space-between", gap: 8, cursor: "pointer", children: [_jsx("input", { type: "checkbox", checked: held.includes(t.name), onChange: () => flip(t.name), "aria-label": t.name }), _jsx(Text, { flex: 1, fontSize: "$2", color: INK, children: t.name }), _jsx(Text, { fontSize: "$1", color: FAINT, children: t.ready ? t.from : `${t.from} · not activated` })] }, `${t.from}-${t.name}`))) }), held.length > 0 ? (_jsxs(YStack, { render: "form", onSubmit: async (e) => {
+                    e.preventDefault();
+                    if (!client || busy || !pick || !op.trim())
+                        return;
+                    setBusy(true);
+                    try {
+                        setRan(await call(client, pick, op.trim()));
+                    }
+                    catch (err) {
+                        setRan(err instanceof Error ? err.message : String(err));
+                    }
+                    finally {
+                        setBusy(false);
+                    }
+                }, gap: 6, children: [_jsx(Picker, { ...PICK, value: pick, onChange: (e) => setPick(e.target.value), "aria-label": "Tool to call", children: held.map((h) => (_jsx("option", { value: h, children: h }, h))) }), _jsxs(XStack, { gap: 6, children: [_jsx(Input, { ...BOXED, flex: 1, minW: 0, "data-hz": "op", value: op, onChange: (e) => setOp(e.target.value), placeholder: "Operation", "aria-label": "Operation to run" }), _jsx(Text, { ...TAB, type: 'submit', "data-hz": "call", disabled: busy || !op.trim(), children: busy ? 'Calling…' : 'Call' })] })] })) : null, ran ? _jsx(Text, { ...OUT, "data-hz": "called", children: ran }) : null, failed ? _jsx(Line, { children: failed }) : null] }));
+}
+/**
+ * The rooms this Bot answers.
+ *
+ * `/v1/channels/agent` binds ONE agent per channel as the org's default
+ * answerer, so this is a per-Bot binding and not an account-wide list: pressing
+ * Answer here moves that channel from whichever bot holds it to this one.
+ */
+function Channels({ bot, rooms, why }) {
+    const { client } = useAi();
+    const [bound, setBound] = useState({});
+    const [failed, setFailed] = useState(null);
+    const read = useCallback(async () => {
+        if (!client)
+            return;
+        const pairs = await Promise.all(rooms.map(async (r) => {
+            try {
+                return [r.id, (await answering(client, r.id)).default ?? ''];
+            }
+            catch {
+                return [r.id, ''];
+            }
+        }));
+        setBound(Object.fromEntries(pairs));
+    }, [client, rooms]);
+    useEffect(() => {
+        void read();
+    }, [read]);
+    return (_jsxs(Part, { title: "Channels", children: [why ? _jsx(Line, { children: why }) : null, rooms.length === 0 && !why ? _jsx(Line, { children: "This org has no channels." }) : null, rooms.map((r) => {
+                const mine = bound[r.id] === bot.name;
+                return (_jsxs(Row, { children: [_jsx(Text, { fontSize: "$2", color: INK, children: r.id }), _jsxs(XStack, { items: "center", gap: 8, children: [_jsx(Text, { fontSize: "$1", color: FAINT, children: r.connected ? bound[r.id] || 'unbound' : 'not connected' }), _jsx(Text, { ...TAB, opacity: mine ? 0.5 : 1, disabled: mine, onClick: async () => {
+                                        if (!client)
+                                            return;
+                                        try {
+                                            await answer(client, r.id, bot.name);
+                                            setFailed(null);
+                                            await read();
+                                        }
+                                        catch (e) {
+                                            setFailed(say(e, 'this channel', 'save'));
+                                        }
+                                    }, children: mine ? 'Answers' : 'Answer' })] })] }, r.id));
+            }), failed ? _jsx(Line, { children: failed }) : null] }));
+}
+/**
+ * Work on a repo.
+ *
+ * `/v1/agents/coding` starts ONE autonomous run against a repo the org owns and
+ * hangs a session off it, so this is the door between a Bot and a codebase. The
+ * repos offered are the org's own projects that carry one; a name outside that
+ * set is refused by the platform naming it, and the refusal is what is shown.
+ */
+function Code({ bot, repos, why }) {
+    const { client } = useAi();
+    const withRepo = repos.filter((p) => p.repo?.url);
+    const [repo, setRepo] = useState('');
+    const [task, setTask] = useState('');
+    const [busy, setBusy] = useState(false);
+    const [said, setSaid] = useState(null);
+    useEffect(() => {
+        if (!repo && withRepo[0])
+            setRepo(withRepo[0].slug);
+    }, [repo, withRepo]);
+    return (_jsxs(Part, { title: "Code", children: [why ? _jsx(Line, { children: why }) : null, withRepo.length === 0 && !why ? (_jsx(Line, { children: "No project in this org names a repo, so there is nothing for this bot to work on." })) : (_jsxs(YStack, { render: "form", onSubmit: async (e) => {
+                    e.preventDefault();
+                    if (!client || busy || !repo || !task.trim())
+                        return;
+                    setBusy(true);
+                    setSaid(null);
+                    try {
+                        const started = await workOn(client, { repo, prompt: task.trim(), agentRef: bot.name, project: repo });
+                        setSaid(`Started ${started.sessionId || started.id || 'a run'} on ${repo}.`);
+                        setTask('');
+                    }
+                    catch (err) {
+                        setSaid(err instanceof Error ? err.message : String(err));
+                    }
+                    finally {
+                        setBusy(false);
+                    }
+                }, gap: 6, children: [_jsx(Picker, { ...PICK, value: repo, onChange: (e) => setRepo(e.target.value), "aria-label": "Repo", children: withRepo.map((p) => (_jsx("option", { value: p.slug, children: p.slug }, p.id))) }), _jsx(Input, { ...BOXED, "data-hz": "task", value: task, onChange: (e) => setTask(e.target.value), placeholder: "What to change", "aria-label": "What to change" }), _jsx(Text, { ...TAB, type: 'submit', "data-hz": "code", self: "flex-start", disabled: busy || !task.trim(), children: busy ? 'Starting…' : 'Work on it' })] })), said ? _jsx(Line, { children: said }) : null] }));
+}
+/** The names under this Bot's KMS prefix. The values stay in KMS. */
+function Secrets({ bot, keys, why }) {
+    return (_jsxs(Part, { title: "Secrets", children: [_jsxs(Line, { children: ["Held under ", _jsx(Text, { render: "code", fontSize: "$1", color: INK, children: vault(bot.name) }), " in KMS. Names are readable here; values are not, by KMS and not by this screen."] }), why ? _jsx(Line, { children: why }) : null, keys.length === 0 && !why ? _jsx(Line, { children: "None yet." }) : null, keys.map((k) => (_jsxs(Row, { children: [_jsx(Text, { fontSize: "$2", color: INK, children: k.name }), _jsx(Text, { fontSize: "$1", color: FAINT, children: k.env })] }, `${k.path}/${k.name}`)))] }));
+}
+/**
+ * The one thing that is NOT this Bot's.
+ *
+ * A connector is held by the person who signed in to it.
+ * `/v1/integrations/connectors` answers one set for the caller and no route in
+ * the contract narrows it to one agent — so it is listed as what it is, and
+ * there is no switch to press.
+ */
+function Held({ links, why }) {
+    return (_jsxs(Part, { title: "Your connectors", children: [_jsx(Line, { children: "Signed in by you, reachable by every bot in this org. The platform publishes no per-bot binding for a connector, so nothing here is scoped down to this one." }), why ? _jsx(Line, { children: why }) : null, links.length === 0 && !why ? _jsx(Line, { children: "None connected." }) : null, links.map((l) => (_jsxs(Row, { children: [_jsx(Text, { fontSize: "$1", color: DIM, children: l.label || l.provider }), _jsx(Text, { fontSize: "$1", color: FAINT, children: l.account })] }, l.id)))] }));
+}
+function Part({ title, children }) {
+    return (_jsxs(YStack, { render: "section", px: 16, py: 14, borderBottomWidth: 1, borderColor: LINE, gap: 8, children: [_jsx(Text, { ...LABEL, children: title }), children] }));
+}
+const Line = ({ children, ...rest }) => (_jsx(Text, { render: "p", fontSize: "$1", lineHeight: "1.1rem", color: DIM, ...rest, children: children }));
+const Row = ({ children }) => (_jsx(XStack, { items: "center", justify: "space-between", gap: 8, children: children }));