@hanzo/build 0.2.10 → 0.2.11

package/lib/api/tools.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The org's tool plane: every tool it can reach, and which of them are on.
+ *
+ *   GET /v1/tool?source=&activated=true   {tools: [{name, source, description, activated, dispatchable}]}
+ *   GET /v1/tool/activation               {enabled: [name]}
+ *   PUT /v1/tool/activation               {activate: [name], deactivate: [name]} → {enabled: [name]}
+ *
+ * A tool is on per org. On is what puts a skill's SKILL.md in an agent's prompt
+ * and what lets an MCP server's tool be called; a tool that is off is listed and
+ * refused at call time. Any member of the org may switch one — the handler asks
+ * for the org and nothing more.
+ */
+import { type Target } from './call.ts';
+export interface Tool {
+    /** The flat, fleet-wide name: `skill_<name>`, `<server id>_<tool>`, `agent_<name>`… */
+    name: string;
+    /** connector, function, zap-service, agent, skill or mcp. */
+    source: string;
+    description: string;
+    activated: boolean;
+}
+export declare const names: (v: unknown) => string[];
+export declare function tool(raw: unknown): Tool;
+/** The tools in one listing, whichever of the plane's two envelopes it came in. */
+export declare function toolsOf(raw: unknown): Tool[];
+/** Every tool the org reaches, narrowed to one source and to the ones that are on when asked. */
+export declare function tools(t: Target, q?: {
+    source?: string;
+    activated?: boolean;
+}): Promise<Tool[]>;
+/** The names that are on. */
+export declare function enabled(t: Target): Promise<string[]>;
+/** Switch names on and off; answers every name that is on afterwards. */
+export declare function toggle(t: Target, on: string[], off?: string[]): Promise<string[]>;

package/lib/api/tools.js

@@ -0,0 +1,37 @@
+/**
+ * The org's tool plane: every tool it can reach, and which of them are on.
+ *
+ *   GET /v1/tool?source=&activated=true   {tools: [{name, source, description, activated, dispatchable}]}
+ *   GET /v1/tool/activation               {enabled: [name]}
+ *   PUT /v1/tool/activation               {activate: [name], deactivate: [name]} → {enabled: [name]}
+ *
+ * A tool is on per org. On is what puts a skill's SKILL.md in an agent's prompt
+ * and what lets an MCP server's tool be called; a tool that is off is listed and
+ * refused at call time. Any member of the org may switch one — the handler asks
+ * for the org and nothing more.
+ */
+import { call, query } from './call.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+export const names = (v) => (Array.isArray(v) ? v.filter((n) => typeof n === 'string' && n !== '') : []);
+export function tool(raw) {
+    const o = obj(raw);
+    return { name: str(o.name), source: str(o.source), description: str(o.description), activated: o.activated === true };
+}
+/** The tools in one listing, whichever of the plane's two envelopes it came in. */
+export function toolsOf(raw) {
+    const list = obj(raw).tools;
+    return (Array.isArray(list) ? list : []).map(tool).filter((x) => x.name);
+}
+/** Every tool the org reaches, narrowed to one source and to the ones that are on when asked. */
+export async function tools(t, q = {}) {
+    return toolsOf(await call(t, 'GET', `/v1/tool${query({ source: q.source, activated: q.activated ? 'true' : undefined })}`));
+}
+/** The names that are on. */
+export async function enabled(t) {
+    return names(obj(await call(t, 'GET', '/v1/tool/activation')).enabled);
+}
+/** Switch names on and off; answers every name that is on afterwards. */
+export async function toggle(t, on, off = []) {
+    return names(obj(await call(t, 'PUT', '/v1/tool/activation', { activate: on, deactivate: off })).enabled);
+}

package/lib/api/turn.d.ts

@@ -1,18 +1,3 @@
-/**
- * What a run's events SAY, as text a person reads.
- *
- * A curated projection, never a dump: an event carries the machinery a run
- * happened on — hosts, paths, whole file bodies — and printing it would put
- * someone's filesystem in front of anyone who can read the run. Each kind gets a
- * sentence built from the few fields that describe the outcome; the rest is
- * dropped by omission, because a projection cannot leak a field it never reads.
- *
- * Every string here is rendered as TEXT by the transcript. Nothing is HTML.
- *
- * The coding plane's vocabulary (apps/coding): `status` for a lifecycle move
- * (started, routed, done, error, stopped, paused), `tool-call` for a step,
- * `log` for a free line. A steering message a person sent is a `message`.
- */
 import type { Event } from './sessions.ts';
 /** The payload as an object. A live frame may carry it as a JSON string. */
 export declare function decode(payload: unknown): Record<string, unknown> | string | null;
@@ -38,7 +23,12 @@ export interface StepLine {
     name: string;
     done: boolean;
 }
-/** Tool calls, in the order they were first named. A later status for the same step wins. */
+/**
+ * Tool calls, in the order they were first named. A later status for the same
+ * step wins, and a run's steps follow one another, so a step another has
+ * followed is over. `exit` is not a step: it is how the sandbox says one command
+ * in it ended (apps/sandbox work.go).
+ */
 export declare function steps(events: Pick<Event, 'kind' | 'payload' | 'seq'>[]): StepLine[];
 export interface Outcome {
     /** The last lifecycle status the run narrated, or ''. */
@@ -71,3 +61,81 @@ export declare function pull(url: string, repo: string): {
     href: string;
     label: string;
 };
+/** How a card's work went. One still running once the run has ended was cut off. */
+export type Ran = 'running' | 'done' | 'error' | 'cancelled';
+/**
+ * One piece of the transcript, drawn by what it is.
+ *
+ *   said   prose: the agent's messages (markdown), or a person's steering words
+ *   shell  a command the agent ran, and what it printed
+ *   edit   files the agent changed, with the diff when the harness printed one
+ *   read   a file the agent read, drawn as a chip
+ *   step   a step of the run itself (lease, clone, install, push), or a tool the agent called
+ *   note   a lifecycle line: started, pushed, stopped
+ *   plan   a plan run's answer, which can be approved into a build
+ */
+export type Card = {
+    kind: 'said';
+    key: string;
+    who: 'person' | 'agent';
+    text: string;
+} | {
+    kind: 'shell';
+    key: string;
+    command: string;
+    output: string;
+    ran: Ran;
+} | {
+    kind: 'edit';
+    key: string;
+    files: string[];
+    patch: string;
+    ran: Ran;
+} | {
+    kind: 'read';
+    key: string;
+    file: string;
+    ran: Ran;
+} | {
+    kind: 'step';
+    key: string;
+    name: string;
+    detail: string;
+    output: string;
+    ran: Ran;
+} | {
+    kind: 'note';
+    key: string;
+    text: string;
+} | {
+    kind: 'plan';
+    key: string;
+    text: string;
+};
+/**
+ * A run's events, as the cards its transcript draws. `mode` is the run's, from
+ * its record: a plan's final status is its plan, and nothing else draws a plan.
+ *
+ * The run's own steps arrive as `tool-call` {step, message, status}; each
+ * command in the sandbox narrates its output as `log` {message} chunks and ends
+ * with `tool-call` {step: "exit"}. The output after the step that starts the
+ * agent is the agent's, read by its harness's grammar (harness.ts); after any
+ * other step it is that step's. Once the agent has exited, the commands the run
+ * runs before it pushes commit its work.
+ */
+export declare function cards(events: Pick<Event, 'kind' | 'payload' | 'seq'>[], mode?: string): Card[];
+/** The plan a plan run answered with, from its final status, or ''. */
+export declare function answer(events: Pick<Event, 'kind' | 'payload' | 'seq'>[]): string;
+export interface Settled {
+    /** The run has said how it ended, or that it paused: its work is where it will stay. */
+    settled: boolean;
+    /** That work is on the run's own branch, which a follow-up can start from. */
+    pushed: boolean;
+}
+/**
+ * Whether the run has kept its work yet, and whether that work is on its
+ * branch. A stop or a pause commits and pushes AFTER it is asked, and says so
+ * in its status (apps/coding coding.go interrupted): until then a follow-up
+ * would clone a branch the push has not reached.
+ */
+export declare function settled(events: Pick<Event, 'kind' | 'payload' | 'seq'>[]): Settled;

package/lib/api/turn.js

@@ -1,3 +1,24 @@
+/**
+ * What a run's events SAY, as text a person reads.
+ *
+ * A curated projection, never a dump: an event carries the machinery a run
+ * happened on — hosts, paths, whole file bodies — and printing it would put
+ * someone's filesystem in front of anyone who can read the run. Each kind gets a
+ * sentence built from the few fields that describe the outcome; the rest is
+ * dropped by omission, because a projection cannot leak a field it never reads.
+ *
+ * Every string here is rendered as TEXT by the transcript. Nothing is HTML.
+ *
+ * The coding plane's vocabulary (apps/coding): `status` for a lifecycle move
+ * (started, routed, done, error, stopped, paused), `tool-call` for a step,
+ * `log` for a free line. A person's steering is a `control` {command, message}.
+ *
+ * `cards` is the transcript as it is drawn: the run's steps, and the agent's own
+ * output read by what each part is (harness.ts). The output a card shows is what
+ * the run's Terminal log already prints; a command's working directory, which is
+ * the sandbox's layout, is dropped.
+ */
+import { harness } from './harness.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 /** The payload as an object. A live frame may carry it as a JSON string. */
 export function decode(payload) {
@@ -50,7 +71,10 @@ function status(b, mode) {
         case 'stopped':
             return branch && b.changed ? `Stopped — work kept on ${branch}` : 'Stopped';
         case 'paused':
-            return 'Paused';
+            return branch && b.changed ? `Paused — work kept on ${branch}` : 'Paused';
+        case 'followed':
+            // A run redirected from a chat thread is carried on by a follow-up (apps/coding steer.go).
+            return str(b.next) ? 'Continued in a follow-up run' : 'The follow-up run could not start';
     }
     return str(b.status);
 }
@@ -123,7 +147,12 @@ export function shell(events) {
     }
     return out.slice(-400);
 }
-/** Tool calls, in the order they were first named. A later status for the same step wins. */
+/**
+ * Tool calls, in the order they were first named. A later status for the same
+ * step wins, and a run's steps follow one another, so a step another has
+ * followed is over. `exit` is not a step: it is how the sandbox says one command
+ * in it ended (apps/sandbox work.go).
+ */
 export function steps(events) {
     const order = [];
     const done = new Map();
@@ -134,14 +163,14 @@ export function steps(events) {
         if (!body || typeof body === 'string')
             continue;
         const name = str(body.step);
-        if (!name)
+        if (!name || name === 'exit')
             continue;
         if (!done.has(name))
             order.push(name);
         const status = str(body.status);
         done.set(name, status === 'ok' || status === 'done' || status === 'error');
     }
-    return order.map((name) => ({ name, done: done.get(name) === true }));
+    return order.map((name, i) => ({ name, done: i < order.length - 1 || done.get(name) === true }));
 }
 /**
  * What the run narrated about how it ended, latest winning. Status text only:
@@ -190,3 +219,191 @@ export function pull(url, repo) {
         return { href: '', label: '' };
     return { href: url, label: `#${m[3]}` };
 }
+/** The platform's own words for the step that starts the agent (apps/coding sandboxrunner.go). */
+const TASK = 'running the task';
+/** What the run's own steps are called on a card. */
+const NAMES = {
+    lease: 'Sandbox',
+    clone: 'Clone',
+    secrets: 'Secrets',
+    install: 'Install',
+    start: 'Start',
+    push: 'Push',
+    keep: 'Keep the work',
+};
+/** Steps another card already says: `leased` finishes the lease, `done` is the final status, `ended` is housekeeping. */
+const QUIET = new Set(['leased', 'done', 'ended']);
+const ranOf = (status) => (status === 'ok' || status === 'done' ? 'done' : status === 'error' ? 'error' : 'running');
+/**
+ * A run's events, as the cards its transcript draws. `mode` is the run's, from
+ * its record: a plan's final status is its plan, and nothing else draws a plan.
+ *
+ * The run's own steps arrive as `tool-call` {step, message, status}; each
+ * command in the sandbox narrates its output as `log` {message} chunks and ends
+ * with `tool-call` {step: "exit"}. The output after the step that starts the
+ * agent is the agent's, read by its harness's grammar (harness.ts); after any
+ * other step it is that step's. Once the agent has exited, the commands the run
+ * runs before it pushes commit its work.
+ */
+export function cards(events, mode = '') {
+    const out = [];
+    let seq = 0;
+    let n = 0;
+    const mint = () => `${seq}.${n++}`;
+    let phase = null;
+    let agent = null;
+    // The agent has run and exited: output with no step of its own is the run's.
+    let exited = false;
+    const settle = () => {
+        agent?.end();
+        agent = null;
+        phase = null;
+    };
+    const answers = new Set();
+    for (const e of [...events].sort((a, b) => a.seq - b.seq)) {
+        seq = e.seq;
+        n = 0;
+        const body = decode(e.payload);
+        const b = body && typeof body === 'object' ? body : null;
+        switch (e.kind) {
+            case 'log': {
+                const text = typeof body === 'string' ? body : str(b?.message) || str(b?.text);
+                if (!text)
+                    break;
+                if (!agent && !phase && exited) {
+                    phase = { kind: 'step', key: mint(), name: 'Commit', detail: 'committing the work', output: '', ran: 'running' };
+                    out.push(phase);
+                }
+                if (!agent && !phase)
+                    agent = harness(out, mint);
+                if (agent)
+                    agent.feed(text);
+                else if (phase)
+                    phase.output += text;
+                break;
+            }
+            case 'tool-call': {
+                if (!b)
+                    break;
+                const step = str(b.step);
+                const message = str(b.message);
+                if (step === 'exit') {
+                    // One command in the sandbox ended: `exit 0`, `exit 1`, or `ended: …`.
+                    if (agent) {
+                        settle();
+                        exited = true;
+                    }
+                    else if (phase && phase.ran === 'running')
+                        phase.ran = message === 'exit 0' ? 'done' : 'error';
+                    break;
+                }
+                if (message === TASK) {
+                    settle();
+                    exited = false;
+                    agent = harness(out, mint);
+                    break;
+                }
+                if (step === 'leased') {
+                    const lease = out.find((c) => c.kind === 'step' && c.name === NAMES.lease);
+                    if (lease)
+                        lease.ran = 'done';
+                }
+                if (!step || QUIET.has(step))
+                    break;
+                const name = NAMES[step] ?? step.charAt(0).toUpperCase() + step.slice(1);
+                if (phase && phase.name === name) {
+                    phase.ran = ranOf(str(b.status));
+                    if (message)
+                        phase.detail = message;
+                    break;
+                }
+                settle();
+                phase = { kind: 'step', key: mint(), name, detail: message, output: '', ran: ranOf(str(b.status)) };
+                out.push(phase);
+                break;
+            }
+            case 'status': {
+                settle();
+                if (!b)
+                    break;
+                const text = str(b.plan);
+                if (str(b.status) === 'done' && (mode === 'plan' || mode === 'setup') && text) {
+                    answers.add(text.trim());
+                    out.push(mode === 'plan' ? { kind: 'plan', key: mint(), text } : { kind: 'said', key: mint(), who: 'agent', text });
+                    break;
+                }
+                const line = status(b, mode);
+                if (line)
+                    out.push({ kind: 'note', key: mint(), text: line });
+                break;
+            }
+            case 'control': {
+                if (!b)
+                    break;
+                const command = str(b.command);
+                const said = str(b.message);
+                if (command === 'message' && said)
+                    out.push({ kind: 'said', key: mint(), who: 'person', text: said });
+                else if (command === 'pause')
+                    out.push({ kind: 'note', key: mint(), text: 'Pause asked' });
+                else if (command === 'resume')
+                    out.push({ kind: 'note', key: mint(), text: 'Resume asked' });
+                else if (command === 'stop')
+                    out.push({ kind: 'note', key: mint(), text: 'Stop asked' });
+                break;
+            }
+            case 'message': {
+                const text = typeof body === 'string' ? body : str(b?.text) || str(b?.content) || str(b?.message);
+                if (text)
+                    out.push({ kind: 'said', key: mint(), who: str(b?.role) === 'user' ? 'person' : 'agent', text });
+                break;
+            }
+        }
+    }
+    settle();
+    // The answer the final status carries is also the agent's last message: draw it once, as the answer.
+    let kept = false;
+    for (let i = out.length - 1; i >= 0; i--) {
+        const c = out[i];
+        if (!((c.kind === 'said' && c.who === 'agent') || c.kind === 'plan') || !answers.has(c.text.trim()))
+            continue;
+        if (kept)
+            out.splice(i, 1);
+        kept = true;
+    }
+    return out;
+}
+/** The plan a plan run answered with, from its final status, or ''. */
+export function answer(events) {
+    let out = '';
+    for (const e of [...events].sort((a, b) => a.seq - b.seq)) {
+        if (e.kind !== 'status')
+            continue;
+        const b = decode(e.payload);
+        if (b && typeof b === 'object' && str(b.status) === 'done')
+            out = str(b.plan);
+    }
+    return out;
+}
+/**
+ * Whether the run has kept its work yet, and whether that work is on its
+ * branch. A stop or a pause commits and pushes AFTER it is asked, and says so
+ * in its status (apps/coding coding.go interrupted): until then a follow-up
+ * would clone a branch the push has not reached.
+ */
+export function settled(events) {
+    const out = { settled: false, pushed: false };
+    for (const e of [...events].sort((a, b) => a.seq - b.seq)) {
+        if (e.kind !== 'status')
+            continue;
+        const b = decode(e.payload);
+        if (!b || typeof b === 'string')
+            continue;
+        const s = str(b.status);
+        if (s === 'done' || s === 'error' || s === 'stopped' || s === 'paused') {
+            out.settled = true;
+            out.pushed = b.changed === true;
+        }
+    }
+    return out;
+}

package/lib/api/webhooks.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The organization's webhooks: https endpoints that each matching platform event
+ * is POSTed to, signed.
+ *
+ *   GET    /v1/webhook                    {data: [endpoint]}, newest first, secrets withheld
+ *   POST   /v1/webhook                    {url, events, description} → 201, the secret shown this once
+ *   DELETE /v1/webhook/{id}               204
+ *   POST   /v1/webhook/{id}/test          one signed test event, sent now → {delivered, httpStatus, durationMs, error}
+ *   GET    /v1/webhook/{id}/deliveries    {data: [attempt]}, newest first
+ *
+ * The org is the caller's; an endpoint another org owns reads as not found.
+ * Events are subject patterns (`commerce.order.>`); none means every event.
+ */
+import { type Target } from './call.ts';
+export interface Endpoint {
+    id: string;
+    url: string;
+    /** Subject patterns; empty is every event. */
+    events: string[];
+    description: string;
+    /** active | disabled */
+    status: string;
+    /** The signing secret: present only in the answer to a create. */
+    secret: string;
+    created: string;
+    /** Settled in the last seven days, and how many of those failed. */
+    deliveries: number;
+    failures: number;
+}
+export declare function endpoint(raw: unknown): Endpoint;
+export declare function endpoints(t: Target): Promise<Endpoint[]>;
+/** The patterns in what a person typed: comma or space separated. */
+export declare function patterns(typed: string): string[];
+export interface Draft {
+    url: string;
+    events: string[];
+    description: string;
+}
+/** Why a draft cannot be sent, or ''. The platform refuses the same things. */
+export declare function refuse(d: Draft): string;
+export declare function add(t: Target, d: Draft): Promise<Endpoint>;
+export declare function remove(t: Target, id: string): Promise<void>;
+export interface Trial {
+    delivered: boolean;
+    /** 0 when the endpoint never answered. */
+    status: number;
+    ms: number;
+    error: string;
+}
+export declare function test(t: Target, id: string): Promise<Trial>;
+export interface Attempt {
+    subject: string;
+    /** ok | retrying | failed */
+    status: string;
+    code: number;
+    attempt: number;
+    error: string;
+    at: string;
+}
+export declare function deliveries(t: Target, id: string, limit?: number): Promise<Attempt[]>;

package/lib/api/webhooks.js

@@ -0,0 +1,81 @@
+/**
+ * The organization's webhooks: https endpoints that each matching platform event
+ * is POSTed to, signed.
+ *
+ *   GET    /v1/webhook                    {data: [endpoint]}, newest first, secrets withheld
+ *   POST   /v1/webhook                    {url, events, description} → 201, the secret shown this once
+ *   DELETE /v1/webhook/{id}               204
+ *   POST   /v1/webhook/{id}/test          one signed test event, sent now → {delivered, httpStatus, durationMs, error}
+ *   GET    /v1/webhook/{id}/deliveries    {data: [attempt]}, newest first
+ *
+ * The org is the caller's; an endpoint another org owns reads as not found.
+ * Events are subject patterns (`commerce.order.>`); none means every event.
+ */
+import { call, query, seg } from './call.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+const arr = (v) => (Array.isArray(v) ? v : []);
+export function endpoint(raw) {
+    const e = obj(raw);
+    return {
+        id: str(e.id),
+        url: str(e.url),
+        events: arr(e.events).filter((s) => typeof s === 'string' && s !== ''),
+        description: str(e.description),
+        status: str(e.status) || 'active',
+        secret: str(e.secret),
+        created: str(e.created),
+        deliveries: num(e.deliveries7d),
+        failures: num(e.failures7d),
+    };
+}
+export async function endpoints(t) {
+    const raw = obj(await call(t, 'GET', '/v1/webhook'));
+    return arr(raw.data).map(endpoint).filter((e) => e.id);
+}
+/** The patterns in what a person typed: comma or space separated. */
+export function patterns(typed) {
+    return [...new Set(typed.split(/[\s,]+/).map((s) => s.trim()).filter(Boolean))];
+}
+/** Why a draft cannot be sent, or ''. The platform refuses the same things. */
+export function refuse(d) {
+    let u;
+    try {
+        u = new URL(d.url.trim());
+    }
+    catch {
+        return 'Enter the https address to deliver to';
+    }
+    if (u.protocol !== 'https:')
+        return 'A webhook is delivered over https only';
+    if (d.events.length > 64)
+        return 'At most 64 event patterns';
+    return '';
+}
+export async function add(t, d) {
+    const why = refuse(d);
+    if (why)
+        throw new Error(why);
+    return endpoint(await call(t, 'POST', '/v1/webhook', { url: d.url.trim(), events: d.events, description: d.description.trim() }));
+}
+export async function remove(t, id) {
+    await call(t, 'DELETE', `/v1/webhook/${seg(id)}`);
+}
+export async function test(t, id) {
+    const r = obj(await call(t, 'POST', `/v1/webhook/${seg(id)}/test`, {}));
+    return { delivered: r.delivered === true, status: num(r.httpStatus), ms: num(r.durationMs), error: str(r.error) };
+}
+export async function deliveries(t, id, limit = 10) {
+    const raw = obj(await call(t, 'GET', `/v1/webhook/${seg(id)}/deliveries${query({ limit })}`));
+    return arr(raw.data)
+        .map(obj)
+        .map((a) => ({
+        subject: str(a.subject),
+        status: str(a.status),
+        code: num(a.httpStatus),
+        attempt: num(a.attempt),
+        error: str(a.error),
+        at: str(a.created),
+    }));
+}

package/lib/ask.d.ts

@@ -0,0 +1,18 @@
+export declare function Confirm({ open, onOpenChange, title, says, act, run, }: {
+    open: boolean;
+    onOpenChange: (o: boolean) => void;
+    title: string;
+    /** The whole consequence, stated plainly. */
+    says: string;
+    /** The button's word: Delete, Remove, Forget. */
+    act: string;
+    run: () => Promise<void>;
+}): import("react").JSX.Element;
+export declare function Rename({ open, onOpenChange, title, name, run, }: {
+    open: boolean;
+    onOpenChange: (o: boolean) => void;
+    title: string;
+    /** The name it has now. */
+    name: string;
+    run: (next: string) => Promise<void>;
+}): import("react").JSX.Element;

package/lib/ask.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Asking one thing before an act: to confirm one that cannot be undone, or the
+ * new name for something. A refusal is said in the dialog, which stays open, so
+ * the reason is read where the act was asked for.
+ */
+import { SizableText, XStack } from '@hanzo/gui';
+import { Button, Dialog, DialogContent, DialogTitle, Input } from '@hanzo/ui';
+import { useEffect, useState } from 'react';
+/** One act in flight, and what refused it. */
+function useAct(onDone) {
+    const [working, setWorking] = useState(false);
+    const [note, setNote] = useState('');
+    const go = async (run) => {
+        setWorking(true);
+        setNote('');
+        try {
+            await run();
+            setWorking(false);
+            onDone();
+        }
+        catch (e) {
+            setNote(e instanceof Error ? e.message : 'That did not work');
+            setWorking(false);
+        }
+    };
+    return { working, note, setNote, go };
+}
+function Said({ note }) {
+    if (!note)
+        return null;
+    return (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note }));
+}
+export function Confirm({ open, onOpenChange, title, says, act, run, }) {
+    const { working, note, setNote, go } = useAct(() => onOpenChange(false));
+    const close = (o) => {
+        if (working)
+            return;
+        setNote('');
+        onOpenChange(o);
+    };
+    return (_jsx(Dialog, { open: open, onOpenChange: close, children: _jsxs(DialogContent, { maxW: 420, showCloseButton: false, children: [_jsx(DialogTitle, { children: title }), _jsx(SizableText, { size: "$2", color: "$soft", children: says }), _jsx(Said, { note: note }), _jsxs(XStack, { gap: "$2", justify: "flex-end", children: [_jsx(Button, { size: "sm", variant: "ghost", disabled: working, onPress: () => close(false), children: "Cancel" }), _jsx(Button, { size: "sm", variant: "destructive", disabled: working, onPress: () => void go(run), children: act })] })] }) }));
+}
+export function Rename({ open, onOpenChange, title, name, run, }) {
+    const [value, setValue] = useState(name);
+    const { working, note, setNote, go } = useAct(() => onOpenChange(false));
+    useEffect(() => {
+        if (open)
+            setValue(name);
+    }, [open, name]);
+    const close = (o) => {
+        if (working)
+            return;
+        setNote('');
+        onOpenChange(o);
+    };
+    const save = () => {
+        const next = value.trim();
+        if (!next)
+            return setNote('It needs a name');
+        if (next === name)
+            return close(false);
+        void go(() => run(next));
+    };
+    return (_jsx(Dialog, { open: open, onOpenChange: close, children: _jsxs(DialogContent, { maxW: 420, showCloseButton: false, children: [_jsx(DialogTitle, { children: title }), _jsx(Input, { autoFocus: true, value: value, onChangeText: setValue, "aria-label": "Name", onKeyDown: (e) => {
+                        if ((e.key ?? e.nativeEvent?.key) === 'Enter')
+                            save();
+                    } }), _jsx(Said, { note: note }), _jsxs(XStack, { gap: "$2", justify: "flex-end", children: [_jsx(Button, { size: "sm", variant: "ghost", disabled: working, onPress: () => close(false), children: "Cancel" }), _jsx(Button, { size: "sm", disabled: working, onPress: save, children: "Save" })] })] }) }));
+}