01b2aca · 116897f
@@ -78,6 +78,8 @@
In the terminal, the Capacity screen (palette: Capacity, a forge admin who is a
An admin's home and the terminal's Flow dialog also say when the forge is clogged and how long the last clog took to notice and to clear: `docs/features/clog-watch.md`. A fork whose parent is archived shows one quiet line instead of its ahead/behind count, and its admin can detach it from the parent (Settings › Danger zone, the terminal's About `x`, MCP `detach`): `docs/features/detach.md`.
**Forge it:** a **Forge it** button beside Fork on a repository page (and the terminal's palette entry `Forge it`) makes a fresh forge, named for the repository, with it as the app, and lands on that forge's claim link, where you pick a username and password and become its admin. A second press makes no second forge and shows no second link. Agents: `spawn` with `apps: ["owner/name"]`. `docs/features/forge-it.md`.
A pull the merge queue holds as red alone (red on its own merge at its current head; cleared by a new head or a moved main) says so under its checks line: "red alone at <time>, waiting for a new head or a new main", on the pull page, its live checks line and the studio change step, and in the checks row of the pull's terminal screen (`redMark` in `src/checks/queue.ts`). Nothing is drawn when it is not held.
On a sealed issue, a writer gets the private repository to fix it in: `POST /api/v1/repos/:owner/:name/issues/:number/private`, the issue page's button, and `p` on the issue's terminal screen, which shows the repository and its clone URL (built from the forge's origin). All three refuse alike: not found for anyone who may not see sealed reports, `not_sealed`, and `unverified`.
@@ -0,0 +1,14 @@
# Forge it
A **Forge it** button (rocket icon, outline weight, so it is not mistaken for Fork) sits beside Fork on every repository page, for any signed-in person. One press makes a fresh forge named for the repository (`Bakery_Shop` becomes `bakery-shop`) with that repository as its app, and sends the browser straight to the new forge's claim link. The claim code rides the URL fragment, so there is nothing to copy; choosing a username and password there signs the person in as the new forge's admin.
- Terminal: the repository screen's palette (`:`) has `Forge it`; a confirm, then the claim link once (`src/tui/screens/forge_it.ts`). Both doors share `src/spawn/forge_it.ts`.
- Route: `POST /:owner/:name/forge` (`src/web/pages/forge-it.ts`), same-origin and `admin`-scoped like `POST /forges/new`, which it calls through the spawn door with the defaults.
- A private repository is forged only by those who can read it. Limits (children per forge, rate) are the spawn door's.
- Pressing it twice makes one forge: the second press goes to `/forges`, and the link is not shown again (ask for a new one there).
- Agents: the same thing is MCP `spawn` / `POST /api/v1/forges` with `apps: ["owner/name"]`.
- Tests: `test/tui-forge-it.test.ts` for the terminal; `test/forge-it.test.ts` walks press, claim, signed-in admin, files.
Not here: a hosted child's crew runner (#4416), arriving signed in with no claim form (#2928), choosing a template (#7534, #7535).
Direction: this is a feature ahead of the pipeline-first order only in being a small door onto the spawn path that already exists; it adds no pipeline code. The owner asked for it on #7642.
@@ -265,6 +265,7 @@
import { claimFragmentPage, claimOptions, claimSubmit } from "../web/pages/claim
import { firstAdminOptions, firstAdminPage, firstAdminSubmit } from "../web/pages/first-admin.ts";
import { familyPage } from "../web/pages/family.ts";
import { forgeLinkSubmit, forgesPage } from "../web/pages/forges.ts";
import { forgeItSubmit } from "../web/pages/forge-it.ts";
import { newForgePage, newForgeSubmit } from "../web/pages/new-forge.ts";
import { askedPage } from "../web/studio/asked_page.ts";
import { reviewPage } from "../web/studio/review_page.ts";
@@ -1379,6 +1380,8 @@
export function buildRouter(): Router<Handler> {
  router.add("GET", "/:owner/:name/commits", commitsPage);
  router.add("GET", "/:owner/:name/commit/:oid", commitPage);
  router.add("POST", "/:owner/:name/fork", forkSubmit);
  // Forge it: a fresh forge with this repository as its app, then its claim link.
  router.add("POST", "/:owner/:name/forge", forgeItSubmit);
  // Make it yours (#606): a fork with its app, planned, then made.
  router.add("GET", "/:owner/:name/make-it-yours", makeItYoursPage);
  router.add("POST", "/:owner/:name/make-it-yours", makeItYoursSubmit);
@@ -0,0 +1,30 @@
/**
 * Forge it: one repository becomes the app of a fresh forge. The page's
 * button and the terminal's palette entry both come here, so the name and
 * the spawn are the same in both. It is the spawn door with the choices made.
 */
import type { Repo } from "../core/repos.ts";
import type { User } from "../core/users.ts";
import type { Ctx } from "../http/context.ts";
import { spawnDoor, type Door } from "./door.ts";
import { CHILD_NAME } from "./placement.ts";
/** A forge name from a repository name: lowercase, dashes, at most 38 characters. */
export function forgeNameOf(repoName: string): string {
  const slug = repoName
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/^-+|-+$/g, "")
    .slice(0, 38)
    .replace(/-+$/, "");
  return CHILD_NAME.test(slug) ? slug : "forge";
}
/** Make the forge (the door refuses what a person may not do). */
export const forgeIt = (ctx: Ctx, user: User, repo: Repo): Promise<Door> =>
  spawnDoor(ctx, user, {
    name: forgeNameOf(repo.name),
    apps: [`${repo.ownerName}/${repo.name}`],
    dryRun: false,
  });
@@ -0,0 +1,61 @@
/**
 * Forge it, from a repository screen's `:` palette: the terminal's door to
 * the Forge button beside Fork. A confirm, then the spawn door as the page
 * calls it, and the claim link shown once.
 */
import type { Repo } from "../../core/repos.ts";
import { forgeIt, forgeNameOf } from "../../spawn/forge_it.ts";
import type { Ctx, Screen } from "../app/app.ts";
import type { Command } from "../app/palette.ts";
import type { Session } from "../session.ts";
import { confirmScreen, linkScreen, runAsync } from "./common.ts";
export function forgeItScreen(f: Session, ctx: Ctx, repo: Repo, parent: Screen): Screen {
  const from = `${repo.ownerName}/${repo.name}`;
  return confirmScreen(ctx, parent, {
    title: "Forge it",
    body: [
      `A fresh forge, ${forgeNameOf(repo.name)}, with ${from} as its app.`,
      "You get its claim link once; whoever opens it becomes the admin.",
    ],
    actions: [{ label: "Forge it" }, { label: "Cancel" }],
    onChoose: (choice) => {
      if (choice !== 0 || f.user === undefined) return;
      const user = f.user;
      runAsync(ctx, async () => {
        const url = new URL(f.app.config.url ?? `http://${f.app.config.host ?? "localhost"}`);
        const made = await forgeIt(
          {
            app: f.app,
            request: new Request(url.href, { method: "POST" }),
            url,
            params: {},
            auth: { user, scope: undefined, via: "none" as const },
            theme: undefined,
          },
          user,
          repo,
        );
        if (made.status >= 400) return ctx.toast(String(made.body["message"] ?? "it could not be made"), "danger");
        const link = made.body["claimUrl"];
        if (typeof link !== "string")
          return ctx.toast(`${String(made.body["name"])} was forged before; its link is not shown again`, "attn");
        ctx.toast(`${String(made.body["name"])} is ready`, "success");
        ctx.replace(linkScreen(ctx, link));
      });
    },
  });
}
export function forgeItCommands(f: Session, ctx: Ctx, repo: Repo | undefined, parent: () => Screen): Command[] {
  if (repo === undefined || f.user === undefined || f.user.kind !== "user") return [];
  return [
    {
      id: "forge-it",
      title: `${repo.ownerName}/${repo.name} — Forge it`,
      hint: "a fresh forge with it as the app",
      run: () => ctx.push(forgeItScreen(f, ctx, repo, parent())),
    },
  ];
}
@@ -128,6 +128,7 @@
import { reportCommands } from "./report.ts";
import { reportsCommands } from "./reports.ts";
import { tellCommands } from "./tell.ts";
import { workingCommands } from "./working.ts";
import { forgeItCommands } from "./forge_it.ts";
import { makeItYoursScreen, yoursCommands } from "./yours.ts";
import { visionCommands } from "./vision.ts";
import { appEnvCommands } from "./appenv.ts";
@@ -1438,6 +1439,7 @@
export function workspaceScreen(
      ...reportsCommands(f, ctx, repo),
      ...noteCommands(f, ctx, () => screen, repo),
      ...yoursCommands(f, ctx, repo),
      ...forgeItCommands(f, ctx, repo, () => screen),
      ...hooksCommands(f, ctx, repo),
      ...visionCommands(f, ctx, repo),
      ...appEnvCommands(f, ctx, repo),
@@ -0,0 +1,33 @@
/**
 * Forge it: the verb beside Fork. One press on a repository spins up a fresh
 * forge with that repository as its app, and sends the person straight to the
 * new forge's claim link (the code rides the fragment, so nothing is copied).
 * It is `POST /forges/new` with the choices made for them: the name comes from
 * the repository, everything else is the spawn door's default.
 */
import type { Ctx } from "../../http/context.ts";
import { forgeIt } from "../../spawn/forge_it.ts";
import { loadRepo, notFoundPage, signInFirst } from "../chrome.ts";
import { readForm } from "../form.ts";
import { flashTo, redirect } from "../layout.ts";
// POST /:owner/:name/forge
export async function forgeItSubmit(ctx: Ctx): Promise<Response> {
  const repo = loadRepo(ctx);
  if (!repo) return notFoundPage(ctx);
  const user = ctx.auth.user;
  if (!user) return signInFirst(ctx);
  const form = await readForm(ctx, "admin");
  if (form instanceof Response) return form;
  const back = `/${repo.ownerName}/${repo.name}`;
  const door = await forgeIt(ctx, user, repo);
  if (door.status >= 400)
    return flashTo(ctx, back, { tone: "danger", message: `Not forged: ${String(door.body["message"] ?? "it could not be made")}.` });
  const link = door.body["claimUrl"];
  if (typeof link !== "string")
    return flashTo(ctx, "/forges", { message: `${String(door.body["name"])} was forged before; its link is not shown again.` });
  const response = redirect(link);
  response.headers.set("cache-control", "no-store");
  return response;
}
@@ -239,8 +239,10 @@
function forkRanking(
function forkBar(ctx: Ctx, repo: Repo): Html {
  const canFork =
    ctx.auth.user !== undefined && ctx.auth.user.id !== repo.ownerId;
  // Forge it is for any signed-in person, the owner too: it makes a forge, not a copy in this one.
  const canForge = ctx.auth.user?.kind === "user";
  const forkCount = forksFor(ctx, repo).length;
  if (!canFork && forkCount === 0) return html``;
  if (!canFork && !canForge && forkCount === 0) return html``;
  return html`<div class="mt">
    ${listCard([
      row({
@@ -251,11 +253,15 @@
function forkBar(ctx: Ctx, repo: Repo): Html {
                >${badge(`${forkCount} fork${forkCount === 1 ? "" : "s"}`)}</a
              >`
            : "Forks",
        trail: canFork
        trail: html`${canFork
          ? html`<form method="post" action="${repoBase(repo)}/fork">
              ${btn("Fork", { size: "sm", icon: "fork" })}
            </form>`
          : html``,
          : html``}${canForge
          ? html`<form method="post" action="${repoBase(repo)}/forge">
              ${btn("Forge it", { size: "sm", icon: "rocket", variant: "outline" })}
            </form>`
          : html``}`,
      }),
    ])}
  </div>`;
@@ -0,0 +1,186 @@
/**
 * Forge it (#7642): one press beside Fork on a repository makes a fresh forge
 * with that repository as its app and lands the person on its claim link; the
 * claim signs them in as the new forge's admin, holding the repository's files.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createRepo } from "../src/actions/repos.ts";
import { childDirOf } from "../src/actions/spawn.ts";
import { createApp, type App } from "../src/app.ts";
import { getRepo } from "../src/core/repos.ts";
import { createUser, getUserByName } from "../src/core/users.ts";
import { repoDir } from "../src/git/repos.ts";
import { commitFiles } from "../src/git/write.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { forgeNameOf } from "../src/spawn/forge_it.ts";
import { useProbe } from "../src/spawn/door.ts";
import { firstBoot } from "../src/spawn/first-boot.ts";
import { quietLogs } from "./helpers/globals.ts";
quietLogs();
const PASSWORD = "a-long-claim-passphrase";
describe("forge it", () => {
  let dir = "";
  let parent: App;
  let parentServers: Servers;
  let cookie = "";
  let bobCookie = "";
  let link = "";
  const post = (path: string, extra: Record<string, string> = {}) =>
    fetch(`${parentServers.url}${path}`, {
      method: "POST",
      headers: { origin: "https://forge.test", ...extra },
      redirect: "manual",
    });
  beforeAll(async () => {
    dir = await mkdtemp(join(tmpdir(), "forge-it-"));
    parent = createApp({ dataDir: dir, url: "https://forge.test", port: 0 });
    const alice = await createUser(parent.db, {
      origin: "seed", trusted: true, username: "alice", email: "[email protected]", password: PASSWORD, isAdmin: true,
    });
    if (!alice.ok) throw new Error("user");
    const repo = await createRepo(parent, alice.value, { name: "Bakery_Shop" });
    if (!repo.ok) throw new Error("repo");
    const c = await commitFiles(repoDir(parent.reposRoot, "alice", "Bakery_Shop"), {
      branch: "main", message: "bakery",
      files: [{ path: "README.md", content: "# bakery\n" }],
      author: { name: "a", email: "[email protected]" },
    });
    if (!c.ok) throw new Error("commit");
    useProbe(parent, () => async () => true);
    parentServers = await serve(parent);
    const bob = await createUser(parent.db, {
      origin: "seed", trusted: true, username: "bob", email: "[email protected]", password: PASSWORD,
    });
    if (!bob.ok) throw new Error("bob");
    const open = await createRepo(parent, alice.value, { name: "open", visibility: "public" });
    if (!open.ok) throw new Error("open");
    const oc = await commitFiles(repoDir(parent.reposRoot, "alice", "open"), {
      branch: "main", message: "open",
      files: [{ path: "README.md", content: "# open\n" }],
      author: { name: "a", email: "[email protected]" },
    });
    if (!oc.ok) throw new Error("commit");
    const signIn = async (username: string) => {
      const res = await fetch(`${parentServers.url}/signin`, {
        method: "POST",
        headers: { origin: "https://forge.test" },
        body: new URLSearchParams({ username, password: PASSWORD }),
        redirect: "manual",
      });
      const c = (res.headers.get("set-cookie") ?? "").split(";")[0]!;
      if (!c.includes("=")) throw new Error(`signin ${res.status}`);
      return c;
    };
    cookie = await signIn("alice");
    bobCookie = await signIn("bob");
  }, 60_000);
  afterAll(async () => {
    parentServers.stop();
    parent.close();
    await rm(dir, { recursive: true, force: true });
  });
  test("the repository page offers Forge beside Fork, to a signed-in person only", async () => {
    const signedIn = await (await fetch(`${parentServers.url}/alice/Bakery_Shop`, { headers: { cookie } })).text();
    expect(signedIn).toContain('action="/alice/Bakery_Shop/forge"');
    const stranger = await (await fetch(`${parentServers.url}/alice/Bakery_Shop`)).text();
    expect(stranger).not.toContain("/forge\"");
  });
  test("a name comes from the repository and always fits", () => {
    expect(forgeNameOf("Bakery_Shop")).toBe("bakery-shop");
    expect(forgeNameOf("___")).toBe("forge");
    expect(forgeNameOf("a".repeat(60))).toHaveLength(38);
  });
  test("a stranger and a cross-origin press make nothing", async () => {
    // A private repository is not there to a stranger.
    expect((await post("/alice/Bakery_Shop/forge")).status).toBe(404);
    expect((await post("/alice/Bakery_Shop/forge", { cookie, origin: "https://evil.test" })).status).toBe(403);
    expect(await Bun.file(join(dir, "spawn", "bakery-shop.json")).exists()).toBe(false);
  });
  test("pressing it lands on the claim link, which signs in an admin holding the files", async () => {
    const res = await post("/alice/Bakery_Shop/forge", { cookie });
    expect(res.status).toBe(303);
    expect(res.headers.get("cache-control")).toBe("no-store");
    link = res.headers.get("location")!;
    expect(link).toMatch(/^https:\/\/bakery-shop--forge\.test\/claim#[A-Za-z0-9_-]{43}$/);
    const ledger = await Bun.file(join(dir, "spawn", "bakery-shop.json")).json();
    const child = createApp({ dataDir: childDirOf(parent, ledger.bodyId), port: 0 });
    await firstBoot(child);
    const childServers = await serve(child);
    try {
      const claimed = await fetch(`${childServers.url}/claim`, {
        method: "POST",
        headers: { origin: childServers.url },
        body: new URLSearchParams({ token: link.split("#")[1]!, username: "maria", email: "[email protected]", password: PASSWORD }),
        redirect: "manual",
      });
      expect(claimed.status).toBe(303);
      const session = (claimed.headers.get("set-cookie") ?? "").split(";")[0]!;
      expect(session).toContain("=");
      expect(getUserByName(child.db, "maria")?.isAdmin).toBe(true);
      const repo = getRepo(child.db, "bakery-shop", "Bakery_Shop");
      expect(repo).toBeDefined();
      const home = await fetch(`${childServers.url}/`, { headers: { cookie: session } });
      expect(home.status).toBe(200);
      expect(await home.text()).toContain("maria");
    } finally {
      childServers.stop();
      child.close();
    }
  }, 30_000);
  test("pressing it again makes no second forge and shows no second link", async () => {
    const again = await post("/alice/Bakery_Shop/forge", { cookie });
    expect(again.status).toBe(303);
    expect(again.headers.get("location")).toBe("/forges");
  });
  test("signed in but unable to read: a private repository is a 404 and makes no ledger entry", async () => {
    const res = await post("/alice/Bakery_Shop/forge", { cookie: bobCookie });
    expect(res.status).toBe(404);
    const page = await fetch(`${parentServers.url}/alice/Bakery_Shop`, { headers: { cookie: bobCookie } });
    expect(await page.text()).not.toContain("/forge\"");
    expect(await Bun.file(join(dir, "spawn", "bakery-shop.json")).exists()).toBe(true); // alice's, from above
    expect(await Bun.file(join(dir, "spawn", "bob.json")).exists()).toBe(false);
  });
  test("signed out on a public repository is sent to sign in and makes nothing", async () => {
    const res = await post("/alice/open/forge");
    expect(res.status).toBe(303);
    expect(res.headers.get("location") ?? "").toContain("/signin");
    expect(await Bun.file(join(dir, "spawn", "open.json")).exists()).toBe(false);
  });
  test("a reader who is not the owner may forge a public repository", async () => {
    const res = await post("/alice/open/forge", { cookie: bobCookie });
    expect(res.status).toBe(303);
    expect(res.headers.get("location")).toMatch(/^https:\/\/open--forge\.test\/claim#/);
  });
  test("a refusal comes back as an escaped flash on the repository page", async () => {
    // `open_` is named `open` as well, with other apps: the door refuses with 409.
    const other = await createRepo(parent, (await getUserByName(parent.db, "alice"))!, { name: "open_", visibility: "public" });
    if (!other.ok) throw new Error("open_");
    const res = await post("/alice/open_/forge", { cookie });
    expect(res.status).toBe(303);
    expect(res.headers.get("location")).toBe("/alice/open_");
    const flash = (res.headers.get("set-cookie") ?? "").split(";")[0]!;
    expect(flash).toStartWith("forge_flash=");
    const shown = await (await fetch(`${parentServers.url}/alice/open_`, { headers: { cookie: `${cookie}; ${flash}` } })).text();
    expect(shown).toContain("Not forged:");
    expect(shown).not.toMatch(/Not forged:[^<]*<script/i);
  });
});
@@ -0,0 +1,88 @@
/** The terminal's repository screen offers Forge it, as the page's button does (#7642). */
import { afterAll, beforeAll, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createRepo } from "../src/actions/repos.ts";
import { createApp, type App } from "../src/app.ts";
import type { Repo } from "../src/core/repos.ts";
import { createUser, type User } from "../src/core/users.ts";
import { commitFiles } from "../src/git/write.ts";
import { repoDir } from "../src/git/repos.ts";
import { useProbe } from "../src/spawn/door.ts";
import { createForgeApp } from "../src/tui/forge.ts";
import { repoScreen } from "../src/tui/screens/repo.ts";
import { local } from "../src/tui/screens/where.ts";
import { headlessTerminal } from "../src/tui/term/terminal.ts";
import { quietLogs } from "./helpers/globals.ts";
import { settleApp } from "./helpers/tui.ts";
quietLogs();
let dir: string;
let forge: App;
let alice: User;
let repo: Repo;
beforeAll(async () => {
  dir = await mkdtemp(join(tmpdir(), "forge-tui-forge-it-"));
  forge = createApp({ dataDir: dir, url: "https://forge.test", port: 0 });
  const a = await createUser(forge.db, { origin: "seed", trusted: true, username: "alice", email: "[email protected]", password: "a-long-passphrase", isAdmin: true });
  if (!a.ok) throw new Error("user");
  alice = a.value;
  const made = await createRepo(forge, alice, { name: "bakery", visibility: "public" });
  if (!made.ok) throw new Error("repo");
  repo = made.value;
  const c = await commitFiles(repoDir(forge.reposRoot, "alice", "bakery"), {
    branch: "main", message: "bakery", files: [{ path: "README.md", content: "# bakery\n" }], author: { name: "a", email: "[email protected]" },
  });
  if (!c.ok) throw new Error("commit");
  useProbe(forge, () => async () => true);
}, 60_000);
afterAll(async () => {
  forge.close?.();
  await rm(dir, { recursive: true, force: true });
});
const open = async (user: User | undefined) => {
  const { app, session } = createForgeApp(
    forge,
    { sshUsername: user?.username ?? "anon", remoteAddress: "127.0.0.1", user },
    { terminal: headlessTerminal(120, 40), exitHooks: false },
  );
  app.start();
  await settleApp(app);
  app.push(repoScreen(session, app.ctx, local(session, repo)));
  await settleApp(app);
  return app;
};
const key = async (app: Awaited<ReturnType<typeof open>>, k: string): Promise<string> => {
  app.dispatch({ type: "key", key: k, ctrl: false, alt: false, shift: false });
  await settleApp(app);
  return app.screen.toText();
};
const type = async (app: Awaited<ReturnType<typeof open>>, text: string): Promise<string> => {
  let out = "";
  for (const ch of text) out = await key(app, ch);
  return out;
};
test("a signed-in person is offered Forge it in the palette; a stranger is not", async () => {
  const app = await open(alice);
  await key(app, ":");
  expect(await type(app, "forge it")).toContain("alice/bakery — Forge it");
  const stranger = await open(undefined);
  await key(stranger, ":");
  expect(await type(stranger, "forge it")).not.toContain("alice/bakery — Forge it");
});
test("Forge it confirms, then makes the forge and shows its claim link once", async () => {
  const app = await open(alice);
  await key(app, ":");
  await type(app, "forge it");
  const confirm = await key(app, "enter");
  expect(confirm).toContain("bakery");
  expect(await Bun.file(join(dir, "spawn", "bakery.json")).exists()).toBe(false);
  expect(await key(app, "enter")).toMatch(/bakery--forge\.test\/claim#/);
  expect(await Bun.file(join(dir, "spawn", "bakery.json")).exists()).toBe(true);
});
		@@ -78,6 +78,8 @@ In the terminal, the Capacity screen (palette: Capacity, a forge admin who is a
78	78
79	79	An admin's home and the terminal's Flow dialog also say when the forge is clogged and how long the last clog took to notice and to clear: `docs/features/clog-watch.md`. A fork whose parent is archived shows one quiet line instead of its ahead/behind count, and its admin can detach it from the parent (Settings › Danger zone, the terminal's About `x`, MCP `detach`): `docs/features/detach.md`.
80	80
	81	Forge it: a Forge it button beside Fork on a repository page (and the terminal's palette entry `Forge it`) makes a fresh forge, named for the repository, with it as the app, and lands on that forge's claim link, where you pick a username and password and become its admin. A second press makes no second forge and shows no second link. Agents: `spawn` with `apps: ["owner/name"]`. `docs/features/forge-it.md`.
	82
81	83	A pull the merge queue holds as red alone (red on its own merge at its current head; cleared by a new head or a moved main) says so under its checks line: "red alone at <time>, waiting for a new head or a new main", on the pull page, its live checks line and the studio change step, and in the checks row of the pull's terminal screen (`redMark` in `src/checks/queue.ts`). Nothing is drawn when it is not held.
82	84
83	85	On a sealed issue, a writer gets the private repository to fix it in: `POST /api/v1/repos/:owner/:name/issues/:number/private`, the issue page's button, and `p` on the issue's terminal screen, which shows the repository and its clone URL (built from the forge's origin). All three refuse alike: not found for anyone who may not see sealed reports, `not_sealed`, and `unverified`.
		@@ -0,0 +1,14 @@
	1	# Forge it
	2
	3	A Forge it button (rocket icon, outline weight, so it is not mistaken for Fork) sits beside Fork on every repository page, for any signed-in person. One press makes a fresh forge named for the repository (`Bakery_Shop` becomes `bakery-shop`) with that repository as its app, and sends the browser straight to the new forge's claim link. The claim code rides the URL fragment, so there is nothing to copy; choosing a username and password there signs the person in as the new forge's admin.
	4
	5	- Terminal: the repository screen's palette (`:`) has `Forge it`; a confirm, then the claim link once (`src/tui/screens/forge_it.ts`). Both doors share `src/spawn/forge_it.ts`.
	6	- Route: `POST /:owner/:name/forge` (`src/web/pages/forge-it.ts`), same-origin and `admin`-scoped like `POST /forges/new`, which it calls through the spawn door with the defaults.
	7	- A private repository is forged only by those who can read it. Limits (children per forge, rate) are the spawn door's.
	8	- Pressing it twice makes one forge: the second press goes to `/forges`, and the link is not shown again (ask for a new one there).
	9	- Agents: the same thing is MCP `spawn` / `POST /api/v1/forges` with `apps: ["owner/name"]`.
	10	- Tests: `test/tui-forge-it.test.ts` for the terminal; `test/forge-it.test.ts` walks press, claim, signed-in admin, files.
	11
	12	Not here: a hosted child's crew runner (#4416), arriving signed in with no claim form (#2928), choosing a template (#7534, #7535).
	13
	14	Direction: this is a feature ahead of the pipeline-first order only in being a small door onto the spawn path that already exists; it adds no pipeline code. The owner asked for it on #7642.
		@@ -265,6 +265,7 @@ import { claimFragmentPage, claimOptions, claimSubmit } from "../web/pages/claim
265	265	import { firstAdminOptions, firstAdminPage, firstAdminSubmit } from "../web/pages/first-admin.ts";
266	266	import { familyPage } from "../web/pages/family.ts";
267	267	import { forgeLinkSubmit, forgesPage } from "../web/pages/forges.ts";
	268	import { forgeItSubmit } from "../web/pages/forge-it.ts";
268	269	import { newForgePage, newForgeSubmit } from "../web/pages/new-forge.ts";
269	270	import { askedPage } from "../web/studio/asked_page.ts";
270	271	import { reviewPage } from "../web/studio/review_page.ts";
		@@ -1379,6 +1380,8 @@ export function buildRouter(): Router<Handler> {
1379	1380	router.add("GET", "/:owner/:name/commits", commitsPage);
1380	1381	router.add("GET", "/:owner/:name/commit/:oid", commitPage);
1381	1382	router.add("POST", "/:owner/:name/fork", forkSubmit);
	1383	// Forge it: a fresh forge with this repository as its app, then its claim link.
	1384	router.add("POST", "/:owner/:name/forge", forgeItSubmit);
1382	1385	// Make it yours (#606): a fork with its app, planned, then made.
1383	1386	router.add("GET", "/:owner/:name/make-it-yours", makeItYoursPage);
1384	1387	router.add("POST", "/:owner/:name/make-it-yours", makeItYoursSubmit);
		@@ -0,0 +1,30 @@
	1	/**
	2	* Forge it: one repository becomes the app of a fresh forge. The page's
	3	* button and the terminal's palette entry both come here, so the name and
	4	* the spawn are the same in both. It is the spawn door with the choices made.
	5	*/
	6
	7	import type { Repo } from "../core/repos.ts";
	8	import type { User } from "../core/users.ts";
	9	import type { Ctx } from "../http/context.ts";
	10	import { spawnDoor, type Door } from "./door.ts";
	11	import { CHILD_NAME } from "./placement.ts";
	12
	13	/** A forge name from a repository name: lowercase, dashes, at most 38 characters. */
	14	export function forgeNameOf(repoName: string): string {
	15	const slug = repoName
	16	.toLowerCase()
	17	.replace(/[^a-z0-9]+/g, "-")
	18	.replace(/^-+\|-+$/g, "")
	19	.slice(0, 38)
	20	.replace(/-+$/, "");
	21	return CHILD_NAME.test(slug) ? slug : "forge";
	22	}
	23
	24	/** Make the forge (the door refuses what a person may not do). */
	25	export const forgeIt = (ctx: Ctx, user: User, repo: Repo): Promise<Door> =>
	26	spawnDoor(ctx, user, {
	27	name: forgeNameOf(repo.name),
	28	apps: [`${repo.ownerName}/${repo.name}`],
	29	dryRun: false,
	30	});
		@@ -0,0 +1,61 @@
	1	/**
	2	* Forge it, from a repository screen's `:` palette: the terminal's door to
	3	* the Forge button beside Fork. A confirm, then the spawn door as the page
	4	* calls it, and the claim link shown once.
	5	*/
	6
	7	import type { Repo } from "../../core/repos.ts";
	8	import { forgeIt, forgeNameOf } from "../../spawn/forge_it.ts";
	9	import type { Ctx, Screen } from "../app/app.ts";
	10	import type { Command } from "../app/palette.ts";
	11	import type { Session } from "../session.ts";
	12	import { confirmScreen, linkScreen, runAsync } from "./common.ts";
	13
	14	export function forgeItScreen(f: Session, ctx: Ctx, repo: Repo, parent: Screen): Screen {
	15	const from = `${repo.ownerName}/${repo.name}`;
	16	return confirmScreen(ctx, parent, {
	17	title: "Forge it",
	18	body: [
	19	`A fresh forge, ${forgeNameOf(repo.name)}, with ${from} as its app.`,
	20	"You get its claim link once; whoever opens it becomes the admin.",
	21	],
	22	actions: [{ label: "Forge it" }, { label: "Cancel" }],
	23	onChoose: (choice) => {
	24	if (choice !== 0 \|\| f.user === undefined) return;
	25	const user = f.user;
	26	runAsync(ctx, async () => {
	27	const url = new URL(f.app.config.url ?? `http://${f.app.config.host ?? "localhost"}`);
	28	const made = await forgeIt(
	29	{
	30	app: f.app,
	31	request: new Request(url.href, { method: "POST" }),
	32	url,
	33	params: {},
	34	auth: { user, scope: undefined, via: "none" as const },
	35	theme: undefined,
	36	},
	37	user,
	38	repo,
	39	);
	40	if (made.status >= 400) return ctx.toast(String(made.body["message"] ?? "it could not be made"), "danger");
	41	const link = made.body["claimUrl"];
	42	if (typeof link !== "string")
	43	return ctx.toast(`${String(made.body["name"])} was forged before; its link is not shown again`, "attn");
	44	ctx.toast(`${String(made.body["name"])} is ready`, "success");
	45	ctx.replace(linkScreen(ctx, link));
	46	});
	47	},
	48	});
	49	}
	50
	51	export function forgeItCommands(f: Session, ctx: Ctx, repo: Repo \| undefined, parent: () => Screen): Command[] {
	52	if (repo === undefined \|\| f.user === undefined \|\| f.user.kind !== "user") return [];
	53	return [
	54	{
	55	id: "forge-it",
	56	title: `${repo.ownerName}/${repo.name} — Forge it`,
	57	hint: "a fresh forge with it as the app",
	58	run: () => ctx.push(forgeItScreen(f, ctx, repo, parent())),
	59	},
	60	];
	61	}
		@@ -128,6 +128,7 @@ import { reportCommands } from "./report.ts";
128	128	import { reportsCommands } from "./reports.ts";
129	129	import { tellCommands } from "./tell.ts";
130	130	import { workingCommands } from "./working.ts";
	131	import { forgeItCommands } from "./forge_it.ts";
131	132	import { makeItYoursScreen, yoursCommands } from "./yours.ts";
132	133	import { visionCommands } from "./vision.ts";
133	134	import { appEnvCommands } from "./appenv.ts";
		@@ -1438,6 +1439,7 @@ export function workspaceScreen(
1438	1439	...reportsCommands(f, ctx, repo),
1439	1440	...noteCommands(f, ctx, () => screen, repo),
1440	1441	...yoursCommands(f, ctx, repo),
	1442	...forgeItCommands(f, ctx, repo, () => screen),
1441	1443	...hooksCommands(f, ctx, repo),
1442	1444	...visionCommands(f, ctx, repo),
1443	1445	...appEnvCommands(f, ctx, repo),
		@@ -0,0 +1,33 @@
	1	/**
	2	* Forge it: the verb beside Fork. One press on a repository spins up a fresh
	3	* forge with that repository as its app, and sends the person straight to the
	4	* new forge's claim link (the code rides the fragment, so nothing is copied).
	5	* It is `POST /forges/new` with the choices made for them: the name comes from
	6	* the repository, everything else is the spawn door's default.
	7	*/
	8
	9	import type { Ctx } from "../../http/context.ts";
	10	import { forgeIt } from "../../spawn/forge_it.ts";
	11	import { loadRepo, notFoundPage, signInFirst } from "../chrome.ts";
	12	import { readForm } from "../form.ts";
	13	import { flashTo, redirect } from "../layout.ts";
	14
	15	// POST /:owner/:name/forge
	16	export async function forgeItSubmit(ctx: Ctx): Promise<Response> {
	17	const repo = loadRepo(ctx);
	18	if (!repo) return notFoundPage(ctx);
	19	const user = ctx.auth.user;
	20	if (!user) return signInFirst(ctx);
	21	const form = await readForm(ctx, "admin");
	22	if (form instanceof Response) return form;
	23	const back = `/${repo.ownerName}/${repo.name}`;
	24	const door = await forgeIt(ctx, user, repo);
	25	if (door.status >= 400)
	26	return flashTo(ctx, back, { tone: "danger", message: `Not forged: ${String(door.body["message"] ?? "it could not be made")}.` });
	27	const link = door.body["claimUrl"];
	28	if (typeof link !== "string")
	29	return flashTo(ctx, "/forges", { message: `${String(door.body["name"])} was forged before; its link is not shown again.` });
	30	const response = redirect(link);
	31	response.headers.set("cache-control", "no-store");
	32	return response;
	33	}
		@@ -239,8 +239,10 @@ function forkRanking(
239	239	function forkBar(ctx: Ctx, repo: Repo): Html {
240	240	const canFork =
241	241	ctx.auth.user !== undefined && ctx.auth.user.id !== repo.ownerId;
	242	// Forge it is for any signed-in person, the owner too: it makes a forge, not a copy in this one.
	243	const canForge = ctx.auth.user?.kind === "user";
242	244	const forkCount = forksFor(ctx, repo).length;
243		if (!canFork && forkCount === 0) return html``;
	245	if (!canFork && !canForge && forkCount === 0) return html``;
244	246	return html`<div class="mt">
245	247	${listCard([
246	248	row({
		@@ -251,11 +253,15 @@ function forkBar(ctx: Ctx, repo: Repo): Html {
251	253	>${badge(`${forkCount} fork${forkCount === 1 ? "" : "s"}`)}</a
252	254	>`
253	255	: "Forks",
254		trail: canFork
	256	trail: html`${canFork
255	257	? html`<form method="post" action="${repoBase(repo)}/fork">
256	258	${btn("Fork", { size: "sm", icon: "fork" })}
257	259	</form>`
258		: html``,
	260	: html``}${canForge
	261	? html`<form method="post" action="${repoBase(repo)}/forge">
	262	${btn("Forge it", { size: "sm", icon: "rocket", variant: "outline" })}
	263	</form>`
	264	: html``}`,
259	265	}),
260	266	])}
261	267	</div>`;
		@@ -0,0 +1,186 @@
	1	/**
	2	* Forge it (#7642): one press beside Fork on a repository makes a fresh forge
	3	* with that repository as its app and lands the person on its claim link; the
	4	* claim signs them in as the new forge's admin, holding the repository's files.
	5	*/
	6	import { afterAll, beforeAll, describe, expect, test } from "bun:test";
	7	import { mkdtemp, rm } from "node:fs/promises";
	8	import { tmpdir } from "node:os";
	9	import { join } from "node:path";
	10	import { createRepo } from "../src/actions/repos.ts";
	11	import { childDirOf } from "../src/actions/spawn.ts";
	12	import { createApp, type App } from "../src/app.ts";
	13	import { getRepo } from "../src/core/repos.ts";
	14	import { createUser, getUserByName } from "../src/core/users.ts";
	15	import { repoDir } from "../src/git/repos.ts";
	16	import { commitFiles } from "../src/git/write.ts";
	17	import { serve, type Servers } from "../src/http/server.ts";
	18	import { forgeNameOf } from "../src/spawn/forge_it.ts";
	19	import { useProbe } from "../src/spawn/door.ts";
	20	import { firstBoot } from "../src/spawn/first-boot.ts";
	21	import { quietLogs } from "./helpers/globals.ts";
	22
	23	quietLogs();
	24
	25	const PASSWORD = "a-long-claim-passphrase";
	26
	27	describe("forge it", () => {
	28	let dir = "";
	29	let parent: App;
	30	let parentServers: Servers;
	31	let cookie = "";
	32	let bobCookie = "";
	33	let link = "";
	34
	35	const post = (path: string, extra: Record<string, string> = {}) =>
	36	fetch(`${parentServers.url}${path}`, {
	37	method: "POST",
	38	headers: { origin: "https://forge.test", ...extra },
	39	redirect: "manual",
	40	});
	41
	42	beforeAll(async () => {
	43	dir = await mkdtemp(join(tmpdir(), "forge-it-"));
	44	parent = createApp({ dataDir: dir, url: "https://forge.test", port: 0 });
	45	const alice = await createUser(parent.db, {
	46	origin: "seed", trusted: true, username: "alice", email: "[email protected]", password: PASSWORD, isAdmin: true,
	47	});
	48	if (!alice.ok) throw new Error("user");
	49	const repo = await createRepo(parent, alice.value, { name: "Bakery_Shop" });
	50	if (!repo.ok) throw new Error("repo");
	51	const c = await commitFiles(repoDir(parent.reposRoot, "alice", "Bakery_Shop"), {
	52	branch: "main", message: "bakery",
	53	files: [{ path: "README.md", content: "# bakery\n" }],
	54	author: { name: "a", email: "[email protected]" },
	55	});
	56	if (!c.ok) throw new Error("commit");
	57	useProbe(parent, () => async () => true);
	58	parentServers = await serve(parent);
	59	const bob = await createUser(parent.db, {
	60	origin: "seed", trusted: true, username: "bob", email: "[email protected]", password: PASSWORD,
	61	});
	62	if (!bob.ok) throw new Error("bob");
	63	const open = await createRepo(parent, alice.value, { name: "open", visibility: "public" });
	64	if (!open.ok) throw new Error("open");
	65	const oc = await commitFiles(repoDir(parent.reposRoot, "alice", "open"), {
	66	branch: "main", message: "open",
	67	files: [{ path: "README.md", content: "# open\n" }],
	68	author: { name: "a", email: "[email protected]" },
	69	});
	70	if (!oc.ok) throw new Error("commit");
	71	const signIn = async (username: string) => {
	72	const res = await fetch(`${parentServers.url}/signin`, {
	73	method: "POST",
	74	headers: { origin: "https://forge.test" },
	75	body: new URLSearchParams({ username, password: PASSWORD }),
	76	redirect: "manual",
	77	});
	78	const c = (res.headers.get("set-cookie") ?? "").split(";")[0]!;
	79	if (!c.includes("=")) throw new Error(`signin ${res.status}`);
	80	return c;
	81	};
	82	cookie = await signIn("alice");
	83	bobCookie = await signIn("bob");
	84	}, 60_000);
	85
	86	afterAll(async () => {
	87	parentServers.stop();
	88	parent.close();
	89	await rm(dir, { recursive: true, force: true });
	90	});
	91
	92	test("the repository page offers Forge beside Fork, to a signed-in person only", async () => {
	93	const signedIn = await (await fetch(`${parentServers.url}/alice/Bakery_Shop`, { headers: { cookie } })).text();
	94	expect(signedIn).toContain('action="/alice/Bakery_Shop/forge"');
	95	const stranger = await (await fetch(`${parentServers.url}/alice/Bakery_Shop`)).text();
	96	expect(stranger).not.toContain("/forge\"");
	97	});
	98
	99	test("a name comes from the repository and always fits", () => {
	100	expect(forgeNameOf("Bakery_Shop")).toBe("bakery-shop");
	101	expect(forgeNameOf("___")).toBe("forge");
	102	expect(forgeNameOf("a".repeat(60))).toHaveLength(38);
	103	});
	104
	105	test("a stranger and a cross-origin press make nothing", async () => {
	106	// A private repository is not there to a stranger.
	107	expect((await post("/alice/Bakery_Shop/forge")).status).toBe(404);
	108	expect((await post("/alice/Bakery_Shop/forge", { cookie, origin: "https://evil.test" })).status).toBe(403);
	109	expect(await Bun.file(join(dir, "spawn", "bakery-shop.json")).exists()).toBe(false);
	110	});
	111
	112	test("pressing it lands on the claim link, which signs in an admin holding the files", async () => {
	113	const res = await post("/alice/Bakery_Shop/forge", { cookie });
	114	expect(res.status).toBe(303);
	115	expect(res.headers.get("cache-control")).toBe("no-store");
	116	link = res.headers.get("location")!;
	117	expect(link).toMatch(/^https:\/\/bakery-shop--forge\.test\/claim#[A-Za-z0-9_-]{43}$/);
	118
	119	const ledger = await Bun.file(join(dir, "spawn", "bakery-shop.json")).json();
	120	const child = createApp({ dataDir: childDirOf(parent, ledger.bodyId), port: 0 });
	121	await firstBoot(child);
	122	const childServers = await serve(child);
	123	try {
	124	const claimed = await fetch(`${childServers.url}/claim`, {
	125	method: "POST",
	126	headers: { origin: childServers.url },
	127	body: new URLSearchParams({ token: link.split("#")[1]!, username: "maria", email: "[email protected]", password: PASSWORD }),
	128	redirect: "manual",
	129	});
	130	expect(claimed.status).toBe(303);
	131	const session = (claimed.headers.get("set-cookie") ?? "").split(";")[0]!;
	132	expect(session).toContain("=");
	133	expect(getUserByName(child.db, "maria")?.isAdmin).toBe(true);
	134	const repo = getRepo(child.db, "bakery-shop", "Bakery_Shop");
	135	expect(repo).toBeDefined();
	136	const home = await fetch(`${childServers.url}/`, { headers: { cookie: session } });
	137	expect(home.status).toBe(200);
	138	expect(await home.text()).toContain("maria");
	139	} finally {
	140	childServers.stop();
	141	child.close();
	142	}
	143	}, 30_000);
	144
	145	test("pressing it again makes no second forge and shows no second link", async () => {
	146	const again = await post("/alice/Bakery_Shop/forge", { cookie });
	147	expect(again.status).toBe(303);
	148	expect(again.headers.get("location")).toBe("/forges");
	149	});
	150
	151	test("signed in but unable to read: a private repository is a 404 and makes no ledger entry", async () => {
	152	const res = await post("/alice/Bakery_Shop/forge", { cookie: bobCookie });
	153	expect(res.status).toBe(404);
	154	const page = await fetch(`${parentServers.url}/alice/Bakery_Shop`, { headers: { cookie: bobCookie } });
	155	expect(await page.text()).not.toContain("/forge\"");
	156	expect(await Bun.file(join(dir, "spawn", "bakery-shop.json")).exists()).toBe(true); // alice's, from above
	157	expect(await Bun.file(join(dir, "spawn", "bob.json")).exists()).toBe(false);
	158	});
	159
	160	test("signed out on a public repository is sent to sign in and makes nothing", async () => {
	161	const res = await post("/alice/open/forge");
	162	expect(res.status).toBe(303);
	163	expect(res.headers.get("location") ?? "").toContain("/signin");
	164	expect(await Bun.file(join(dir, "spawn", "open.json")).exists()).toBe(false);
	165	});
	166
	167	test("a reader who is not the owner may forge a public repository", async () => {
	168	const res = await post("/alice/open/forge", { cookie: bobCookie });
	169	expect(res.status).toBe(303);
	170	expect(res.headers.get("location")).toMatch(/^https:\/\/open--forge\.test\/claim#/);
	171	});
	172
	173	test("a refusal comes back as an escaped flash on the repository page", async () => {
	174	// `open_` is named `open` as well, with other apps: the door refuses with 409.
	175	const other = await createRepo(parent, (await getUserByName(parent.db, "alice"))!, { name: "open_", visibility: "public" });
	176	if (!other.ok) throw new Error("open_");
	177	const res = await post("/alice/open_/forge", { cookie });
	178	expect(res.status).toBe(303);
	179	expect(res.headers.get("location")).toBe("/alice/open_");
	180	const flash = (res.headers.get("set-cookie") ?? "").split(";")[0]!;
	181	expect(flash).toStartWith("forge_flash=");
	182	const shown = await (await fetch(`${parentServers.url}/alice/open_`, { headers: { cookie: `${cookie}; ${flash}` } })).text();
	183	expect(shown).toContain("Not forged:");
	184	expect(shown).not.toMatch(/Not forged:[^<]*<script/i);
	185	});
	186	});
		@@ -0,0 +1,88 @@
	1	/** The terminal's repository screen offers Forge it, as the page's button does (#7642). */
	2	import { afterAll, beforeAll, expect, test } from "bun:test";
	3	import { mkdtemp, rm } from "node:fs/promises";
	4	import { tmpdir } from "node:os";
	5	import { join } from "node:path";
	6	import { createRepo } from "../src/actions/repos.ts";
	7	import { createApp, type App } from "../src/app.ts";
	8	import type { Repo } from "../src/core/repos.ts";
	9	import { createUser, type User } from "../src/core/users.ts";
	10	import { commitFiles } from "../src/git/write.ts";
	11	import { repoDir } from "../src/git/repos.ts";
	12	import { useProbe } from "../src/spawn/door.ts";
	13	import { createForgeApp } from "../src/tui/forge.ts";
	14	import { repoScreen } from "../src/tui/screens/repo.ts";
	15	import { local } from "../src/tui/screens/where.ts";
	16	import { headlessTerminal } from "../src/tui/term/terminal.ts";
	17	import { quietLogs } from "./helpers/globals.ts";
	18	import { settleApp } from "./helpers/tui.ts";
	19
	20	quietLogs();
	21
	22	let dir: string;
	23	let forge: App;
	24	let alice: User;
	25	let repo: Repo;
	26
	27	beforeAll(async () => {
	28	dir = await mkdtemp(join(tmpdir(), "forge-tui-forge-it-"));
	29	forge = createApp({ dataDir: dir, url: "https://forge.test", port: 0 });
	30	const a = await createUser(forge.db, { origin: "seed", trusted: true, username: "alice", email: "[email protected]", password: "a-long-passphrase", isAdmin: true });
	31	if (!a.ok) throw new Error("user");
	32	alice = a.value;
	33	const made = await createRepo(forge, alice, { name: "bakery", visibility: "public" });
	34	if (!made.ok) throw new Error("repo");
	35	repo = made.value;
	36	const c = await commitFiles(repoDir(forge.reposRoot, "alice", "bakery"), {
	37	branch: "main", message: "bakery", files: [{ path: "README.md", content: "# bakery\n" }], author: { name: "a", email: "[email protected]" },
	38	});
	39	if (!c.ok) throw new Error("commit");
	40	useProbe(forge, () => async () => true);
	41	}, 60_000);
	42	afterAll(async () => {
	43	forge.close?.();
	44	await rm(dir, { recursive: true, force: true });
	45	});
	46
	47	const open = async (user: User \| undefined) => {
	48	const { app, session } = createForgeApp(
	49	forge,
	50	{ sshUsername: user?.username ?? "anon", remoteAddress: "127.0.0.1", user },
	51	{ terminal: headlessTerminal(120, 40), exitHooks: false },
	52	);
	53	app.start();
	54	await settleApp(app);
	55	app.push(repoScreen(session, app.ctx, local(session, repo)));
	56	await settleApp(app);
	57	return app;
	58	};
	59	const key = async (app: Awaited<ReturnType<typeof open>>, k: string): Promise<string> => {
	60	app.dispatch({ type: "key", key: k, ctrl: false, alt: false, shift: false });
	61	await settleApp(app);
	62	return app.screen.toText();
	63	};
	64	const type = async (app: Awaited<ReturnType<typeof open>>, text: string): Promise<string> => {
	65	let out = "";
	66	for (const ch of text) out = await key(app, ch);
	67	return out;
	68	};
	69
	70	test("a signed-in person is offered Forge it in the palette; a stranger is not", async () => {
	71	const app = await open(alice);
	72	await key(app, ":");
	73	expect(await type(app, "forge it")).toContain("alice/bakery — Forge it");
	74	const stranger = await open(undefined);
	75	await key(stranger, ":");
	76	expect(await type(stranger, "forge it")).not.toContain("alice/bakery — Forge it");
	77	});
	78
	79	test("Forge it confirms, then makes the forge and shows its claim link once", async () => {
	80	const app = await open(alice);
	81	await key(app, ":");
	82	await type(app, "forge it");
	83	const confirm = await key(app, "enter");
	84	expect(confirm).toContain("bakery");
	85	expect(await Bun.file(join(dir, "spawn", "bakery.json")).exists()).toBe(false);
	86	expect(await key(app, "enter")).toMatch(/bakery--forge\.test\/claim#/);
	87	expect(await Bun.file(join(dir, "spawn", "bakery.json")).exists()).toBe(true);
	88	});