@hanzo/build 0.2.25 → 0.2.27

package/lib/api/changes.d.ts

@@ -1,9 +1,11 @@
 /**
- * What a run changed, read from the forge it pushed to, as the person asking.
+ * What a run changed, read from the forge it pushed to, as the person asking,
+ * and its pull request merged there.
  *
- *   GET /v1/agent/coding/{session}/changes     commits base..head, each file's patch, the pull request
- *   GET /v1/agent/coding/{session}/tree?path=  one directory at the run's branch (its base until it pushes)
- *   GET /v1/agent/coding/{session}/blob?path=  one file there, in /v1/git's blob shape
+ *   GET  /v1/agent/coding/{session}/changes     commits base..head, each file's patch, the pull request
+ *   GET  /v1/agent/coding/{session}/tree?path=  one directory at the run's branch (its base until it pushes)
+ *   GET  /v1/agent/coding/{session}/blob?path=  one file there, in /v1/git's blob shape
+ *   POST /v1/agent/coding/{session}/merge       → {number, url, state, base}; 409 with the forge's reason
  *
  * Before the run pushes, changes answers empty, not 404.
  */
@@ -54,3 +56,19 @@ export declare function changes(raw: unknown): Changes;
 export declare function read(t: Target, session: string): Promise<Changes>;
 export declare function tree(t: Target, session: string, path?: string): Promise<Entry[]>;
 export declare function blob(t: Target, session: string, path: string): Promise<Blob>;
+/** A pull request after its merge. */
+export interface Merged {
+    number: number;
+    url: string;
+    /** `merged`. */
+    state: string;
+    /** The branch it was merged into. */
+    base: string;
+}
+/**
+ * Merge the run's pull request into its base, at the commit the forge holds
+ * now: a push after that is refused, not merged unseen. One already merged
+ * answers as it is; a conflict, a closed pull request or a rule on the base is
+ * a 409 carrying the forge's reason. Nothing is forced.
+ */
+export declare function merge(t: Target, session: string): Promise<Merged>;

package/lib/api/changes.js

@@ -1,9 +1,11 @@
 /**
- * What a run changed, read from the forge it pushed to, as the person asking.
+ * What a run changed, read from the forge it pushed to, as the person asking,
+ * and its pull request merged there.
  *
- *   GET /v1/agent/coding/{session}/changes     commits base..head, each file's patch, the pull request
- *   GET /v1/agent/coding/{session}/tree?path=  one directory at the run's branch (its base until it pushes)
- *   GET /v1/agent/coding/{session}/blob?path=  one file there, in /v1/git's blob shape
+ *   GET  /v1/agent/coding/{session}/changes     commits base..head, each file's patch, the pull request
+ *   GET  /v1/agent/coding/{session}/tree?path=  one directory at the run's branch (its base until it pushes)
+ *   GET  /v1/agent/coding/{session}/blob?path=  one file there, in /v1/git's blob shape
+ *   POST /v1/agent/coding/{session}/merge       → {number, url, state, base}; 409 with the forge's reason
  *
  * Before the run pushes, changes answers empty, not 404.
  */
@@ -61,3 +63,13 @@ export async function tree(t, session, path = '') {
 export async function blob(t, session, path) {
     return file(await call(t, 'GET', `/v1/agent/coding/${seg(session)}/blob${query({ path })}`), path);
 }
+/**
+ * Merge the run's pull request into its base, at the commit the forge holds
+ * now: a push after that is refused, not merged unseen. One already merged
+ * answers as it is; a conflict, a closed pull request or a rule on the base is
+ * a 409 carrying the forge's reason. Nothing is forced.
+ */
+export async function merge(t, session) {
+    const o = obj(await call(t, 'POST', `/v1/agent/coding/${seg(session)}/merge`, {}));
+    return { number: num(o.number), url: str(o.url), state: str(o.state), base: str(o.base) };
+}

package/lib/api/platform.d.ts

@@ -2,7 +2,7 @@
  * Adding a repository to a project, which is how a project is published.
  *
  *   POST /v1/platform/apps {repo, ref, name, partOf, mode, tag?}
- *     → 202 {app, build?: {id, job, image, status}, declaration: {mode, ref, review, live, …}}
+ *     → 202 {app, build?: {id, job, image, status}, declaration: {mode, ref, review, live, …}, notice?}
  *   GET  /v1/platform/builds → {builds: [{id, repo, commit, status, startedAt, duration}]}
  *
  * The declaration is a values file in universe. `branch` (the default) opens a
@@ -10,6 +10,11 @@
  * refuses to name an image that is not built yet, so publishing to main is two
  * calls: build on a branch, then commit that tag once the build is green. An
  * org admin gets both; anyone else gets the review link.
+ *
+ * A repository in the org's own code workspace is its project's site instead:
+ * built in a sandbox and served at the project's address when the build
+ * finishes. That answer is `declaration.live` with a `notice` saying so, and no
+ * review; its build is on the same board, building, succeeded or failed.
  */
 import { type Target } from './call.ts';
 export interface Declare {
@@ -39,6 +44,8 @@ export interface Declared {
     review: string;
     /** Whether anything can deploy from this write. */
     live: boolean;
+    /** What the platform says of this write in a sentence, or ''. */
+    notice: string;
 }
 export interface Build {
     id: string;

package/lib/api/platform.js

@@ -2,7 +2,7 @@
  * Adding a repository to a project, which is how a project is published.
  *
  *   POST /v1/platform/apps {repo, ref, name, partOf, mode, tag?}
- *     → 202 {app, build?: {id, job, image, status}, declaration: {mode, ref, review, live, …}}
+ *     → 202 {app, build?: {id, job, image, status}, declaration: {mode, ref, review, live, …}, notice?}
  *   GET  /v1/platform/builds → {builds: [{id, repo, commit, status, startedAt, duration}]}
  *
  * The declaration is a values file in universe. `branch` (the default) opens a
@@ -10,6 +10,11 @@
  * refuses to name an image that is not built yet, so publishing to main is two
  * calls: build on a branch, then commit that tag once the build is green. An
  * org admin gets both; anyone else gets the review link.
+ *
+ * A repository in the org's own code workspace is its project's site instead:
+ * built in a sandbox and served at the project's address when the build
+ * finishes. That answer is `declaration.live` with a `notice` saying so, and no
+ * review; its build is on the same board, building, succeeded or failed.
  */
 import { call } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
@@ -49,6 +54,7 @@ export async function declare(t, d) {
         ref: str(dec.ref),
         review: https(str(dec.review)),
         live: dec.live === true,
+        notice: str(raw.notice),
     };
 }
 export async function builds(t) {

package/lib/api/projects.d.ts

@@ -1,9 +1,10 @@
 /**
  * The org's projects: what it has built, and where each one is served.
  *
- *   GET    /v1/projects         → Project[]
- *   PATCH  /v1/projects/{slug}  rename it, or make it public or private
- *   DELETE /v1/projects/{slug}  delete it and take its site down
+ *   GET    /v1/projects                     → Project[]
+ *   PATCH  /v1/projects/{slug}              rename it, or make it public or private
+ *   DELETE /v1/projects/{slug}              delete it and take its site down
+ *   GET    /v1/projects/{slug}/deployments  → Deployment[], newest first
  *
  * `slug` is the one key every surface shares — the address under /dev, the
  * site's name, the `project` a run is tagged with. A project belongs to the org,
@@ -19,6 +20,11 @@ export interface Project {
     repo: string;
     /** The branch pushes to which rebuild it, or ''. */
     branch: string;
+    /**
+     * Where it stands: `building` while a project that has never served is being
+     * published, `live` once it serves, `error` when its build failed. A live
+     * project stays `live` while it is built again.
+     */
     status: string;
     /** The deployed address, or '' when nothing has shipped. */
     live: string;
@@ -42,6 +48,24 @@ export declare function change(t: Target, slug: string, what: {
 }): Promise<Project>;
 /** Delete a project. Its site stops answering and its slug is free again. */
 export declare function remove(t: Target, slug: string): Promise<void>;
+/** One attempt to put a project on its address, as the platform recorded it. */
+export interface Deployment {
+    id: string;
+    /** Counts the project's deployments from 1. */
+    version: number;
+    /** `building`, `live` or `error`, as the platform said. */
+    status: string;
+    /** The revision that was built, or ''. */
+    commit: string;
+    /** What happened, in words: the build's own note, or on a failure why it failed. */
+    message: string;
+    /** Unix seconds; 0 when unknown. */
+    created: number;
+    updated: number;
+}
+export declare function deployment(raw: unknown): Deployment;
+/** A project's deployments, newest first: the first says how its latest build went. */
+export declare function deployments(t: Target, slug: string): Promise<Deployment[]>;
 /** The repository name a project's clone URL names — the last path segment, without `.git`. */
 export declare function name(clone: string): string;
 /** A starter from the public catalog. */
@@ -60,7 +84,9 @@ export interface Template {
 export declare function templates(t: Target): Promise<Template[]>;
 /**
  * Take a copy of a starter: a project whose repository is the starter's own,
- * so what opens is that template rather than a model's imitation of it.
+ * so what opens is that template rather than a model's imitation of it. In an
+ * org whose code is in a workspace the platform made, the copy is published at
+ * once, and answers `building` until it is `live` or its build failed.
  */
 export declare function fork(t: Target, slug: string): Promise<Project>;
 /** `owner/name` from a clone URL — its last two path segments, without `.git`. */

package/lib/api/projects.js

@@ -1,9 +1,10 @@
 /**
  * The org's projects: what it has built, and where each one is served.
  *
- *   GET    /v1/projects         → Project[]
- *   PATCH  /v1/projects/{slug}  rename it, or make it public or private
- *   DELETE /v1/projects/{slug}  delete it and take its site down
+ *   GET    /v1/projects                     → Project[]
+ *   PATCH  /v1/projects/{slug}              rename it, or make it public or private
+ *   DELETE /v1/projects/{slug}              delete it and take its site down
+ *   GET    /v1/projects/{slug}/deployments  → Deployment[], newest first
  *
  * `slug` is the one key every surface shares — the address under /dev, the
  * site's name, the `project` a run is tagged with. A project belongs to the org,
@@ -74,6 +75,26 @@ export async function change(t, slug, what) {
 export async function remove(t, slug) {
     await call(t, 'DELETE', `/v1/projects/${seg(slug)}`);
 }
+export function deployment(raw) {
+    const d = (raw && typeof raw === 'object' ? raw : {});
+    return {
+        id: str(d.id),
+        version: num(d.version),
+        status: str(d.status),
+        commit: str(d.commit),
+        message: str(d.message),
+        created: num(d.createdAt),
+        updated: num(d.updatedAt),
+    };
+}
+/** A project's deployments, newest first: the first says how its latest build went. */
+export async function deployments(t, slug) {
+    const raw = await call(t, 'GET', `/v1/projects/${seg(slug)}/deployments`);
+    return (Array.isArray(raw) ? raw : [])
+        .map(deployment)
+        .filter((d) => d.id)
+        .sort((a, b) => b.version - a.version);
+}
 /** The repository name a project's clone URL names — the last path segment, without `.git`. */
 export function name(clone) {
     const cut = clone.replace(/\.git$/, '').replace(/\/+$/, '');
@@ -100,7 +121,9 @@ export async function templates(t) {
 }
 /**
  * Take a copy of a starter: a project whose repository is the starter's own,
- * so what opens is that template rather than a model's imitation of it.
+ * so what opens is that template rather than a model's imitation of it. In an
+ * org whose code is in a workspace the platform made, the copy is published at
+ * once, and answers `building` until it is `live` or its build failed.
  */
 export async function fork(t, slug) {
     return project(await call(t, 'POST', '/v1/projects/fork', { slug }));

package/lib/api/turn.d.ts

@@ -39,6 +39,12 @@ export interface Outcome {
      * never put on screen as the reason.
      */
     problem: string;
+    /**
+     * The place in the run (its `seq`) of the latest status that said its work
+     * went live on its project's site, or 0. It is the cue to read the project
+     * again; the address shown is the project's own, never one an event names.
+     */
+    published: number;
 }
 /**
  * What the run narrated about how it ended, latest winning. Status text only:

package/lib/api/turn.js

@@ -12,6 +12,8 @@
  * 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}.
+ * A run on a project with a site ends `done` with `live` when it published what
+ * it pushed, or `unpublished` saying why it did not.
  *
  * `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
@@ -62,7 +64,10 @@ function status(b, mode) {
                 return 'Done — nothing to change';
             const pr = str(b.pr);
             const tail = str(b.prError) ? ' — the pull request could not be opened' : pr ? ` — ${pr}` : '';
-            return branch ? `Pushed ${branch}${tail}` : `Done${tail}`;
+            // A run on a project with a site publishes what it pushed, or says why not.
+            const why = str(b.unpublished);
+            const site = why ? ` — not published: ${why}` : str(b.live) ? ' — published' : '';
+            return branch ? `Pushed ${branch}${tail}${site}` : `Done${tail}${site}`;
         }
         case 'error':
             return str(b.error) || 'The run hit an error';
@@ -175,7 +180,7 @@ export function steps(events) {
  * the branch and the pull request are read from the run's record (`pull`).
  */
 export function outcome(events) {
-    const out = { status: '', problem: '' };
+    const out = { status: '', problem: '', published: 0 };
     for (const e of [...events].sort((a, b) => a.seq - b.seq)) {
         if (e.kind !== 'status')
             continue;
@@ -184,6 +189,8 @@ export function outcome(events) {
             continue;
         out.status = str(b.status) || out.status;
         out.problem = str(b.prError) || out.problem;
+        if (str(b.live))
+            out.published = e.seq;
     }
     return out;
 }

package/lib/git.d.ts

@@ -3,6 +3,18 @@ export declare function Git({ session, title, live }: {
     title: string;
     live: boolean;
 }): import("react").JSX.Element;
+/**
+ * Merge for a run's pull request, shown while it is open: `POST …/merge` lands
+ * the run's branch in its base at the commit the forge holds now. One press is
+ * one merge — pressed again while it is out, nothing more is sent — and a
+ * refusal says the forge's reason. `onMerged` reads the run again, which is
+ * what closes the button: the pull request reads merged.
+ */
+export declare function Merge({ session, open, onMerged }: {
+    session: string;
+    open: boolean;
+    onMerged: () => void;
+}): import("react").JSX.Element | null;
 /** A unified diff's lines, coloured by what each does: the Git tab's, and a transcript's edit card's. */
 export declare function Patch({ text }: {
     text: string;

package/lib/git.js

@@ -2,13 +2,15 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 /**
  * A run's Git tab: what it pushed, read from the forge. Diff is the net change
  * from its base, Review is the pull request it opened and what reviewers said,
- * Commits is its branch's history since the base. While the run works it is
- * read again every little while, because a run pushes when it finishes a step.
+ * with Merge while it is open, Commits is its branch's history since the base.
+ * While the run works it is read again every little while, because a run
+ * pushes when it finishes a step.
  */
 import { SizableText, XStack, YStack } from '@hanzo/gui';
 import { ChevronDown, ChevronRight } from '@hanzogui/lucide-icons-2';
+import { Button } from '@hanzo/ui';
 import { useEffect, useState } from 'react';
-import { read } from './api/changes.js';
+import { merge, read } from './api/changes.js';
 import { useRead } from './data.js';
 import { useHost, useTarget } from './host.js';
 import { Out } from './out.js';
@@ -39,7 +41,39 @@ export function Git({ session, title, live }) {
                                             : 'Open'
                                     : c.pull.state === 'merged'
                                         ? 'Merged'
-                                        : 'Closed' }), c.pull.url.startsWith('https://') ? (_jsx(Out, { href: c.pull.url, label: `Open pull request #${c.pull.number}`, children: _jsx(SizableText, { size: "$1", color: "$ink", textDecorationLine: "underline", children: "Open on the forge" }) })) : null] }), c.pull.reviews.length ? (c.pull.reviews.map((r, i) => (_jsxs(YStack, { gap: "$1", pb: "$2", borderBottomWidth: 1, borderColor: "$borderColor", children: [_jsx(SizableText, { size: "$1", color: "$soft", children: [r.author || 'Someone', verdict(r.state), when(r.at)].filter(Boolean).join(' · ') }), r.body ? (_jsx(SizableText, { size: "$2", color: "$ink", children: r.body })) : null] }, i)))) : (_jsx(Soft, { children: "No reviews yet" }))] })) : (_jsx(Soft, { children: "No pull request yet. The run opens one when it pushes its changes." }))) : c.commits.length ? (_jsx(YStack, { children: c.commits.map((k) => (_jsxs(XStack, { gap: "$3", py: "$2", borderBottomWidth: 1, borderColor: "$borderColor", items: "baseline", children: [_jsx(SizableText, { size: "$1", color: "$soft", style: mono, children: k.sha.slice(0, 7) }), _jsxs(YStack, { flex: 1, minW: 0, gap: "$0.5", children: [_jsx(SizableText, { size: "$2", color: "$ink", numberOfLines: 2, children: k.message }), _jsx(SizableText, { size: "$1", color: "$soft", numberOfLines: 1, children: [k.author, when(k.date)].filter(Boolean).join(' · ') })] })] }, k.sha))) })) : (_jsx(Soft, { children: "No pushed commits" }))] }));
+                                        : 'Closed' }), c.pull.url.startsWith('https://') ? (_jsx(Out, { href: c.pull.url, label: `Open pull request #${c.pull.number}`, children: _jsx(SizableText, { size: "$1", color: "$ink", textDecorationLine: "underline", children: "Open on the forge" }) })) : null, _jsx(Merge, { session: session, open: c.pull.state === 'open', onMerged: reload })] }), c.pull.reviews.length ? (c.pull.reviews.map((r, i) => (_jsxs(YStack, { gap: "$1", pb: "$2", borderBottomWidth: 1, borderColor: "$borderColor", children: [_jsx(SizableText, { size: "$1", color: "$soft", children: [r.author || 'Someone', verdict(r.state), when(r.at)].filter(Boolean).join(' · ') }), r.body ? (_jsx(SizableText, { size: "$2", color: "$ink", children: r.body })) : null] }, i)))) : (_jsx(Soft, { children: "No reviews yet" }))] })) : (_jsx(Soft, { children: "No pull request yet. The run opens one when it pushes its changes." }))) : c.commits.length ? (_jsx(YStack, { children: c.commits.map((k) => (_jsxs(XStack, { gap: "$3", py: "$2", borderBottomWidth: 1, borderColor: "$borderColor", items: "baseline", children: [_jsx(SizableText, { size: "$1", color: "$soft", style: mono, children: k.sha.slice(0, 7) }), _jsxs(YStack, { flex: 1, minW: 0, gap: "$0.5", children: [_jsx(SizableText, { size: "$2", color: "$ink", numberOfLines: 2, children: k.message }), _jsx(SizableText, { size: "$1", color: "$soft", numberOfLines: 1, children: [k.author, when(k.date)].filter(Boolean).join(' · ') })] })] }, k.sha))) })) : (_jsx(Soft, { children: "No pushed commits" }))] }));
+}
+/**
+ * Merge for a run's pull request, shown while it is open: `POST …/merge` lands
+ * the run's branch in its base at the commit the forge holds now. One press is
+ * one merge — pressed again while it is out, nothing more is sent — and a
+ * refusal says the forge's reason. `onMerged` reads the run again, which is
+ * what closes the button: the pull request reads merged.
+ */
+export function Merge({ session, open, onMerged }) {
+    const t = useTarget();
+    const [busy, setBusy] = useState(false);
+    const [note, setNote] = useState('');
+    const press = async () => {
+        if (busy)
+            return;
+        setBusy(true);
+        setNote('');
+        try {
+            const done = await merge(t, session);
+            setNote(done.base ? `Merged into ${done.base}` : 'Merged');
+            onMerged();
+        }
+        catch (e) {
+            setNote(e.message);
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    if (!open && !note)
+        return null;
+    return (_jsxs(XStack, { items: "center", gap: "$2", flexWrap: "wrap", children: [open ? (_jsx(Button, { size: "sm", variant: "outline", "aria-busy": busy, onPress: () => void press(), children: busy ? 'Merging…' : 'Merge' })) : null, note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note })) : null] }));
 }
 function File({ change: f, first }) {
     const [open, setOpen] = useState(false);

package/lib/project.js

@@ -16,6 +16,12 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
  * preview is the project's own deployed address; a run's sandbox serves no
  * address the platform publishes, and nothing here invents one.
  *
+ * A project in a workspace the platform made is published by the platform: a
+ * template taken there reads `building` until its copy is `live` or failed, and
+ * is read again until then; a run that publishes what it pushed says so on its
+ * final status, which reads the project again and loads the preview again. Its
+ * pull request is merged from beside its link.
+ *
  * Derived from the Hanzo App v2 editor (github.com/hanzoai/build-v2), itself
  * derived from OSW Studio and DeepSite (MIT). See NOTICE.
  */
@@ -26,19 +32,23 @@ import { Composer, Message } from '@hanzo/ui/chat';
 import { Button, Dialog, DialogContent, DialogTitle } from '@hanzo/ui';
 import { HanzoMark } from '@hanzo/ui/product';
 import { useEffect, useMemo, useRef, useState } from 'react';
+import { read as pushed } from './api/changes.js';
 import { start } from './api/coding.js';
 import { blob, tree } from './api/git.js';
-import { name as repoName, ours, templates } from './api/projects.js';
+import { deployments, name as repoName, ours, templates } from './api/projects.js';
 import { list, message, stop } from './api/sessions.js';
 import { outcome, pull, said, who } from './api/turn.js';
 import { verdict as record } from './api/verdict.js';
 import { useKept, useProjects, useRead, useRun } from './data.js';
+import { Merge } from './git.js';
 import { useHost, useTarget } from './host.js';
 import { MODES } from './landing.js';
 import { Out } from './out.js';
 import { Publish } from './publish.js';
 import { Attach, compose, Dictate, Files } from './tools.js';
 const LIVE = new Set(['running', 'paused']);
+/** How often a project being published is read again, ms. */
+const AGAIN = 5000;
 /** One run in the conversation: what was asked, and what it came to. */
 function Turn({ run, open, onOpen, project }) {
     const t = useTarget();
@@ -58,6 +68,19 @@ export function Project({ slug }) {
     const signed = Boolean(host.person);
     const all = useProjects(t, signed);
     const project = all.value.find((p) => p.slug === slug) ?? null;
+    // A project that has never served reads `building` while it is published, and
+    // is read again until it is live or its build failed.
+    const building = project?.status === 'building';
+    const failed = project?.status === 'error';
+    const { reload: again } = all;
+    useEffect(() => {
+        if (!building)
+            return;
+        const every = setInterval(again, AGAIN);
+        return () => clearInterval(every);
+    }, [building, again]);
+    // Why the build failed is its latest deployment's to say.
+    const failure = useRead(failed ? () => deployments(t, slug) : null, [], [t, slug, failed, project?.updated]);
     const listed = useRead(signed ? () => list(t, { kind: 'coding', project: slug, limit: 50 }) : null, [], [t, signed, slug]);
     // Only the runs on this project's own repository: a record can be moved into
     // any project, and a run's branch is what Files, Code and Publish read.
@@ -91,6 +114,36 @@ export function Project({ slug }) {
     const [publish, setPublish] = useState(null);
     const [switcher, setSwitcher] = useState(false);
     const frame = useRef(null);
+    // What was published may be new files at the same address: the project is read
+    // for its address, and the frame loads again.
+    const fresh = () => {
+        again();
+        frame.current?.reload();
+    };
+    // The open run's final status says when it published what it pushed. That is
+    // narration, which any member can write, so it is the cue to read the project
+    // and never the address framed; one already there when the run was first read
+    // is not news.
+    const heard = useRef({ run: null, at: 0 });
+    useEffect(() => {
+        if (!run.record)
+            return;
+        if (heard.current.run !== current) {
+            heard.current = { run: current, at: end.published };
+            return;
+        }
+        if (end.published <= heard.current.at)
+            return;
+        heard.current.at = end.published;
+        fresh();
+        // `fresh` reads what it needs when it runs.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [current, run.record, end.published]);
+    // Where the open run's pull request stands on the forge: Merge is offered while it is open.
+    const proposal = useRead(signed && current && pr.href ? () => pushed(t, current).then((c) => ({ run: current, pull: c.pull })) : null, null, [t, signed, current, pr.href]);
+    const proposing = proposal.value?.run === current && proposal.value.pull?.state === 'open';
+    // Files is drawn again after a merge, from what the forge holds now.
+    const [round, setRound] = useState(0);
     // Files and Code: native git, at the branch the open run pushed (or the project's own).
     const repo = project?.repo ? repoName(project.repo) : '';
     const ref = run.record?.branch || project?.branch || 'main';
@@ -124,13 +177,19 @@ export function Project({ slug }) {
             .filter((e) => !e.dir && /\.html?$/i.test(e.name) && !/^index\.html?$/i.test(e.name))
             .map((e) => ({ id: `/${e.path}`, label: e.name.replace(/\.html?$/i, '') })),
     ], [root.value]);
-    // A project taken from a starter and not yet published shows the starter's own
-    // live page, which is what the copy is until its first publish.
-    const forked = project && !project.live ? project.forked : '';
+    // A project taken from a starter, not published and not being, shows the
+    // starter's own live page, which is what the copy is until its first publish.
+    const forked = project && !project.live && !building && !failed ? project.forked : '';
     const starters = useRead(forked ? () => templates(t) : null, [], [t.api, forked]);
     const starter = forked ? starters.value.find((s) => s.slug === forked && s.demo) : undefined;
     const shown = project?.live || starter?.demo || '';
     const src = shown ? new URL(page, shown).toString() : null;
+    const why = failure.value[0]?.message || failure.error?.message || (failure.loading ? '' : 'Its build ended without saying why.');
+    const merged = () => {
+        proposal.reload();
+        root.reload();
+        setRound((n) => n + 1);
+    };
     const lines = useMemo(() => [
         ...run.events
             .filter((e) => e.kind === 'log' || e.kind === 'tool-call' || e.kind === 'status')
@@ -229,18 +288,20 @@ export function Project({ slug }) {
                         ? 'Reading this project’s runs…'
                         : project?.live
                             ? `${project.name} is loaded — it is in the preview, and every run on it is under the clock above. Say what to change and it gets built.`
-                            : starter
-                                ? `${project?.name} is loaded — the preview shows the ${starter.title} starter until your copy is published. Say what to change and it gets built.`
-                                : project
-                                    ? `${project.name} is loaded and nothing is published yet. Say what to change and it gets built.`
-                                    : `${slug} is loaded. Say what to change and it gets built.` })) : (ordered.map((r) => (_jsxs(YStack, { gap: "$2", children: [_jsx(Turn, { run: r, open: r.id === current, onOpen: () => setChosen(r.id), project: slug }), r.id === current ? (_jsxs(YStack, { gap: "$1", pl: "$2", borderLeftWidth: 1, borderColor: "$borderColor", children: [fold(run.events.map((e) => ({ kind: e.kind, actor: who(e.actor), seq: e.seq, id: e.id, text: said(e, run.record?.mode) })).filter((b) => b.text)).map((b) => (_jsx(SizableText, { size: "$1", color: "$soft", children: b.text }, b.key))), pr.href ? (_jsxs(Out, { href: pr.href, label: `Open pull request ${pr.label}`, children: [_jsxs(SizableText, { size: "$1", color: "$ink", textDecorationLine: "underline", children: ["Pull request ", pr.label] }), _jsx(ExternalLink, { size: 11 })] })) : null] })) : null] }, r.id)))) }), _jsxs(YStack, { px: "$3", pb: "$3", gap: "$2", children: [!dismissed && !running ? _jsx(Suggestions, { items: SUGGESTIONS, onPick: (s) => void send(s), onDismiss: () => setDismissed(true) }) : null, note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note })) : null, picked.length ? _jsx(Attachments, { items: picked, onRemove: () => setPicked([]) }) : null, attached.length ? (_jsx(XStack, { gap: 6, flexWrap: "wrap", children: _jsx(Files, { files: attached, onFiles: setAttached }) })) : null, _jsxs(Composer, { value: draft, onChange: setDraft, onSend: () => void (current && running ? steer(current) : send()), onStop: current
+                            : building
+                                ? `${project?.name} is being published — it appears in the preview when its build finishes. Say what to change and it gets built.`
+                                : starter
+                                    ? `${project?.name} is loaded — the preview shows the ${starter.title} starter until your copy is published. Say what to change and it gets built.`
+                                    : project
+                                        ? `${project.name} is loaded and nothing is published yet. Say what to change and it gets built.`
+                                        : `${slug} is loaded. Say what to change and it gets built.` })) : (ordered.map((r) => (_jsxs(YStack, { gap: "$2", children: [_jsx(Turn, { run: r, open: r.id === current, onOpen: () => setChosen(r.id), project: slug }), r.id === current ? (_jsxs(YStack, { gap: "$1", pl: "$2", borderLeftWidth: 1, borderColor: "$borderColor", children: [fold(run.events.map((e) => ({ kind: e.kind, actor: who(e.actor), seq: e.seq, id: e.id, text: said(e, run.record?.mode) })).filter((b) => b.text)).map((b) => (_jsx(SizableText, { size: "$1", color: "$soft", children: b.text }, b.key))), pr.href ? (_jsxs(XStack, { items: "center", gap: "$2", flexWrap: "wrap", children: [_jsxs(Out, { href: pr.href, label: `Open pull request ${pr.label}`, children: [_jsxs(SizableText, { size: "$1", color: "$ink", textDecorationLine: "underline", children: ["Pull request ", pr.label] }), _jsx(ExternalLink, { size: 11 })] }), _jsx(Merge, { session: r.id, open: proposing, onMerged: merged })] })) : null] })) : null] }, r.id)))) }), _jsxs(YStack, { px: "$3", pb: "$3", gap: "$2", children: [!dismissed && !running ? _jsx(Suggestions, { items: SUGGESTIONS, onPick: (s) => void send(s), onDismiss: () => setDismissed(true) }) : null, note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note })) : null, picked.length ? _jsx(Attachments, { items: picked, onRemove: () => setPicked([]) }) : null, attached.length ? (_jsx(XStack, { gap: 6, flexWrap: "wrap", children: _jsx(Files, { files: attached, onFiles: setAttached }) })) : null, _jsxs(Composer, { value: draft, onChange: setDraft, onSend: () => void (current && running ? steer(current) : send()), onStop: current
                             ? () => void stop(t, current).then(() => setNote('Stop requested — the run keeps its work on its branch'), (e) => setNote(e.message))
                             : undefined, busy: busy || (running && !draft.trim()), rows: 3, placeholder: running ? 'Steer this run' : 'Ask Hanzo for edits', label: "Ask Hanzo for edits", children: [_jsx(Attach, { files: attached, onFiles: setAttached, onNote: setNote }), _jsx(XStack, { flex: 1 }), _jsx(ModeSelect, { modes: MODES, value: mode, onChange: (m) => setMode(m), self: "center" }), _jsx(Dictate, { onText: (said) => setDraft((d) => (d ? `${d} ${said}` : said)), onNote: setNote })] })] })] }));
-    const body = view === 'preview' ? (_jsx(PreviewFrame, { ref: frame, src: src, title: `${project?.name ?? slug} preview`, device: device, onBridge: onBridge, empty: _jsxs(YStack, { items: "center", gap: "$2", p: "$6", children: [_jsx(SizableText, { size: "$3", color: "$ink", children: "Nothing deployed yet" }), _jsx(SizableText, { size: "$2", color: "$soft", text: "center", children: "Publish this project and its page appears here." })] }), toolbar: bridge ? (_jsx(XStack, { render: "button", "aria-pressed": editing, "aria-label": editing ? 'Stop picking elements' : 'Pick an element to edit', onPress: () => {
+    const body = view === 'preview' ? (_jsx(PreviewFrame, { ref: frame, src: src, title: `${project?.name ?? slug} preview`, device: device, onBridge: onBridge, empty: _jsxs(YStack, { items: "center", gap: "$2", p: "$6", children: [_jsx(SizableText, { size: "$3", color: "$ink", children: building ? (project?.forked ? 'Publishing your copy…' : 'Publishing…') : failed ? 'Publishing failed' : 'Nothing deployed yet' }), _jsx(SizableText, { size: "$2", color: "$soft", text: "center", children: building ? 'Its page appears here when the build finishes.' : failed ? why : 'Publish this project and its page appears here.' })] }), toolbar: bridge ? (_jsx(XStack, { render: "button", "aria-pressed": editing, "aria-label": editing ? 'Stop picking elements' : 'Pick an element to edit', onPress: () => {
                 const next = !editing;
                 setEditing(next);
                 frame.current?.post({ type: 'preview:editable', active: next });
-            }, p: "$2", rounded: "$10", children: _jsx(MousePointerClick, { size: 16 }) })) : undefined })) : view === 'files' ? (repo ? (_jsx(FileTree, { load: async (dir) => (await tree(t, repo, ref, dir)).map((e) => ({ path: e.path, kind: e.dir ? 'dir' : 'file' })), value: file, onSelect: (p) => void openFile(p), label: `${repo} at ${ref}` })) : (_jsx(SizableText, { size: "$2", color: "$soft", p: "$4", children: "This project has no repository yet. Its first run creates one." }))) : view === 'code' ? (_jsx(FileTabs, { files: files, value: file, onSelect: setFile, onClose: (p) => {
+            }, p: "$2", rounded: "$10", children: _jsx(MousePointerClick, { size: 16 }) })) : undefined })) : view === 'files' ? (repo ? (_jsx(FileTree, { load: async (dir) => (await tree(t, repo, ref, dir)).map((e) => ({ path: e.path, kind: e.dir ? 'dir' : 'file' })), value: file, onSelect: (p) => void openFile(p), label: `${repo} at ${ref}` }, round)) : (_jsx(SizableText, { size: "$2", color: "$soft", p: "$4", children: "This project has no repository yet. Its first run creates one." }))) : view === 'code' ? (_jsx(FileTabs, { files: files, value: file, onSelect: setFile, onClose: (p) => {
             setFiles((was) => was.filter((f) => f.path !== p));
             if (file === p)
                 setFile(null);
@@ -259,5 +320,5 @@ export function Project({ slug }) {
                                 }, justify: "space-between", px: "$2", py: "$1.5", rounded: "$3", hoverStyle: { bg: '$hover' }, children: [_jsx(SizableText, { size: "$2", color: "$ink", numberOfLines: 1, flex: 1, children: r.title || 'Untitled run' }), _jsx(SizableText, { size: "$1", color: "$soft", children: r.status })] }, r.id)))) })] }) }), _jsx(Dialog, { open: switcher, onOpenChange: setSwitcher, children: _jsxs(DialogContent, { maxW: 420, children: [_jsx(DialogTitle, { children: "Projects" }), _jsx(YStack, { gap: "$1", maxH: 420, overflow: "scroll", children: all.value.map((p) => (_jsx(XStack, { render: "button", onPress: () => {
                                     setSwitcher(false);
                                     host.go(p.slug);
-                                }, px: "$2", py: "$1.5", rounded: "$3", bg: p.slug === slug ? '$hover' : undefined, hoverStyle: { bg: '$hover' }, children: _jsx(SizableText, { size: "$2", color: "$ink", numberOfLines: 1, children: p.name }) }, p.slug))) })] }) }), _jsx(Publish, { source: publish, onClose: () => setPublish(null) })] }));
+                                }, px: "$2", py: "$1.5", rounded: "$3", bg: p.slug === slug ? '$hover' : undefined, hoverStyle: { bg: '$hover' }, children: _jsx(SizableText, { size: "$2", color: "$ink", numberOfLines: 1, children: p.name }) }, p.slug))) })] }) }), _jsx(Publish, { source: publish, onClose: () => setPublish(null), onLive: fresh })] }));
 }

package/lib/publish.d.ts

@@ -9,7 +9,8 @@ export interface Source {
     /** The project to add it to, when there already is one. */
     project?: string;
 }
-export declare function Publish({ source, onClose }: {
+export declare function Publish({ source, onClose, onLive }: {
     source: Source | null;
     onClose: () => void;
+    onLive?: () => void;
 }): import("react").JSX.Element | null;

package/lib/publish.js

@@ -9,17 +9,23 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * build to main, which CD applies: that is the second call, with the build's
  * tag, because main refuses an image that is not built yet.
  *
+ * A repository in the org's own code workspace answers `live` instead: its
+ * build puts it on the project's address when it finishes, so there is no
+ * review and nothing to take to main. Its build is followed on the board like
+ * any other, and `onLive` is told when it succeeds, so the host reads the
+ * project's address again.
+ *
  * Every state shown is one the platform reported; a refusal shows the
  * platform's own sentence.
  */
 import { SizableText, XStack, YStack } from '@hanzo/gui';
 import { ExternalLink } from '@hanzogui/lucide-icons-2';
 import { Button, Dialog, DialogContent, DialogDescription, DialogTitle, Input } from '@hanzo/ui';
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { builds, declare, label } from './api/platform.js';
 import { useHost, useTarget } from './host.js';
 import { Out } from './out.js';
-export function Publish({ source, onClose }) {
+export function Publish({ source, onClose, onLive }) {
     const t = useTarget();
     const host = useHost();
     const [project, setProject] = useState('');
@@ -27,6 +33,8 @@ export function Publish({ source, onClose }) {
     const [out, setOut] = useState(null);
     const [status, setStatus] = useState('');
     const [error, setError] = useState('');
+    const told = useRef(onLive);
+    told.current = onLive;
     useEffect(() => {
         setProject(source?.project ?? source?.name ?? '');
         setPhase('ask');
@@ -57,6 +65,12 @@ export function Publish({ source, onClose }) {
             clearInterval(every);
         };
     }, [t, out, phase]);
+    const green = /^(succeeded|success|done|complete|completed|ok)$/i.test(status);
+    // A site's build going green is the site going live, at the project's address.
+    useEffect(() => {
+        if (out?.live && green)
+            told.current?.();
+    }, [out, green]);
     if (!source)
         return null;
     const send = async () => {
@@ -75,7 +89,6 @@ export function Publish({ source, onClose }) {
     };
     // The build this write started; its status is what the platform last said of it.
     const built = out?.build?.id ?? '';
-    const green = /^(succeeded|success|done|complete|completed|ok)$/i.test(status);
     // Offered only once that build is green.
     const ship = async () => {
         setPhase('shipping');
@@ -89,7 +102,11 @@ export function Publish({ source, onClose }) {
             setPhase('declared');
         }
     };
-    return (_jsx(Dialog, { open: true, onOpenChange: (o) => !o && onClose(), children: _jsxs(DialogContent, { maxW: 480, children: [_jsx(DialogTitle, { children: "Add to project" }), _jsxs(DialogDescription, { children: ["Build ", source.title, " at ", source.ref, " and declare it in a project. ", host.admin ? 'As an admin you can take a green build to main.' : 'It opens a review; merging it is what deploys.'] }), _jsxs(YStack, { gap: "$1.5", children: [_jsx(SizableText, { render: "label", size: "$2", color: "$soft", htmlFor: "publish-project", children: "Project" }), _jsx(Input, { id: "publish-project", value: project, onChangeText: (v) => setProject(v), disabled: phase !== 'ask' && phase !== 'failed', placeholder: label(source.name), "aria-label": "Project" }), _jsxs(SizableText, { size: "$1", color: "$soft", children: ["Saved as ", label(project || source.name)] })] }), out ? (_jsxs(YStack, { gap: "$2", role: "status", children: [_jsx(SizableText, { size: "$2", color: "$ink", children: phase === 'shipped'
+    return (_jsx(Dialog, { open: true, onOpenChange: (o) => !o && onClose(), children: _jsxs(DialogContent, { maxW: 480, children: [_jsx(DialogTitle, { children: "Add to project" }), _jsx(DialogDescription, { children: out?.live
+                        ? `Build ${source.title} at ${source.ref} and publish it at its project’s address.`
+                        : `Build ${source.title} at ${source.ref} and declare it in a project. ${host.admin ? 'As an admin you can take a green build to main.' : 'It opens a review; merging it is what deploys.'}` }), _jsxs(YStack, { gap: "$1.5", children: [_jsx(SizableText, { render: "label", size: "$2", color: "$soft", htmlFor: "publish-project", children: "Project" }), _jsx(Input, { id: "publish-project", value: project, onChangeText: (v) => setProject(v), disabled: phase !== 'ask' && phase !== 'failed', placeholder: label(source.name), "aria-label": "Project" }), _jsxs(SizableText, { size: "$1", color: "$soft", children: ["Saved as ", label(project || source.name)] })] }), out ? (_jsxs(YStack, { gap: "$2", role: "status", children: [out.notice ? (_jsx(SizableText, { size: "$2", color: "$soft", children: out.notice })) : null, _jsx(SizableText, { size: "$2", color: "$ink", children: phase === 'shipped'
                                 ? 'Declared on main — CD applies it on its next pass.'
-                                : `Build ${built}: ${status || 'building'}` }), out.review ? (_jsxs(Out, { href: out.review, children: [_jsx(SizableText, { size: "$2", color: "$ink", textDecorationLine: "underline", children: "Open the review" }), _jsx(ExternalLink, { size: 12, opacity: 0.6 })] })) : null] })) : null, error ? (_jsx(SizableText, { size: "$2", color: "$red10", role: "alert", children: error })) : null, _jsxs(XStack, { gap: "$2", justify: "flex-end", children: [_jsx(Button, { variant: "outline", size: "sm", onPress: onClose, children: phase === 'shipped' || phase === 'declared' ? 'Done' : 'Cancel' }), phase === 'ask' || phase === 'failed' || phase === 'sending' ? (_jsx(Button, { size: "sm", disabled: phase === 'sending', onPress: () => void send(), children: phase === 'sending' ? 'Adding…' : 'Add to project' })) : host.admin && (phase === 'declared' || phase === 'shipping') ? (_jsx(Button, { size: "sm", disabled: !green || phase === 'shipping', onPress: () => void ship(), children: phase === 'shipping' ? 'Shipping…' : green ? 'Ship to main' : 'Waiting for the build' })) : null] })] }) }));
+                                : out.live && green
+                                    ? `Build ${built} succeeded — it is live at the project’s address.`
+                                    : `Build ${built}: ${status || 'building'}` }), out.review ? (_jsxs(Out, { href: out.review, children: [_jsx(SizableText, { size: "$2", color: "$ink", textDecorationLine: "underline", children: "Open the review" }), _jsx(ExternalLink, { size: 12, opacity: 0.6 })] })) : null] })) : null, error ? (_jsx(SizableText, { size: "$2", color: "$red10", role: "alert", children: error })) : null, _jsxs(XStack, { gap: "$2", justify: "flex-end", children: [_jsx(Button, { variant: "outline", size: "sm", onPress: onClose, children: phase === 'shipped' || phase === 'declared' ? 'Done' : 'Cancel' }), phase === 'ask' || phase === 'failed' || phase === 'sending' ? (_jsx(Button, { size: "sm", disabled: phase === 'sending', onPress: () => void send(), children: phase === 'sending' ? 'Adding…' : 'Add to project' })) : host.admin && !out?.live && (phase === 'declared' || phase === 'shipping') ? (_jsx(Button, { size: "sm", disabled: !green || phase === 'shipping', onPress: () => void ship(), children: phase === 'shipping' ? 'Shipping…' : green ? 'Ship to main' : 'Waiting for the build' })) : null] })] }) }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzo/build",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "type": "module",
   "license": "Apache-2.0 OR MIT",
   "description": "Hanzo Build — say what you want, watch it built, deployed and running. The builder as a component, mounted by the Hanzo app at hanzo.ai.",
@@ -10,7 +10,7 @@
   "devDependencies": {
     "@hanzo/font": "1.9.3",
     "@hanzo/gui": "8.3.5",
-    "@hanzo/iam": "0.21.18",
+    "@hanzo/iam": "0.21.21",
     "@hanzo/ui": "8.27.16",
     "@hanzo/vite": "0.1.4",
     "@hanzo/voice": "0.1.8",