53e7f29
@@ -496,12 +496,7 @@
JavaScript at all it is a `<textarea>` in a `<form>`, which is what it was
before any of this. The Preview tab is offered on Markdown only, and renders
through the same `/preview` fragment the server will use for the file.
**Terminal keys and glyphs for origins.** Account → `o` opens Origins; there
`c` connects, `s` syncs now, `r` browses the origin's repositories and `D`
disconnects. In the picker `enter` **browses** the row — live, read-only,
nothing downloaded — and `m` mirrors it into the workbench; a second `m` on a
running mirror joins the job rather than starting a second one. On a repo's
home `y` syncs the mirror and `P` pins it — `p` has meant _pulls_ on that
**Origins are web-only.** Connecting, syncing and browsing an origin live on the web pages (`/origins`) and in migrate; the terminal has no origins screen. On a mirrored repo's home `y` syncs the mirror and `P` pins it — `p` has meant _pulls_ on that
screen since before pins existed, so the toggle takes the shifted key there
and the plain `p` everywhere a repo is a _row_ (the dashboard, explore).
@@ -599,8 +594,8 @@
Four rules hold the gestures together:
Clickable today: every list row, the dashboard's four panes, the workspace's
explorer rows and tab chips (including the active tab's `✗`), the file pane
(focus, and the wheel), the where-strip's three places, the palette's results,
the appearance picker's rows, the owner, refs, settings, account and origins
lists, the origin picker's rows, the pull's diff-and-threads pane, and **every
the appearance picker's rows, the owner, refs, settings, account
lists, the pull's diff-and-threads pane, and **every
hint in the help bar** — clicking a hint presses the key it names, taken from
the binding itself so a label can never drift from the action. A list with no
`hitList` is a bug, not a design decision: "everything you can see is
@@ -38,7 +38,6 @@
import { exploreScreen } from "./screens/explore.ts";
import { issuesScreen, newIssueScreen } from "./screens/issues.ts";
import { newPullScreen } from "./screens/newpull.ts";
import { newRepoScreen } from "./screens/newrepo.ts";
import { originsScreen } from "./screens/origins.ts";
import { ownerScreen } from "./screens/owner.ts";
import { repoScreen } from "./screens/repo.ts";
import { settingsScreen } from "./screens/settings.ts";
@@ -177,12 +176,6 @@
export function forgeCommands(session: Session): (ctx: Ctx) => Command[] {
          title: "Account settings",
          run: () => ctx.push(accountScreen(session, ctx)),
        },
        {
          id: "origins",
          title: "Origins",
          hint: "connected forges",
          run: () => ctx.push(originsScreen(session, ctx)),
        },
      );
    if (session.user?.isAdmin === true)
      commands.push({
@@ -39,7 +39,6 @@
import {
  runAsync,
} from "./common.ts";
import { crewScreen } from "./crew.ts";
import { originsScreen } from "./origins.ts";
const TABS = ["Profile", "Tokens", "SSH keys"] as const;
@@ -68,7 +67,6 @@
export function accountScreen(f: Session, ctx: Ctx): Screen {
          binding(["d"], "display name"),
          binding(["e"], "email"),
          binding(["p"], "password"),
          binding(["o"], "origins"),
          ...crew,
        ];
      if (tab === 1)
@@ -76,14 +74,12 @@
export function accountScreen(f: Session, ctx: Ctx): Screen {
          binding(["tab"], "next tab"),
          binding(["n"], "new token"),
          binding(["D"], "revoke"),
          binding(["o"], "origins"),
          ...crew,
        ];
      return [
        binding(["tab"], "next tab"),
        binding(["n"], "add key"),
        binding(["D"], "delete key"),
        binding(["o"], "origins"),
        ...crew,
      ];
    },
@@ -148,12 +144,6 @@
export function accountScreen(f: Session, ctx: Ctx): Screen {
        state.index = 0;
        return true;
      }
      // Origins are an account-level thing, like tokens and keys, so they
      // hang off this screen from every tab rather than becoming a fourth.
      if (e.key === "o") {
        ctx.push(originsScreen(f, ctx));
        return true;
      }
      if (e.key === "c" && f.user?.isAdmin === true) {
        ctx.push(crewScreen(f, ctx));
        return true;
@@ -1,1030 +0,0 @@
/**
 * Origins in the terminal: the connected accounts, the three ways to connect
 * one, and the picker that turns a remote repository into a local mirror.
 *
 * The device grant is why this screen exists in the shape it does. It is the
 * only connect flow that works with no browser on this machine — the forge
 * shows a short code, a phone types it in somewhere else, and the forge does
 * the polling. Everything here is a client of `actions/origins.ts`: no token
 * ever reaches a cell buffer, and what a session may see is decided by the
 * same `getOriginFor` every other surface goes through.
 */
import {
  connectOrigin,
  disconnectOrigin,
  listRemoteRepos,
  listUserOrigins,
  pollOAuthConnect,
  registerOriginApp,
  startOAuthConnect,
  syncOriginNow,
} from "../../actions/origins.ts";
import type { OriginRepoRow } from "../../core/origins.ts";
import { pinnedRepoIds } from "../../core/pins.ts";
import { getRepoById, getReposByIds, type Repo } from "../../core/repos.ts";
import { sourceFor } from "../../view/source.ts";
import type { Origin } from "../../origins/types.ts";
import { forgeBaseUrl, oauthCallbackUri } from "../../http/api.ts";
import type { Ctx, Screen } from "../app/app.ts";
import { binding, type Binding } from "../app/keys.ts";
import { BOLD, UNDERLINE, style, type Style } from "../term/style.ts";
import { G, type Rect, type Screen as TermScreen } from "../term/screen.ts";
import { truncate } from "../term/width.ts";
import { fill, len, split } from "../ui/layout.ts";
import { card, emptyState, spinner } from "../ui/widgets.ts";
import { drawQr, qrSize, terminalQr } from "../ui/qr.ts";
import type { Session } from "../session.ts";
import {
  Filter,
  ListState,
  PIN_MARK,
  ago,
  confirmScreen,
  drawList,
  errorText,
  later,
  openLink,
  promptScreen,
  runAsync,
  type ListRow,
  hitList,
} from "./common.ts";
import { startMirror } from "./mirror.ts";
import { forkAtOrigin } from "./contribute.ts";
import { repoScreen } from "./repo.ts";
import { local } from "./where.ts";
/**
 * Push a screen *after* the prompt that asked for it has closed itself.
 *
 * `promptScreen` pops on submit, so pushing straight from `onSubmit` would
 * hand the pop the screen we just pushed. Returning a promise defers the
 * push by a microtask, which is exactly the ordering wanted: prompt closes,
 * next screen opens.
 */
/** `codeberg.org` from `https://codeberg.org` — what a person calls a forge. */
export function hostLabel(url: string): string {
  return URL.parse(url)?.host ?? url;
}
/** Healthy, spent, or merely erroring — three words, never a colour alone. */
export function originState(origin: Origin): {
  text: string;
  tone: "success" | "danger" | "attn";
} {
  if (origin.needsReauth) return { text: "needs re-auth", tone: "danger" };
  if (origin.lastError !== "") return { text: "error", tone: "attn" };
  return { text: "healthy", tone: "success" };
}
/**
 * Where an OAuth application must send the browser back to.
 *
 * The same rule the web surface uses, asked from this side: `FORGE_URL`, or a
 * host the operator vouched for, or loopback. A terminal session has no
 * request to read a Host header from — which is the point, since that header
 * was never trustworthy for this — so it asks about the forge's own address.
 */
function callbackUri(f: Session): string {
  const url = selfUrl(f);
  return url === null ? "" : oauthCallbackUri(url, f.app.config.host);
}
/** The forge's own base URL, by the same rule — "" when it knows of none. */
function baseUri(f: Session): string {
  const url = selfUrl(f);
  return url === null ? "" : forgeBaseUrl(url, f.app.config.host);
}
function selfUrl(f: Session): URL | null {
  const host = f.app.config.host ?? "localhost";
  return URL.parse(`http://${host}:${f.app.config.port ?? 3000}/`);
}
/** `<forge>/go/<code>` — what a phone types, or a camera reads. */
function shortLink(f: Session, code: string): string {
  const base = baseUri(f);
  return base === "" || code === "" ? "" : `${base}/go/${code}`;
}
// ---- the list ----
export function originsScreen(f: Session, ctx: Ctx): Screen {
  let origins: Origin[] = [];
  const state = new ListState();
  const reload = (): void => {
    origins = f.user ? listUserOrigins(f.app, f.user) : [];
    state.clamp(origins.length);
    ctx.invalidate();
  };
  const current = (): Origin | undefined => origins[state.index];
  const screen: Screen = {
    title: "Origins",
    keys: [
      binding(["j", "k"], "move"),
      binding(["c"], "connect — a token needs no setup"),
      binding(["s"], "sync now"),
      binding(["r"], "browse its repositories"),
      binding(["D"], "disconnect"),
    ],
    load() {
      reload();
      return Promise.resolve();
    },
    render(area, s) {
      const c = ctx.theme.c;
      if (origins.length === 0) {
        emptyState(s, area, c, {
          title: "No origins connected",
          body: "Paste a personal access token — or set up one-click GitHub or Forgejo.",
          action: "c  connect an origin",
        });
        return;
      }
      drawList(
        s,
        area,
        c,
        state,
        origins.map((origin): ListRow => {
          const health = originState(origin);
          const kind = origin.authKind === "oauth" ? "oauth" : "token";
          return {
            title: `${origin.login} @ ${hostLabel(origin.webUrl)}`,
            secondary: `${kind} · ${health.text}${origin.lastError === "" ? "" : `: ${origin.lastError}`}`,
            meta:
              origin.lastSyncAt === null
                ? "never synced"
                : `synced ${ago(origin.lastSyncAt)}`,
          };
        }),
      );
      // Opening an origin is browsing its repositories — the same thing `r`
      // does, so the pointer cannot reach somewhere the keyboard could not.
      hitList(ctx, area, state, origins.length, {
        open: (index) => {
          const origin = origins[index];
          if (origin !== undefined) ctx.push(originReposScreen(f, ctx, origin));
        },
      });
    },
    key(e) {
      if (state.key(e, origins.length)) return true;
      if (e.key === "c") {
        ctx.push(connectScreen(f, ctx, screen, reload));
        return true;
      }
      if (e.key === "s") {
        const origin = current();
        if (!origin) return true;
        runAsync(ctx, async () => {
          const report = await syncOriginNow(f.app, f.user, origin.id);
          if (!report.ok) ctx.toast(errorText(report.error), "danger");
          else if (report.value.error !== "")
            ctx.toast(report.value.error, "danger");
          else
            ctx.toast(`synced ${report.value.repos} repositories`, "success");
          reload();
        });
        return true;
      }
      if (e.key === "r") {
        const origin = current();
        if (origin) ctx.push(originReposScreen(f, ctx, origin));
        return true;
      }
      if (e.key === "D") {
        const origin = current();
        if (!origin) return true;
        ctx.push(
          confirmScreen(ctx, screen, {
            title: "Disconnect origin",
            body: [
              `${origin.login} @ ${hostLabel(origin.webUrl)}`,
              "",
              "Mirrors keep everything they have and stop syncing.",
              "The grant is revoked upstream only where the forge allows it.",
            ],
            actions: [
              { label: "Cancel", variant: "ghost" },
              { label: "Disconnect", variant: "danger" },
            ],
            onChoose: (choice) => {
              if (choice !== 1) return;
              runAsync(ctx, async () => {
                const gone = await disconnectOrigin(f.app, f.user, origin.id);
                if (!gone.ok) ctx.toast(errorText(gone.error), "danger");
                else
                  ctx.toast(
                    gone.value.revokedUpstream
                      ? "disconnected, grant revoked upstream"
                      : "disconnected — revoke the token on the origin too",
                    "success",
                  );
                reload();
              });
            },
          }),
        );
        return true;
      }
      return false;
    },
  };
  return screen;
}
// ---- connecting ----
/**
 * The chooser. Which flow works is a property of the forge, not a
 * preference, so the rows say what each one *is* rather than offering them
 * as equals — and they are in the order that gets a person connected.
 *
 * The token is first because it is the only route with no setup at all: you
 * paste a string and you are connected, on any forge, from any terminal. The
 * two one-click flows are genuinely nicer *once they exist*, and each needs
 * somebody to register an application first — so each says so on its own
 * line rather than failing later with an error about an environment
 * variable.
 */
function connectScreen(
  f: Session,
  ctx: Ctx,
  parent: Screen,
  done: () => void,
): Screen {
  const ways = [
    {
      id: "token",
      label: "Personal access token — recommended",
      note: "No setup at all. Works with any forge, any terminal.",
      note2: "Paste one from the forge and you are connected.",
    },
    {
      id: "github",
      label: "GitHub, one click",
      note: "Needs a one-time OAuth app setup.",
      note2: "Then a short code you type on your phone.",
    },
    {
      id: "forgejo",
      label: "Forgejo / Gitea, one click",
      note: "Needs an app registration on the instance.",
      note2: "Then a browser to authorize it.",
    },
  ] as const;
  let at = 0;
  return {
    title: "Connect an origin",
    keys: [
      binding(["j", "k"], "move"),
      binding(["enter"], "choose"),
      binding(["esc"], "cancel"),
    ],
    render(area, s) {
      parent.render(area, s);
      const c = ctx.theme.c;
      const w = Math.min(62, Math.max(24, area.w - 4));
      const h = Math.min(area.h, ways.length * 4 + 1);
      const inner = card(
        s,
        {
          x: area.x + ((area.w - w) >> 1),
          y: area.y + ((area.h - h) >> 1),
          w,
          h,
        },
        c,
        { title: "Connect an origin", focused: true },
      );
      const right = inner.x + inner.w;
      ways.forEach((way, i) => {
        const y = inner.y + i * 4;
        if (y + 2 >= inner.y + inner.h) return;
        const chosen = i === at;
        s.text(
          inner.x,
          y,
          chosen ? G.caretRight : " ",
          style(c.accent, c.card),
          right,
        );
        s.text(
          inner.x + 2,
          y,
          truncate(way.label, Math.max(0, inner.w - 2)),
          style(chosen ? c.fg : c.mutedFg, c.card, chosen ? BOLD : 0),
          right,
        );
        for (const [n, line] of [way.note, way.note2].entries())
          s.text(
            inner.x + 2,
            y + 1 + n,
            truncate(line, Math.max(0, inner.w - 2)),
            style(c.faint, c.card),
            right,
          );
      });
    },
    key(e) {
      if (e.key === "j" || e.key === "down") at = (at + 1) % ways.length;
      else if (e.key === "k" || e.key === "up")
        at = (at - 1 + ways.length) % ways.length;
      else if (e.key === "enter") {
        const choice = ways[at]?.id;
        ctx.pop();
        if (choice === "github") askGithubHost(f, ctx, parent, done);
        else if (choice === "forgejo") startCodeFlow(f, ctx, parent, done);
        else if (choice === "token") startToken(f, ctx, parent, done);
      } else if (e.key === "esc" || e.key === "q") ctx.pop();
      return true;
    },
  };
}
function startToken(
  f: Session,
  ctx: Ctx,
  parent: Screen,
  done: () => void,
): void {
  ctx.push(
    promptScreen(ctx, parent, {
      title: "Connect with a token",
      label: "instance",
      placeholder: "github.com",
      onSubmit: (host) => {
        if (host === "") return "an instance is required";
        return later(ctx, () =>
          promptScreen(ctx, parent, {
            title: `Token for ${host}`,
            label: "personal access token",
            // Masked: a terminal is the one surface where somebody is
            // routinely looking over your shoulder.
            mask: true,
            hint: "Needs repository and issue access. Never displayed again.",
            onSubmit: (token) => {
              if (token === "") return "a token is required";
              return (async () => {
                const connected = await connectOrigin(f.app, f.user, {
                  host,
                  token,
                });
                if (!connected.ok) {
                  ctx.toast(errorText(connected.error), "danger");
                  return;
                }
                ctx.toast(
                  `connected ${connected.value.login} @ ${hostLabel(connected.value.webUrl)}`,
                  "success",
                );
                done();
              })();
            },
          }),
        );
      },
    }),
  );
}
/**
 * Which GitHub. Empty means github.com, which is what almost everyone wants
 * and one keypress away; a host is how GitHub Enterprise gets named, since
 * it publishes nothing discovery could recognise.
 */
function askGithubHost(
  f: Session,
  ctx: Ctx,
  parent: Screen,
  done: () => void,
): void {
  ctx.push(
    promptScreen(ctx, parent, {
      title: "Connect GitHub",
      label: "host",
      placeholder: "github.com — or a GitHub Enterprise host",
      // No `later` here: the device start awaits the network before it
      // pushes anything, so the prompt has already closed by then.
      onSubmit: (host) => {
        startDevice(f, ctx, parent, host === "" ? "github" : host, done);
        return undefined;
      },
    }),
  );
}
function startDevice(
  f: Session,
  ctx: Ctx,
  parent: Screen,
  host: string,
  done: () => void,
): void {
  runAsync(ctx, async () => {
    const started = await startOAuthConnect(f.app, f.user, {
      host,
      kind: "github",
      redirectUri: callbackUri(f),
    });
    if (!started.ok) {
      // "Not configured" is a task, not a status: the one error a person can
      // actually fix from here gets the instructions instead of a toast that
      // names an environment variable and leaves them to it.
      if (started.error.error === "no_app")
        ctx.push(githubSetup(f, ctx, parent));
      else ctx.toast(started.error.message, "danger");
      return;
    }
    ctx.push(deviceScreen(f, ctx, parent, started.value, done));
  });
}
// ---- handing a connect to a device that has a browser ----
/**
 * Everything a person needs to finish a connect somewhere else, and every way
 * of getting it to them.
 *
 * This screen exists because of one situation: the forge is on a server, you
 * are in a terminal over SSH, and the URL on the screen is a string you can
 * neither click nor reliably copy. So all three routes off this screen are
 * offered at once — a QR code the phone in your hand reads directly, a short
 * link that is ten characters of path and can be typed by hand, and OSC 52,
 * which asks *your* terminal (not the server) to put the link on *your*
 * clipboard. Opening a browser is the one thing that genuinely cannot be done
 * from the far side of an SSH connection, and `o` says so rather than
 * appearing to work.
 */
interface Handoff {
  /** The device grant's user code. Empty for the code flow, which has none. */
  readonly userCode: string;
  /** The full URL the person has to reach. */
  readonly url: string;
  /** `<forge>/go/<code>`, or "" when the forge does not know its address. */
  readonly link: string;
  /** The lead line: what to do with all this. */
  readonly lead: string;
  /** What the spinner says. A failed poll rewrites it. */
  detail: string;
}
function handoffKeys(h: Handoff): Binding[] {
  return [
    binding(["c"], "copy link"),
    ...(h.userCode === "" ? [] : [binding(["C"], "copy code")]),
    binding(["o"], "open"),
    binding(["esc"], "cancel"),
  ];
}
const COPY_NOTE =
  "copied — if your terminal allows it (iTerm2, Ghostty, kitty, WezTerm do; Apple Terminal does not)";
function handoffKey(ctx: Ctx, h: Handoff, key: string): boolean {
  if (key === "c") {
    ctx.copy(h.link === "" ? h.url : h.link);
    ctx.toast(COPY_NOTE, "success");
    return true;
  }
  if (key === "C" && h.userCode !== "") {
    ctx.copy(h.userCode);
    ctx.toast(COPY_NOTE, "success");
    return true;
  }
  if (key === "o") {
    // Over SSH there is no browser here to reach, so the URL goes to the
    // reader's *own* clipboard and the toast names the gesture that opens
    // the link on screen. Three routes, no dead end.
    openLink(ctx, h.url);
    return true;
  }
  return false;
}
/**
 * Draw the card. The QR is the first thing dropped when the terminal is
 * short: a code that does not fit is not a smaller code, and the short link
 * below it says the same thing in characters.
 */
function drawHandoff(
  ctx: Ctx,
  surface: TermScreen,
  area: Rect,
  parent: Screen,
  h: Handoff,
  title: string,
): void {
  const c = ctx.theme.c;
  parent.render(area, surface);
  const w = Math.min(64, Math.max(24, area.w - 6));
  const urlLines = wrap(h.url, w).slice(0, 2);
  const linkRows = h.link === "" ? 0 : 1;
  const codeRows = h.userCode === "" ? 0 : 2;
  const fixed = 1 + codeRows + 1 + linkRows + urlLines.length + 1 + 1;
  const qr = terminalQr(h.link === "" ? h.url : h.link);
  const dim = qr === undefined ? undefined : qrSize(qr);
  const withQr =
    qr !== undefined &&
    dim !== undefined &&
    dim.cols <= w &&
    fixed + dim.rows + 1 + 2 <= area.h;
  const rows = fixed + (withQr && dim ? dim.rows + 1 : 0);
  const height = Math.min(area.h, rows + 2);
  const inner = card(
    surface,
    {
      x: area.x + ((area.w - w) >> 1),
      y: area.y + ((area.h - height) >> 1),
      w,
      h: height,
    },
    c,
    { title, focused: true },
  );
  const right = inner.x + inner.w;
  let y = inner.y;
  const line = (text: string, st: Style, centred = false): void => {
    const x = centred
      ? inner.x + Math.max(0, (inner.w - text.length) >> 1)
      : inner.x;
    surface.text(x, y++, truncate(text, inner.w), st, right);
  };
  line(h.lead, style(c.mutedFg, c.card));
  if (h.userCode !== "") {
    y++;
    // The code is the whole point of the screen, so it gets the one
    // deliberately loud line in the terminal UI: spaced out, centred.
    line([...h.userCode].join(" "), style(c.fg, c.card, BOLD), true);
  }
  y++;
  if (withQr && qr) {
    y = drawQr(surface, { x: inner.x, y, w: inner.w, h: inner.h }, qr);
    y++;
  }
  // Both URLs are real hyperlinks (OSC 8), so a terminal that supports them
  // turns the one thing this screen exists to hand over into something the
  // reader can click instead of retype. The QR and the plain text stay for
  // everybody else — three routes to one URL, because none of them is
  // reliable on its own.
  if (h.link !== "") {
    surface.linkText(
      inner.x,
      y++,
      truncate(h.link, inner.w),
      style(c.accent, c.card, UNDERLINE),
      h.link,
      right,
    );
  }
  for (const part of urlLines) {
    surface.linkText(
      inner.x,
      y++,
      truncate(part, inner.w),
      style(c.faint, c.card),
      h.url,
      right,
    );
  }
  y++;
  const x = spinner(surface, inner.x, y, c, ctx.tick);
  surface.text(
    x + 1,
    y,
    truncate(h.detail, Math.max(0, right - x - 1)),
    style(c.mutedFg, c.card),
    right,
  );
}
/**
 * How to make the GitHub button work, in the three steps that do it. Shown
 * where the failure happens, because a person who just pressed "GitHub" is
 * exactly the person who wants to know.
 */
function githubSetup(f: Session, ctx: Ctx, parent: Screen): Screen {
  const back = callbackUri(f);
  return confirmScreen(ctx, parent, {
    title: "Set up GitHub",
    body: [
      "No GitHub OAuth application is configured yet.",
      "",
      "1. Create an OAuth App at",
      "   github.com/settings/developers. Homepage: this",
      "   forge. Authorization callback URL:",
      `   ${back === "" ? "<your forge>/settings/origins/callback" : back}`,
      "   Tick 'Enable Device Flow'.",
      "2. Start the forge with",
      "   FORGE_GITHUB_CLIENT_ID=<client id>  (and, only",
      "   for revoke-on-disconnect, the client secret).",
      "3. Come back here — GitHub connects.",
      "",
      "Until then, a pasted token needs no setup at all.",
    ],
    actions: [{ label: "OK", variant: "default" }],
    onChoose: () => undefined,
  });
}
/**
 * The device-code screen: the code, the ways to reach the verification page,
 * and a spinner while the forge polls on the user's behalf. Esc cancels — the
 * flow row expires on its own, so abandoning it costs nothing.
 */
function deviceScreen(
  f: Session,
  ctx: Ctx,
  parent: Screen,
  flow: {
    flowId: string;
    userCode: string;
    url: string;
    shortCode: string;
    intervalSecs: number;
  },
  done: () => void,
): Screen {
  let finished = false;
  const handoff: Handoff = {
    userCode: flow.userCode,
    url: flow.url,
    link: shortLink(f, flow.shortCode),
    lead: `Type this code at ${hostLabel(flow.url)}:`,
    detail: "waiting for you to authorize…",
  };
  return {
    title: "Connect GitHub",
    keys: handoffKeys(handoff),
    load(signal) {
      const every = Math.max(1, flow.intervalSecs) * 1000;
      const timer = setInterval(() => {
        if (finished) return;
        void (async () => {
          const polled = await pollOAuthConnect(f.app, f.user, flow.flowId);
          if (!polled.ok || finished) return;
          if (polled.value.status === "pending") return;
          finished = true;
          clearInterval(timer);
          if (polled.value.status === "done") {
            ctx.toast("origin connected", "success");
            done();
            ctx.pop();
            return;
          }
          handoff.detail = polled.value.detail || "that connect failed";
          ctx.toast(handoff.detail, "danger");
          ctx.invalidate();
        })();
      }, every);
      signal.addEventListener("abort", () => clearInterval(timer));
      return Promise.resolve();
    },
    render(area, s) {
      drawHandoff(ctx, s, area, parent, handoff, "Connect GitHub");
    },
    key(e) {
      if (handoffKey(ctx, handoff, e.key)) return true;
      if (e.key === "esc" || e.key === "q") {
        finished = true;
        ctx.pop();
      }
      return true;
    },
  };
}
/**
 * Forgejo and Gitea: register an application on the instance, then authorize
 * in a browser. There is no device grant to fall back on — their token
 * endpoints accept only `authorization_code` and `refresh_token` — so the
 * terminal prints the URL and waits for the origin list to grow.
 */
function startCodeFlow(
  f: Session,
  ctx: Ctx,
  parent: Screen,
  done: () => void,
): void {
  const redirect = callbackUri(f);
  ctx.push(
    promptScreen(ctx, parent, {
      title: "Connect Forgejo or Gitea",
      label: "instance",
      placeholder: "codeberg.org",
      onSubmit: (host) => {
        if (host === "") return "an instance is required";
        if (redirect === "")
          return "this forge does not know its own public URL — set FORGE_URL";
        return later(ctx, () =>
          promptScreen(ctx, parent, {
            title: `Register an app on ${host}`,
            label: "client id",
            hint: `1. register an app at ${host}/user/settings/applications with redirect ${redirect}  2. paste client id`,
            onSubmit: (clientId) => {
              if (clientId === "") return "a client id is required";
              return (async () => {
                const saved = await registerOriginApp(f.app, f.user, {
                  host,
                  clientId,
                });
                if (!saved.ok) {
                  ctx.toast(errorText(saved.error), "danger");
                  return;
                }
                const started = await startOAuthConnect(f.app, f.user, {
                  host,
                  redirectUri: redirect,
                });
                if (!started.ok) {
                  ctx.toast(started.error.message, "danger");
                  return;
                }
                ctx.push(
                  authorizeScreen(
                    f,
                    ctx,
                    parent,
                    {
                      url: started.value.url,
                      shortCode: started.value.shortCode,
                    },
                    done,
                  ),
                );
              })();
            },
          }),
        );
      },
    }),
  );
}
/**
 * Print the authorize URL and wait. The callback lands on the *web* surface,
 * so this screen has nothing to poll but the origin list itself — which is
 * exactly the question being asked: did an origin appear?
 *
 * A Forgejo authorize URL is long — client id, state, challenge, scopes —
 * which is precisely the URL nobody retypes off a terminal. The short link
 * and the QR carry it instead.
 */
function authorizeScreen(
  f: Session,
  ctx: Ctx,
  parent: Screen,
  flow: { url: string; shortCode: string },
  done: () => void,
): Screen {
  const before = f.user ? listUserOrigins(f.app, f.user).length : 0;
  let finished = false;
  const handoff: Handoff = {
    userCode: "",
    url: flow.url,
    link: shortLink(f, flow.shortCode),
    lead: `Open this and approve the application on ${hostLabel(flow.url)}:`,
    detail: "waiting for you to authorize…",
  };
  return {
    title: "Authorize",
    keys: handoffKeys(handoff),
    load(signal) {
      const timer = setInterval(() => {
        if (finished || !f.user) return;
        if (listUserOrigins(f.app, f.user).length <= before) return;
        finished = true;
        clearInterval(timer);
        ctx.toast("origin connected", "success");
        done();
        ctx.pop();
      }, 1000);
      signal.addEventListener("abort", () => clearInterval(timer));
      return Promise.resolve();
    },
    render(area, s) {
      drawHandoff(ctx, s, area, parent, handoff, "Authorize on the instance");
    },
    key(e) {
      if (handoffKey(ctx, handoff, e.key)) return true;
      if (e.key === "esc" || e.key === "q") {
        finished = true;
        ctx.pop();
      }
      return true;
    },
  };
}
/** Hard-wrap a URL: it has no spaces, so nothing else will break it. */
function wrap(text: string, width: number): string[] {
  const out: string[] = [];
  const chars = [...text];
  const size = Math.max(1, width);
  for (let at = 0; at < chars.length; at += size)
    out.push(chars.slice(at, at + size).join(""));
  return out;
}
// ---- the picker ----
/**
 * One origin's repositories.
 *
 * `enter` *opens* the repository — live, read-only, through the origin's own
 * API — and nothing is downloaded. This is the whole point of the picker:
 * pressing enter used to mean "clone this, import every issue, and take
 * several seconds doing it with nothing on screen", which taught people to
 * press it twice. Taking a copy is now a separate, deliberate key with a
 * progress card behind it, and a row that has already been taken says so.
 */
export function originReposScreen(
  f: Session,
  ctx: Ctx,
  origin: Origin,
): Screen {
  let repos: OriginRepoRow[] = [];
  let failed = false;
  const state = new ListState();
  const filter = new Filter();
  const load = async (refresh = false): Promise<void> => {
    const listed = await listRemoteRepos(f.app, f.user, origin.id, refresh);
    failed = !listed.ok;
    repos = listed.ok ? listed.value : [];
    state.clamp(repos.length);
    ctx.invalidate();
  };
  const shown = (): OriginRepoRow[] =>
    repos.filter((r) => filter.matches(`${r.fullName} ${r.description}`));
  /**
   * The local repositories these rows were mirrored into, and which of them
   * are pinned — both resolved for the whole page in one query each, because
   * `getRepoById` and `isPinned` inside `rows.map` was two queries per row on
   * a list that routinely runs to a few hundred.
   */
  const mirrors = (): {
    repoOf: (row: OriginRepoRow) => Repo | undefined;
    pinned: ReadonlySet<string>;
  } => {
    const held = getReposByIds(
      f.db,
      repos.flatMap((r) => (r.mirroredAs === null ? [] : [r.mirroredAs])),
    );
    return {
      repoOf: (row) =>
        row.mirroredAs === null ? undefined : held.get(row.mirroredAs),
      pinned: f.user ? pinnedRepoIds(f.db, f.user.id) : new Set<string>(),
    };
  };
  /** The local repository a row was mirrored into, if it still exists. */
  const mirrorOf = (remote: OriginRepoRow): Repo | undefined =>
    remote.mirroredAs === null
      ? undefined
      : getRepoById(f.db, remote.mirroredAs);
  const browse = (remote: OriginRepoRow): void => {
    const src = sourceFor(f.app, f.user, {
      originId: origin.id,
      fullName: remote.fullName,
    });
    if (!src.ok) {
      ctx.toast(errorText(src.error), "danger");
      return;
    }
    // Pushed with nothing loaded: the screen paints its own frame with a
    // spinner and fills in as the origin answers.
    ctx.push(repoScreen(f, ctx, src.value));
  };
  const screen: Screen = {
    title: `${origin.login} @ ${hostLabel(origin.webUrl)}`,
    keys: [
      binding(["j", "k"], "move"),
      binding(["enter"], "browse — nothing is downloaded"),
      binding(["m"], "mirror into your workbench"),
      binding(["F"], `fork to ${origin.login}@${hostLabel(origin.webUrl)}`),
      binding(["/"], "filter"),
      binding(["r"], "refresh from origin"),
    ],
    load: () => load(),
    render(area, s) {
      const c = ctx.theme.c;
      const [box, body] = split(area, "v", [len(1), fill(1)]);
      ctx.setCursor(filter.render(s, box!, c, "filter repositories"));
      const rows = shown();
      if (rows.length === 0) {
        emptyState(s, body!, c, {
          title: failed ? "The origin could not be reached" : "No repositories",
          body: failed
            ? "Nothing was changed. Press r to try again."
            : "Nothing on this origin matches.",
        });
        return;
      }
      const page = mirrors();
      drawList(
        s,
        body!,
        c,
        state,
        rows.map((remote): ListRow => {
          const held = page.repoOf(remote);
          const pinned = held !== undefined && page.pinned.has(held.id);
          const marks = [
            remote.private ? "private" : "public",
            remote.forkOf === null
              ? remote.fork
                ? "fork"
                : ""
              : `fork of ${remote.forkOf}`,
            held === undefined
              ? ""
              : `${G.dot} mirrored as ${held.ownerName}/${held.name}`,
            pinned ? `${PIN_MARK} on your machine` : "",
          ].filter((m) => m !== "");
          return {
            title: remote.fullName,
            secondary: marks.join(" · "),
            meta:
              remote.pushedAt === null
                ? "never pushed"
                : `pushed ${ago(remote.pushedAt)}`,
          };
        }),
      );
      hitList(ctx, body!, state, rows.length, {
        open: (index) => {
          const remote = rows[index];
          if (remote !== undefined) browse(remote);
        },
      });
    },
    key(e) {
      if (filter.key(e)) {
        state.clamp(shown().length);
        return true;
      }
      const rows = shown();
      if (state.key(e, rows.length)) return true;
      if (e.key === "enter") {
        const remote = rows[state.index];
        if (remote) browse(remote);
        return true;
      }
      if (e.key === "m") {
        const remote = rows[state.index];
        if (remote === undefined) return true;
        if (remote.mirroredAs !== null) {
          ctx.toast("already mirrored — enter opens it", "attn");
          return true;
        }
        startMirror(f, ctx, {
          parent: screen,
          originId: origin.id,
          fullName: remote.fullName,
          onLanded: () => {
            runAsync(ctx, () => load());
          },
        });
        return true;
      }
      if (e.key === "F") {
        const remote = rows[state.index];
        if (remote === undefined) return true;
        forkAtOrigin(f, ctx, {
          parent: screen,
          target: {
            originId: origin.id,
            fullName: remote.fullName,
            host: hostLabel(origin.webUrl),
          },
          onForked: (fork) => {
            runAsync(ctx, () => load(true));
            ctx.push(repoScreen(f, ctx, local(f, fork)));
          },
        });
        return true;
      }
      if (e.key === "r") {
        runAsync(ctx, () => load(true));
        return true;
      }
      return false;
    },
  };
  return screen;
}
@@ -435,7 +435,7 @@
describe("the terminal, around the workspace", () => {
      await h.settle();
      await openRepo(h, "lighthouse");
      // A native repo has no origin page, and the screen says so rather than
      // pretending. (The mirrored case is covered in tui-origins.)
      // pretending. (The mirrored case is covered on the web.)
      await h.press("O");
      expect(h.text()).toContain("no origin page");
    } finally {
@@ -1,863 +0,0 @@
/**
 * Origins in the terminal, driven headlessly against a real forge, a fake
 * Forgejo API, and a second real forge standing in for the git host — so the
 * mirror is a genuine clone and the write-through genuinely leaves the
 * machine.
 *
 * Every assertion is made against the cell grid the renderer produced. That
 * is the point of a headless terminal: "the code is on the screen" is a claim
 * about what a person would see, not about a variable.
 */
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 { createApp, type App as Forge } from "../src/app.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { resetConnectLimit } from "../src/actions/origins.ts";
import { signUp } from "../src/actions/users.ts";
import { listOrigins } from "../src/core/origins.ts";
import { listPins } from "../src/core/pins.ts";
import { getRepo } from "../src/core/repos.ts";
import type { User } from "../src/core/users.ts";
import { quietLogs } from "./helpers/globals.ts";
import { forgetProviders } from "../src/origins/providers/index.ts";
import type { App } from "../src/tui/app/app.ts";
import { createForgeApp } from "../src/tui/forge.ts";
import type { TuiIdentity } from "../src/tui/session.ts";
import { settleApp } from "./helpers/tui.ts";
import {
  headlessTerminal,
  type HeadlessTerminal,
} from "../src/tui/term/terminal.ts";
import {
  newFakeOAuth,
  newFakeState,
  serveFakeForge,
  type FakeForge,
  type FakeOAuth,
} from "./fake-origin.ts";
quietLogs();
const ORIGIN_LOGIN = "octo";
const ORIGIN_TOKEN = "octo-origin-secret-9f2a";
const CLIENT_ID = "Iv1.forge-tui-client";
/** What an operator sets so the forge knows its own address. */
const FORGE_URL = "https://forge.example.test";
const basic = (user: string, secret: string): string =>
  `Basic ${Buffer.from(`${user}:${secret}`).toString("base64")}`;
interface Harness {
  app: App;
  terminal: HeadlessTerminal;
  text(): string;
  press(...keys: string[]): Promise<void>;
  /** Keys with no settle between them — for "what does a double press do?". */
  burst(...keys: string[]): void;
  typeText(text: string): Promise<void>;
  settle(): Promise<void>;
  /** Pump frames until the screen says something, or give up loudly. */
  until(what: string, ms?: number): Promise<void>;
  stop(): void;
}
/** The crumb trail the loop paints: one entry per screen on the stack. */
const crumbLine = (h: Harness): string => h.text().split("\n")[1] ?? "";
const occurrences = (haystack: string, needle: string): number =>
  haystack.split(needle).length - 1;
function boot(
  forge: Forge,
  identity: TuiIdentity,
  cols = 140,
  rows = 40,
): Harness {
  const terminal = headlessTerminal(cols, rows);
  const { app } = createForgeApp(forge, identity, {
    terminal,
    exitHooks: false,
  });
  app.start();
  const settle = (): Promise<void> => settleApp(app);
  const one = async (key: string): Promise<void> => {
    app.dispatch({
      type: "key",
      key: key.startsWith("ctrl+") ? key.slice(5) : key,
      ctrl: key.startsWith("ctrl+"),
      alt: false,
      shift: false,
    });
    await settle();
  };
  return {
    app,
    terminal,
    text: () => app.screen.toText(),
    async press(...keys) {
      for (const key of keys) await one(key);
    },
    burst(...keys) {
      for (const key of keys)
        app.dispatch({
          type: "key",
          key,
          ctrl: false,
          alt: false,
          shift: false,
        });
      app.frame();
    },
    async typeText(text) {
      for (const ch of text)
        app.dispatch({
          type: "key",
          key: ch,
          ctrl: false,
          alt: false,
          shift: false,
        });
      await settle();
    },
    settle,
    async until(what, ms = 20_000) {
      const deadline = Date.now() + ms;
      for (;;) {
        await settle();
        if (app.screen.toText().includes(what)) return;
        if (Date.now() > deadline)
          throw new Error(
            `never saw ${JSON.stringify(what)} on screen:\n${app.screen.toText()}`,
          );
        await new Promise((r) => setTimeout(r, 20));
      }
    },
    stop: () => app.stop(),
  };
}
describe("origins in the terminal", () => {
  let dataDir: string;
  let originDataDir: string;
  let forge: Forge;
  let originApp: Forge;
  let originServers: Servers;
  let fake: FakeForge;
  let github: FakeForge;
  let ghOauth: FakeOAuth;
  let alice: User;
  const asAlice = (): TuiIdentity => ({
    sshUsername: "alice",
    remoteAddress: "127.0.0.1",
    fingerprint: "SHA256:test",
    user: alice,
  });
  /** Dashboard → account → origins → connect → GitHub → the device screen. */
  const openDeviceScreen = async (h: Harness): Promise<void> => {
    await h.press("A");
    await h.until("Account");
    await h.press("o");
    await h.until("Origins");
    await h.press("c");
    await h.until("Connect an origin");
    // The token is the first row now, so GitHub is one down.
    await h.press("j", "enter");
    await h.until("Connect GitHub");
    await h.typeText(github.url);
    await h.press("enter");
    await h.until("W X Y Z - 1 2 3 4");
  };
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-tuiorigins-"));
    originDataDir = await mkdtemp(join(tmpdir(), "forge-tuiupstream-"));
    originApp = createApp({ dataDir: originDataDir, port: 0 });
    originServers = await serve(originApp);
    await fetch(`${originServers.url}/api/v1/users`, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        username: ORIGIN_LOGIN,
        email: "[email protected]",
        password: ORIGIN_TOKEN,
      }),
    });
    await fetch(`${originServers.url}/api/v1/repos`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        authorization: basic(ORIGIN_LOGIN, ORIGIN_TOKEN),
      },
      body: JSON.stringify({ name: "widgets", visibility: "public" }),
    });
    await fetch(`${originServers.url}/api/v1/repos/octo/widgets/contents`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        authorization: basic(ORIGIN_LOGIN, ORIGIN_TOKEN),
      },
      body: JSON.stringify({
        branch: "main",
        message: "first",
        files: [{ path: "README.md", content: "# widgets\nhello\n" }],
      }),
    });
    await fetch(`${originServers.url}/api/v1/repos`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        authorization: basic(ORIGIN_LOGIN, ORIGIN_TOKEN),
      },
      body: JSON.stringify({ name: "gadgets", visibility: "public" }),
    });
    await fetch(`${originServers.url}/api/v1/repos/octo/gadgets/contents`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        authorization: basic(ORIGIN_LOGIN, ORIGIN_TOKEN),
      },
      body: JSON.stringify({
        branch: "main",
        message: "first",
        files: [{ path: "README.md", content: "# gadgets\nhello\n" }],
      }),
    });
    const state = newFakeState("forgejo", ORIGIN_LOGIN, ORIGIN_TOKEN);
    state.repos.push(
      {
        id: 41,
        fullName: "octo/widgets",
        description: "gears and things",
        cloneUrl: `${originServers.url}/octo/widgets.git`,
        htmlUrl: `${originServers.url}/octo/widgets`,
        defaultBranch: "main",
      },
      // A second remote, so there is still something un-mirrored to press
      // `m` on after the first one has been taken.
      {
        id: 42,
        fullName: "octo/gadgets",
        description: "bits and bobs",
        cloneUrl: `${originServers.url}/octo/gadgets.git`,
        htmlUrl: `${originServers.url}/octo/gadgets`,
        defaultBranch: "main",
      },
    );
    state.files.set(
      "octo/gadgets",
      new Map([["README.md", "# gadgets\n\nbits and bobs, read live\n"]]),
    );
    state.branches.set("octo/gadgets", [
      { name: "main", sha: "2".repeat(40), protected: false },
    ]);
    // The git side of the same repository, as the API would describe it —
    // this is what a *live* browse reads, with nothing cloned anywhere.
    state.files.set(
      "octo/widgets",
      new Map([
        ["README.md", "# widgets\n\ngears and things, read live\n"],
        ["src/index.ts", "export const one = 1;\n"],
      ]),
    );
    state.branches.set("octo/widgets", [
      { name: "main", sha: "1".repeat(40), protected: false },
    ]);
    state.commits.set("octo/widgets", [
      {
        sha: "1".repeat(40),
        message: "first",
        authorName: "Mona Lisa",
        login: "mona",
        date: "2026-01-01T00:00:00.000Z",
      },
    ]);
    state.labels.set("octo/widgets", [{ id: 1, name: "bug", color: "d73a4a" }]);
    state.issues.set("octo/widgets", [
      {
        id: 900,
        number: 7,
        title: "The gear slips",
        body: "under load",
        user: "mona",
        labels: ["bug"],
        createdAt: "2026-01-01T00:00:00.000Z",
        updatedAt: "2026-01-02T00:00:00.000Z",
      },
    ]);
    fake = serveFakeForge(state);
    const ghState = newFakeState("github", ORIGIN_LOGIN, "unused-pat");
    ghOauth = newFakeOAuth(CLIENT_ID);
    ghState.oauth = ghOauth;
    github = serveFakeForge(ghState);
    forge = createApp({ dataDir, port: 0 });
    const created = await signUp(forge, {
      username: "alice",
      email: "[email protected]",
      password: "a-long-passphrase",
    });
    if (!created.ok) throw new Error("signup failed");
    alice = created.value;
    resetConnectLimit();
    forgetProviders(dataDir);
    delete process.env.FORGE_GITHUB_CLIENT_ID;
  });
  afterAll(async () => {
    delete process.env.FORGE_GITHUB_CLIENT_ID;
    fake.stop();
    github.stop();
    originServers.stop();
    forge.close();
    originApp.close();
    forgetProviders(dataDir);
    await rm(dataDir, { recursive: true, force: true });
    await rm(originDataDir, { recursive: true, force: true });
  }, 60_000);
  test("the origins screen is empty, then a pasted token fills it", async () => {
    const h = boot(forge, asAlice());
    try {
      // Dashboard → account → origins.
      await h.press("A");
      await h.until("Account");
      await h.press("o");
      await h.until("No origins connected");
      expect(h.text()).toContain("connect an origin");
      // c → the chooser. A token needs no setup anywhere, so it is the first
      // row and the one `enter` lands on; the two one-click flows come after
      // it, each saying what it needs first.
      await h.press("c");
      await h.until("Connect an origin");
      const chooser = h.text();
      expect(chooser).toContain("Personal access token — recommended");
      expect(chooser).toContain("GitHub, one click");
      expect(chooser).toContain("Forgejo / Gitea, one click");
      expect(chooser).toContain("Needs a one-time OAuth app setup");
      expect(chooser).toContain("Needs an app registration on the instance");
      expect(chooser).toContain("No setup at all");
      expect(chooser.indexOf("Personal access token")).toBeLessThan(
        chooser.indexOf("GitHub, one click"),
      );
      await h.press("enter");
      await h.until("Connect with a token");
      await h.typeText(fake.url);
      await h.press("enter");
      await h.until("personal access token");
      await h.typeText(ORIGIN_TOKEN);
      // A secret typed into a terminal is never left as plain cells.
      expect(h.text()).not.toContain(ORIGIN_TOKEN);
      expect(h.text()).toContain("•");
      await h.press("enter");
      await h.until(`${ORIGIN_LOGIN} @`);
      expect(h.text()).toContain("healthy");
      expect(h.text()).toContain("token");
      expect(listOrigins(forge.db, alice.id)).toHaveLength(1);
    } finally {
      h.stop();
    }
  }, 60_000);
  test("the device-code screen shows the code and where to type it", async () => {
    process.env.FORGE_GITHUB_CLIENT_ID = CLIENT_ID;
    resetConnectLimit();
    const h = boot(forge, asAlice());
    try {
      await h.press("A");
      await h.until("Account");
      await h.press("o");
      await h.until(`${ORIGIN_LOGIN} @`);
      await h.press("c");
      await h.until("Connect an origin");
      await h.press("j", "enter");
      await h.until("Connect GitHub");
      await h.typeText(github.url);
      await h.press("enter");
      await h.until("WXYZ-1234".split("").join(" "));
      expect(h.text()).toContain(ghOauth.verificationUri);
      expect(h.text()).toContain("waiting for you to authorize");
      // The device code is the forge's half and never reaches the screen.
      expect(h.text()).not.toContain(ghOauth.deviceCode);
      await h.press("esc");
    } finally {
      delete process.env.FORGE_GITHUB_CLIENT_ID;
      h.stop();
    }
  }, 60_000);
  /**
   * The reason this screen has the shape it does: over SSH the URL on screen
   * is a string you cannot click and often cannot copy. So the test asserts
   * the three ways off it — a QR made of real cells, a short link short
   * enough to type, and an OSC 52 sequence that reaches the *user's*
   * terminal rather than the server's.
   */
  test("the device screen hands the connect to a phone, and c reaches the user's clipboard", async () => {
    process.env.FORGE_GITHUB_CLIENT_ID = CLIENT_ID;
    process.env.FORGE_URL = FORGE_URL;
    resetConnectLimit();
    const h = boot(forge, asAlice(), 120, 40);
    try {
      await openDeviceScreen(h);
      const text = h.text();
      const found = /https:\/\/forge\.example\.test\/go\/[0-9a-z]{10}/.exec(
        text,
      );
      expect(found).not.toBeNull();
      const short = found![0];
      // The code in it belongs to a live flow row, and to nothing else.
      const row = forge.db
        .query<
          { short_code: string },
          []
        >("SELECT short_code FROM oauth_flow WHERE status = 'pending' ORDER BY id DESC LIMIT 1")
        .get();
      expect(short.endsWith(row!.short_code)).toBe(true);
      // A QR, drawn as half blocks. The signature is the top of a finder
      // pattern: seven dark modules over a dark-light-dark row render as one
      // full block, five upper halves and one full block.
      expect(text).toContain("\u2588\u2580\u2580\u2580\u2580\u2580\u2588");
      // And the full URL is still there for anyone who wants to read it.
      expect(text).toContain(ghOauth.verificationUri);
      // `c` copies the short link through the terminal itself.
      h.terminal.takeOutput();
      await h.press("c");
      const copied = h.terminal.takeOutput();
      expect(copied).toContain(
        `\u001b]52;c;${Buffer.from(short, "utf8").toString("base64")}\u0007`,
      );
      expect(h.text()).toContain("copied");
      expect(h.text()).toContain("Apple Terminal does not");
      // `C` copies the device code instead.
      h.terminal.takeOutput();
      await h.press("C");
      expect(h.terminal.takeOutput()).toContain(
        `\u001b]52;c;${Buffer.from("WXYZ-1234", "utf8").toString("base64")}\u0007`,
      );
      // `o` cannot reach a browser from the far side of a connection. It no
      // longer says so and stops there: the URL goes to the reader's own
      // clipboard through their terminal, and the toast names the gesture
      // that opens the OSC 8 link already on screen.
      h.terminal.takeOutput();
      await h.press("o");
      expect(h.terminal.takeOutput()).toContain(
        `]52;c;${Buffer.from("https://example.invalid/device", "utf8").toString("base64")}`,
      );
      // …and the link dialog shows the address plain, mouse released, so it
      // can be selected by hand where OSC 52 is not honoured.
      expect(h.text()).toContain("Link");
      expect(h.text()).toContain("https://example.invalid/device");
      await h.press("esc");
      expect(h.text()).not.toContain("Select the address");
      await h.press("esc");
    } finally {
      delete process.env.FORGE_GITHUB_CLIENT_ID;
      delete process.env.FORGE_URL;
      h.stop();
    }
  }, 60_000);
  test("at 80x24 the QR is dropped and the short link is kept", async () => {
    process.env.FORGE_GITHUB_CLIENT_ID = CLIENT_ID;
    process.env.FORGE_URL = FORGE_URL;
    resetConnectLimit();
    const h = boot(forge, asAlice(), 80, 24);
    try {
      await openDeviceScreen(h);
      const text = h.text();
      // Half a QR is not a smaller QR, so at this height there is none.
      expect(text).not.toContain("\u2588\u2580\u2580\u2580\u2580\u2580\u2588");
      expect(text).toMatch(/https:\/\/forge\.example\.test\/go\/[0-9a-z]{10}/);
      expect(text).toContain("W X Y Z - 1 2 3 4");
      // All three ways off the screen are named in the help bar.
      expect(text).toContain("copy link");
      expect(text).toContain("copy code");
      expect(text).toContain("open");
      await h.press("esc");
    } finally {
      delete process.env.FORGE_GITHUB_CLIENT_ID;
      delete process.env.FORGE_URL;
      h.stop();
    }
  }, 60_000);
  test("an unconfigured GitHub explains how to configure it, where it failed", async () => {
    delete process.env.FORGE_GITHUB_CLIENT_ID;
    resetConnectLimit();
    const h = boot(forge, asAlice(), 80, 24);
    try {
      await h.press("A");
      await h.until("Account");
      await h.press("o");
      await h.until("Origins");
      await h.press("c");
      await h.until("Connect an origin");
      await h.press("j", "enter");
      await h.until("Connect GitHub");
      await h.typeText(github.url);
      await h.press("enter");
      await h.until("Set up GitHub");
      const text = h.text();
      expect(text).toContain("github.com/settings/developers");
      expect(text).toContain("Enable Device Flow");
      expect(text).toContain("FORGE_GITHUB_CLIENT_ID");
      expect(text).toContain("/settings/origins/callback");
      expect(text).toContain("a pasted token needs no setup");
      await h.press("esc");
    } finally {
      h.stop();
    }
  }, 60_000);
  /**
   * Origins → the picker, filtered down to one row, which is where every
   * browse and every mirror starts. The filter is what makes `enter` mean a
   * named repository rather than "whatever sorted first".
   */
  const openPicker = async (h: Harness, name = "widgets"): Promise<void> => {
    await h.press("A");
    await h.until("Account");
    await h.press("o");
    await h.until(`${ORIGIN_LOGIN} @`);
    await h.press("r");
    await h.until(`octo/${name}`);
    await h.press("/");
    await h.typeText(name);
    await h.press("enter");
  };
  /** The `?` overlay: every binding this screen has, untruncated. */
  const helpText = async (h: Harness): Promise<string> => {
    await h.press("?");
    const text = h.text();
    await h.press("esc");
    return text;
  };
  test("enter opens the repository live and downloads nothing", async () => {
    const host = new URL(fake.url).host;
    const h = boot(forge, asAlice());
    try {
      await openPicker(h);
      expect(h.text()).toContain("public");
      // The row is not mirrored yet, and enter is not going to change that.
      expect(h.text()).not.toContain("mirrored as");
      expect(h.text()).toContain("browse — nothing is downloaded");
      await h.press("enter");
      // One settle: the README is on screen, read through the origin's API.
      await h.until("gears and things, read live");
      const text = h.text();
      // The where strip: three places, and only the first one has it.
      expect(text).toContain(`● ${host}`);
      expect(text).toContain("○ workbench");
      expect(text).toContain("○ this machine");
      expect(text).toContain(
        `reading live from ${host} — read-only · m mirror into your workbench`,
      );
      expect(text).toContain("read-only");
      // The tree came from the same place.
      expect(text).toContain("src/");
      // No key that would write *here* exists — not disabled, absent — and
      // the keys that do make sense on somebody else's repository are
      // offered, forking at the origin among them.
      const help = await helpText(h);
      expect(help).toMatch(/m\s+mirror/);
      expect(help).toContain("open on origin");
      expect(help).toContain(`fork at ${host}`);
      expect(help).not.toContain("settings");
      expect(help).not.toContain("sync now");
      // Pressing them anyway names the one key that leads somewhere: a live
      // browse has no bytes of ours to change, and `W` is where the copy that
      // does live.
      await h.press("e");
      expect(h.text()).toContain("W to edit the workbench copy");
      await h.press("c");
      expect(h.text()).toContain("W to edit the workbench copy");
      // And nothing at all was created here.
      expect(getRepo(forge.db, "alice", "widgets")).toBeUndefined();
    } finally {
      h.stop();
    }
  }, 60_000);
  test("going back and re-entering costs the origin nothing", async () => {
    const h = boot(forge, asAlice());
    try {
      await openPicker(h);
      await h.press("enter");
      await h.until("gears and things, read live");
      // The workspace is the tree: opening the repository already listed it
      // and read a file out of it.
      await h.until("src/");
      // ...and from here on, everything is a cache hit. Back to the picker,
      // in again, and every read is answered from the cache: the origin
      // hears nothing.
      const mark = fake.state.requests.length;
      await h.press("esc");
      await h.until("octo/widgets");
      await h.press("enter");
      await h.until("gears and things, read live");
      await h.until("src/");
      expect(fake.state.requests.length).toBe(mark);
    } finally {
      h.stop();
    }
  }, 60_000);
  test("m mirrors with a visible checklist, and the screen becomes the local one", async () => {
    const h = boot(forge, asAlice());
    try {
      await openPicker(h);
      await h.press("enter");
      await h.until("gears and things, read live");
      // Two presses with no frame between them: the job layer dedupes the
      // work and the card dedupes itself, so there is exactly one card.
      h.burst("m", "m");
      const card = h.text();
      expect(card).toContain("Mirroring octo/widgets");
      for (const stage of [
        "creating",
        "fetching",
        "labels",
        "issues",
        "pulls",
        "comments",
      ])
        expect(card).toContain(stage);
      expect(card).toContain("esc hides this");
      expect(occurrences(crumbLine(h), "Mirroring")).toBe(1);
      // Done: the card goes, and the live screen underneath is replaced in
      // place by the same screen over the repository we now hold.
      await h.until("workbench (synced");
      // The file list is the local one now: these bytes came out of our own
      // bare repository rather than off the origin's API.
      await h.until("README.md");
      const after = h.text();
      const strip = after.split("\n")[2] ?? "";
      expect(strip).toMatch(
        /^● \S+ {2}·  ● workbench \(synced .+\) {2}·  ○ this machine/,
      );
      expect(after).not.toContain("reading live from");
      // Provenance lives on the about card (`I`) now that the repo's front
      // door is a workspace rather than a page.
      await h.press("I");
      await h.settle();
      expect(h.text()).toContain("mirrored from");
      await h.press("esc");
      await h.settle();
      expect(getRepo(forge.db, "alice", "widgets")).toBeDefined();
      // The write keys are here now, and the mirror key is gone.
      const help = await helpText(h);
      expect(help).toContain("settings");
      expect(help).toContain("fork");
      expect(help).toContain("sync now");
      expect(help).not.toMatch(/m\s+mirror\b/);
      // Including the one that matters most: you can say something.
      await h.press("i");
      await h.until("The gear slips");
      await h.press("enter");
      await h.until("The gear slips");
      expect(await helpText(h)).toContain("comment");
    } finally {
      h.stop();
    }
  }, 120_000);
  /**
   * Esc is not cancel. The job is detached from the card that started it, so
   * hiding the card leaves the mirror running and the outcome still arrives —
   * and the screen you are on is *not* yanked out from under you, because by
   * then it may not be the screen the mirror was started from.
   */
  test("esc hides the card and the mirror lands anyway", async () => {
    const h = boot(forge, asAlice());
    try {
      await openPicker(h, "gadgets");
      await h.press("enter");
      await h.until("○ workbench");
      h.burst("m");
      expect(h.text()).toContain("Mirroring octo/gadgets");
      await h.press("esc");
      expect(crumbLine(h)).not.toContain("Mirroring");
      expect(h.text()).toContain("mirroring in the background");
      // Still the live browse: a hidden card never replaces a screen.
      expect(h.text()).toContain("reading live from");
      await h.until("mirrored as alice/gadgets");
      expect(getRepo(forge.db, "alice", "gadgets")).toBeDefined();
      expect(h.text()).toContain("reading live from");
    } finally {
      h.stop();
    }
  }, 120_000);
  /**
   * The question the where-strip answers is "which of these two am I reading",
   * and `W` is the answer to "show me the other one". The dot moving is the
   * whole assertion: it is the same grammar on every repo screen, so if it
   * moves here it moves everywhere.
   */
  test("W swaps a mirror between the workbench copy and the live origin", async () => {
    const h = boot(forge, asAlice());
    try {
      // `widgets` was mirrored by the test above, so this repo has two sides.
      await h.press("/");
      await h.typeText("widgets");
      await h.press("enter");
      await h.press("enter");
      await h.until("workbench (synced");
      // Both places hold the repo, so both wear a filled dot — what says
      // which one you are *reading* is the accent, so that is what is
      // asserted. (The colour, not the glyph: that is the strip's grammar.)
      expect(h.text().split("\n")[2]).toMatch(/^● \S+ {2}·  ● workbench/);
      const workbenchAccent = h.app.screen.styleAt(0, 2).fg;
      expect(h.text()).not.toContain("reading live from");
      expect(await helpText(h)).toContain("live on");
      await h.press("W");
      await h.until("reading live from");
      // Same three places, same glyphs — and the accent has moved to the
      // first one, which is the whole of what `W` means.
      expect(h.text().split("\n")[2]).toMatch(/^● \S+ {2}·  ● workbench/);
      expect(h.app.screen.styleAt(0, 2).fg).not.toBe(workbenchAccent);
      expect(h.text()).toContain("read-only");
      // And back again, to the copy we hold.
      await h.press("W");
      await h.until("workbench (synced");
      expect(h.text()).not.toContain("reading live from");
    } finally {
      h.stop();
    }
  }, 120_000);
  test("the strip marks the third place when the repo is pinned", async () => {
    const h = boot(forge, asAlice());
    try {
      await h.until("alice/widgets");
      await h.press("/");
      await h.typeText("widgets");
      await h.press("enter");
      await h.press("enter");
      await h.until("workbench (synced");
      expect(h.text()).toContain("○ this machine");
      await h.press("P");
      await h.until("◆ this machine");
      expect(listPins(forge.db, alice.id)).toHaveLength(1);
      // Put it back, so the pin test below still starts from nothing.
      await h.press("P");
      await h.until("○ this machine");
      expect(listPins(forge.db, alice.id)).toHaveLength(0);
    } finally {
      h.stop();
    }
  }, 60_000);
  test("the picker says which rows it already holds", async () => {
    const h = boot(forge, asAlice());
    try {
      await openPicker(h);
      expect(h.text()).toContain("● mirrored as alice/widgets");
      // A row already held is not mirrored twice.
      await h.press("m");
      expect(h.text()).toContain("already mirrored");
    } finally {
      h.stop();
    }
  }, 60_000);
  test("an imported issue wears the origin's author, and a comment goes through", async () => {
    const h = boot(forge, asAlice());
    try {
      await h.until("alice/widgets");
      await h.press("/");
      await h.typeText("widgets");
      await h.press("enter");
      await h.press("enter");
      await h.until("workbench (synced");
      await h.press("i");
      await h.until("The gear slips");
      // The upstream mark plus the login on the origin, never a local name.
      expect(h.text()).toContain("mona");
      await h.press("enter");
      await h.until("The gear slips");
      expect(h.text()).toContain("mona");
      const before = fake.state.requests.length;
      await h.press("c");
      await h.until("Comment");
      await h.typeText("from the terminal");
      await h.press("ctrl+d");
      await h.until("comment posted");
      const wrote = fake.state.requests
        .slice(before)
        .some(
          (r) =>
            r.method === "POST" &&
            r.path.endsWith("/issues/7/comments") &&
            r.body.includes("from the terminal"),
        );
      expect(wrote).toBe(true);
    } finally {
      h.stop();
    }
  }, 60_000);
  test("p pins a repository and the dashboard says it is on your machine", async () => {
    const h = boot(forge, asAlice());
    try {
      await h.until("alice/widgets");
      // More than one repo is mirrored by now, so name the one being pinned.
      await h.press("/");
      await h.typeText("widgets");
      await h.press("enter");
      expect(listPins(forge.db, alice.id)).toHaveLength(0);
      await h.press("p");
      await h.until("On your machine");
      expect(listPins(forge.db, alice.id)).toHaveLength(1);
      expect(h.text()).toContain("forge sync");
      // The marker rides the row itself, not a separate list.
      expect(h.text()).toContain("◆ alice/widgets");
      await h.press("p");
      await h.until("Organizations");
      expect(listPins(forge.db, alice.id)).toHaveLength(0);
    } finally {
      h.stop();
    }
  }, 60_000);
});
@@ -8,35 +8,25 @@
 * against a real forge and asserts against the cell grid the renderer
 * produced, with no sleeps: every wait is `settleApp`.
 *
 * Two halves, because they need two worlds.
 *
 * - **At an origin** — a fake Forgejo API in front of a *second real forge*
 *   that is the git host behind its clone URLs. That is the only way to test
 *   forking and proposing honestly: the fork is a real repository, the push
 *   really leaves the machine, and the pull is opened on the upstream with
 *   the `owner:branch` head form both forges take.
 * - **At home** — one forge, an org with two writers, and one pull. Verdicts,
 *   the merge gate, and thread resolution are all about *who said what about
 *   which head*, and nothing about that needs another machine.
 * One forge, an org with two writers, and one pull. Verdicts, the merge
 * gate, and thread resolution are all about *who said what about which
 * head*, and nothing about that needs another machine.
 */
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 { connectOrigin, resetConnectLimit } from "../src/actions/origins.ts";
import { addTeamMember, createOrg, createTeam } from "../src/actions/orgs.ts";
import { openPull } from "../src/actions/pulls.ts";
import { commitToBranch, createRepo } from "../src/actions/repos.ts";
import { signUp } from "../src/actions/users.ts";
import { createApp, type App as Forge } from "../src/app.ts";
import { getRepo, type Repo } from "../src/core/repos.ts";
import type { Repo } from "../src/core/repos.ts";
import { listReviews } from "../src/core/reviews.ts";
import { getPull } from "../src/core/pulls.ts";
import type { User } from "../src/core/users.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { quietLogs } from "./helpers/globals.ts";
import { forgetProviders } from "../src/origins/providers/index.ts";
import type { App } from "../src/tui/app/app.ts";
import { createForgeApp } from "../src/tui/forge.ts";
import type { TuiIdentity } from "../src/tui/session.ts";
@@ -45,7 +35,6 @@
import {
  type HeadlessTerminal,
} from "../src/tui/term/terminal.ts";
import { settleApp } from "./helpers/tui.ts";
import { newFakeState, serveFakeForge, type FakeForge } from "./fake-origin.ts";
quietLogs();
@@ -173,360 +162,6 @@
const identityFor = (user: User): TuiIdentity => ({
// ---------------------------------------------------------------------------
describe("workflows at an origin", () => {
  let dataDir: string;
  let originDataDir: string;
  let forge: Forge;
  let originApp: Forge;
  let originServers: Servers;
  let fake: FakeForge;
  let alice: User;
  let originToken = "";
  const ORIGIN_LOGIN = "me";
  const UPSTREAM = "octo";
  const PASSWORD = "workflow-account-passphrase";
  const basic = (user: string): string =>
    `Basic ${Buffer.from(`${user}:${PASSWORD}`).toString("base64")}`;
  const upstream = (
    path: string,
    init: RequestInit & { as?: string } = {},
  ): Promise<Response> => {
    const headers = new Headers(init.headers);
    if (init.body !== undefined)
      headers.set("content-type", "application/json");
    headers.set("authorization", basic(init.as ?? UPSTREAM));
    return fetch(`${originServers.url}${path}`, { ...init, headers });
  };
  async function mkAccount(username: string): Promise<string> {
    await fetch(`${originServers.url}/api/v1/users`, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        username,
        email: `${username}@upstream.test`,
        password: PASSWORD,
      }),
    });
    const made = (await (
      await fetch(`${originServers.url}/api/v1/tokens`, {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          username,
          password: PASSWORD,
          name: "t",
          scope: "admin",
        }),
      })
    ).json()) as { token: string };
    return made.token;
  }
  async function seed(name: string, owner = UPSTREAM): Promise<void> {
    await upstream("/api/v1/repos", {
      as: owner,
      method: "POST",
      body: JSON.stringify({ name, visibility: "public" }),
    });
    await upstream(`/api/v1/repos/${owner}/${name}/contents`, {
      as: owner,
      method: "POST",
      body: JSON.stringify({
        branch: "main",
        message: "first",
        files: [
          { path: "README.md", content: `# ${name}\n\nread live\n` },
          { path: "a.txt", content: "one\n" },
        ],
      }),
    });
  }
  /** Dashboard → account → origins → browse this origin's repositories. */
  const openPicker = async (h: Harness): Promise<void> => {
    await h.press("A");
    await h.until("Account");
    await h.press("o");
    await h.until("Origins");
    await h.press("r");
    await h.until(`${UPSTREAM}/gears`);
  };
  /**
   * Put the picker's cursor on a named row. `row()` marks the selected one
   * with `▸`, so this asserts on what the reader would look at rather than on
   * an index that shifts the moment the listing is sorted differently.
   */
  const select = async (h: Harness, name: string): Promise<void> => {
    await h.press("g");
    for (let i = 0; i < 20; i++) {
      if (h.rows().some((line) => line.includes(`▸ ${name} `))) return;
      await h.press("j");
    }
    throw new Error(`never selected ${name}:\n${h.text()}`);
  };
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-tuiwf-"));
    originDataDir = await mkdtemp(join(tmpdir(), "forge-tuiwf-up-"));
    originApp = createApp({ dataDir: originDataDir, port: 0 });
    originServers = await serve(originApp);
    await mkAccount(UPSTREAM);
    originToken = await mkAccount(ORIGIN_LOGIN);
    await seed("gears");
    await seed("widgets");
    await seed("own", ORIGIN_LOGIN);
    // `me` really forks both upstreams on the *git host*, so the clone URL
    // the fake hands back for a fork points at a repository that exists and
    // that `me` may push to. The fake's own state deliberately does not know
    // about them, so the TUI's `F` really does POST /forks and really does
    // poll for the repository the origin promised.
    for (const name of ["gears", "widgets"]) {
      const forked = await upstream(`/api/v1/repos/${UPSTREAM}/${name}/forks`, {
        as: ORIGIN_LOGIN,
        method: "POST",
        body: "{}",
      });
      expect(forked.status).toBe(201);
    }
    const git = (name: string, owner = UPSTREAM): string =>
      `${originServers.url}/${owner}/${name}.git`;
    const state = newFakeState("forgejo", ORIGIN_LOGIN, originToken);
    state.repos.push(
      {
        id: 1,
        fullName: `${UPSTREAM}/gears`,
        description: "cannot push here",
        cloneUrl: git("gears"),
        htmlUrl: `${originServers.url}/${UPSTREAM}/gears`,
        defaultBranch: "main",
        push: false,
        admin: false,
      },
      {
        id: 2,
        fullName: `${UPSTREAM}/widgets`,
        description: "cannot push here either",
        cloneUrl: git("widgets"),
        htmlUrl: `${originServers.url}/${UPSTREAM}/widgets`,
        defaultBranch: "main",
        push: false,
        admin: false,
      },
      {
        id: 3,
        fullName: `${ORIGIN_LOGIN}/own`,
        description: "mine, and I may push",
        cloneUrl: git("own", ORIGIN_LOGIN),
        htmlUrl: `${originServers.url}/${ORIGIN_LOGIN}/own`,
        defaultBranch: "main",
        push: true,
        admin: true,
      },
    );
    // The origin does not finish making a fork before it answers.
    state.forkDelayReads = 1;
    for (const name of [
      `${UPSTREAM}/gears`,
      `${UPSTREAM}/widgets`,
      `${ORIGIN_LOGIN}/own`,
    ]) {
      state.branches.set(name, [
        { name: "main", sha: "1".repeat(40), protected: false },
      ]);
      state.files.set(
        name,
        new Map([
          ["README.md", `# ${name.split("/")[1]}\n\nread live\n`],
          ["a.txt", "one\n"],
        ]),
      );
    }
    fake = serveFakeForge(state);
    forge = createApp({ dataDir, port: 0 });
    const created = await signUp(forge, {
      username: "alice",
      email: "[email protected]",
      password: "a-long-passphrase",
    });
    if (!created.ok) throw new Error("signup failed");
    alice = created.value;
    resetConnectLimit();
    forgetProviders(dataDir);
    const connected = await connectOrigin(forge, alice, {
      host: fake.url,
      token: originToken,
    });
    if (!connected.ok)
      throw new Error(`connect failed: ${String(connected.error)}`);
  }, 120_000);
  afterAll(async () => {
    fake.stop();
    originServers.stop();
    forge.close();
    originApp.close();
    forgetProviders(dataDir);
    await rm(dataDir, { recursive: true, force: true });
    await rm(originDataDir, { recursive: true, force: true });
  }, 60_000);
  test("F on a live browse forks at the origin and lands in the fork", async () => {
    const h = boot(forge, identityFor(alice));
    try {
      await h.settle();
      await openPicker(h);
      await select(h, `${UPSTREAM}/gears`);
      // Opened with the pointer: a click selects, a second click opens —
      // the picker's rows answer the mouse like every other list.
      const row = h.rowOf(`${UPSTREAM}/gears`);
      expect(row).toBeGreaterThan(0);
      await h.click(4, row, 2);
      await h.until("read live");
      expect(h.text()).toContain("reading live from");
      await h.press("F");
      // The card says the whole sentence: two machines are involved.
      await h.until(`Fork ${UPSTREAM}/gears to your account`);
      expect(h.text()).toContain("and mirror it here?");
      await h.press("enter");
      // The mirror runs over the job the fork started; wait for the
      // outcome — the fork's own workspace — rather than the mirror card,
      // which can finish and be gone before the next poll ever sees it.
      await h.until(`fork of ${UPSTREAM}/gears`, 60_000);
      // The card was still shown: the harness saw it pushed.
      expect(h.opened().some((t) => t.startsWith("Mirroring"))).toBe(true);
      const fork = getRepo(forge.db, "alice", "gears");
      expect(fork).toBeDefined();
      // The about card says it too, in words, beside the clone URLs.
      await h.press("I");
      await h.until("About");
      expect(h.text()).toContain(`fork of ${UPSTREAM}/gears`);
      await h.press("esc");
      const posts = fake.state.requests.filter(
        (r) => r.method === "POST" && r.path.endsWith("/gears/forks"),
      );
      expect(posts).toHaveLength(1);
    } finally {
      h.stop();
    }
  }, 120_000);
  test("a change on an unpushable upstream becomes a pull on it", async () => {
    const h = boot(forge, identityFor(alice));
    try {
      await h.settle();
      await openPicker(h);
      // Take a copy of `octo/widgets` first, so the pull that comes back has
      // somewhere here to be imported into — the "local import" half.
      await select(h, `${UPSTREAM}/widgets`);
      await h.press("m");
      // Wait for the outcome, not the mirror card: on a fast machine the
      // job can finish before the next poll ever sees "Mirroring".
      await h.until("mirrored as alice/widgets", 60_000);
      expect(getRepo(forge.db, "alice", "widgets")).toBeDefined();
      expect(h.opened()).toContain(`Mirroring ${UPSTREAM}/widgets`);
      // Now browse it live: read-only, and not ours to push to.
      await h.press("enter");
      await h.until("read live");
      expect(h.text()).toContain(`proposing to ${UPSTREAM}/widgets`);
      // Edit the README and propose it.
      await h.press("e");
      await h.settle();
      await h.type("hello from alice");
      await h.press("esc");
      await h.press("c");
      await h.until("Propose a change");
      const dialog = h.text();
      // The proposal dialog, not the commit dialog.
      expect(dialog).not.toContain("commit to main");
      expect(dialog).toContain("Branch in your fork");
      expect(dialog).toContain(`Pull request`);
      expect(dialog).toContain(`${UPSTREAM}/widgets`);
      await h.press("ctrl+s");
      await h.until(`opened pull #1 on ${UPSTREAM}/widgets`, 90_000);
      // The head form both forges take, with the fork's owner on the front.
      const opened = fake.state.requests.find(
        (r) => r.method === "POST" && r.path.endsWith("/widgets/pulls"),
      );
      expect(opened).toBeDefined();
      const body = JSON.parse(opened!.body) as { head: string; base: string };
      expect(body.head).toContain(":");
      expect(body.head.split(":")[0]).toBe(ORIGIN_LOGIN);
      expect(body.head.split(":").at(-1)).toContain("edit-");
      expect(body.base).toBe("main");
      // The branch really landed in the fork's git — asked of the git host
      // itself, not of anything this forge remembers about it.
      const branch = body.head.split(":").at(-1)!;
      const branches = (await (
        await upstream(`/api/v1/repos/${ORIGIN_LOGIN}/widgets/branches`, {
          as: ORIGIN_LOGIN,
        })
      ).json()) as { name: string }[];
      expect(branches.map((b) => b.name)).toContain(branch);
      // And the pull was imported into our mirror of the upstream, so the
      // screen could follow the reader straight to it.
      await h.until("Merge", 30_000);
      expect(h.text()).toContain("#1");
      expect(h.text()).toContain("Conversation");
    } finally {
      h.stop();
    }
  }, 180_000);
  test("a repository you may push to keeps the ordinary commit dialog", async () => {
    const h = boot(forge, identityFor(alice));
    try {
      await h.settle();
      await openPicker(h);
      await select(h, `${ORIGIN_LOGIN}/own`);
      // Mirror it, then work on the copy: this is the push-capable path.
      // Wait for the outcome, not the mirror card — see the fork test above.
      await h.press("m");
      await h.until("mirrored as alice/own", 60_000);
      expect(h.opened()).toContain(`Mirroring ${ORIGIN_LOGIN}/own`);
      await h.press("enter");
      await h.until("read live");
      // The origin says this one is ours to push to, so nothing is proposed.
      expect(h.text()).not.toContain("proposing to");
      // On the copy we hold, the ordinary dialog: a ref to commit onto.
      await h.press("W");
      await h.until("workbench");
      await h.press("e");
      await h.settle();
      await h.type("x");
      await h.press("esc");
      await h.press("c");
      await h.until("commit to main");
      expect(h.text()).not.toContain("Propose a change");
      await h.press("esc");
    } finally {
      h.stop();
    }
  }, 180_000);
});
// ---------------------------------------------------------------------------
describe("reviews, threads and the merge gate", () => {
  let dataDir: string;
  let forge: Forge;
		@@ -496,12 +496,7 @@ JavaScript at all it is a `<textarea>` in a `<form>`, which is what it was
496	496	before any of this. The Preview tab is offered on Markdown only, and renders
497	497	through the same `/preview` fragment the server will use for the file.
498	498
499		Terminal keys and glyphs for origins. Account → `o` opens Origins; there
500		`c` connects, `s` syncs now, `r` browses the origin's repositories and `D`
501		disconnects. In the picker `enter` browses the row — live, read-only,
502		nothing downloaded — and `m` mirrors it into the workbench; a second `m` on a
503		running mirror joins the job rather than starting a second one. On a repo's
504		home `y` syncs the mirror and `P` pins it — `p` has meant _pulls_ on that
	499	Origins are web-only. Connecting, syncing and browsing an origin live on the web pages (`/origins`) and in migrate; the terminal has no origins screen. On a mirrored repo's home `y` syncs the mirror and `P` pins it — `p` has meant _pulls_ on that
505	500	screen since before pins existed, so the toggle takes the shifted key there
506	501	and the plain `p` everywhere a repo is a _row_ (the dashboard, explore).
507	502
		@@ -599,8 +594,8 @@ Four rules hold the gestures together:
599	594	Clickable today: every list row, the dashboard's four panes, the workspace's
600	595	explorer rows and tab chips (including the active tab's `✗`), the file pane
601	596	(focus, and the wheel), the where-strip's three places, the palette's results,
602		the appearance picker's rows, the owner, refs, settings, account and origins
603		lists, the origin picker's rows, the pull's diff-and-threads pane, and **every
	597	the appearance picker's rows, the owner, refs, settings, account
	598	lists, the pull's diff-and-threads pane, and **every
604	599	hint in the help bar** — clicking a hint presses the key it names, taken from
605	600	the binding itself so a label can never drift from the action. A list with no
606	601	`hitList` is a bug, not a design decision: "everything you can see is
		@@ -38,7 +38,6 @@ import { exploreScreen } from "./screens/explore.ts";
38	38	import { issuesScreen, newIssueScreen } from "./screens/issues.ts";
39	39	import { newPullScreen } from "./screens/newpull.ts";
40	40	import { newRepoScreen } from "./screens/newrepo.ts";
41		import { originsScreen } from "./screens/origins.ts";
42	41	import { ownerScreen } from "./screens/owner.ts";
43	42	import { repoScreen } from "./screens/repo.ts";
44	43	import { settingsScreen } from "./screens/settings.ts";
		@@ -177,12 +176,6 @@ export function forgeCommands(session: Session): (ctx: Ctx) => Command[] {
177	176	title: "Account settings",
178	177	run: () => ctx.push(accountScreen(session, ctx)),
179	178	},
180		{
181		id: "origins",
182		title: "Origins",
183		hint: "connected forges",
184		run: () => ctx.push(originsScreen(session, ctx)),
185		},
186	179	);
187	180	if (session.user?.isAdmin === true)
188	181	commands.push({
		@@ -39,7 +39,6 @@ import {
39	39	runAsync,
40	40	} from "./common.ts";
41	41	import { crewScreen } from "./crew.ts";
42		import { originsScreen } from "./origins.ts";
43	42
44	43	const TABS = ["Profile", "Tokens", "SSH keys"] as const;
45	44
		@@ -68,7 +67,6 @@ export function accountScreen(f: Session, ctx: Ctx): Screen {
68	67	binding(["d"], "display name"),
69	68	binding(["e"], "email"),
70	69	binding(["p"], "password"),
71		binding(["o"], "origins"),
72	70	...crew,
73	71	];
74	72	if (tab === 1)
		@@ -76,14 +74,12 @@ export function accountScreen(f: Session, ctx: Ctx): Screen {
76	74	binding(["tab"], "next tab"),
77	75	binding(["n"], "new token"),
78	76	binding(["D"], "revoke"),
79		binding(["o"], "origins"),
80	77	...crew,
81	78	];
82	79	return [
83	80	binding(["tab"], "next tab"),
84	81	binding(["n"], "add key"),
85	82	binding(["D"], "delete key"),
86		binding(["o"], "origins"),
87	83	...crew,
88	84	];
89	85	},
		@@ -148,12 +144,6 @@ export function accountScreen(f: Session, ctx: Ctx): Screen {
148	144	state.index = 0;
149	145	return true;
150	146	}
151		// Origins are an account-level thing, like tokens and keys, so they
152		// hang off this screen from every tab rather than becoming a fourth.
153		if (e.key === "o") {
154		ctx.push(originsScreen(f, ctx));
155		return true;
156		}
157	147	if (e.key === "c" && f.user?.isAdmin === true) {
158	148	ctx.push(crewScreen(f, ctx));
159	149	return true;
		@@ -435,7 +435,7 @@ describe("the terminal, around the workspace", () => {
435	435	await h.settle();
436	436	await openRepo(h, "lighthouse");
437	437	// A native repo has no origin page, and the screen says so rather than
438		// pretending. (The mirrored case is covered in tui-origins.)
	438	// pretending. (The mirrored case is covered on the web.)
439	439	await h.press("O");
440	440	expect(h.text()).toContain("no origin page");
441	441	} finally {
		@@ -8,35 +8,25 @@
8	8	* against a real forge and asserts against the cell grid the renderer
9	9	* produced, with no sleeps: every wait is `settleApp`.
10	10	*
11		* Two halves, because they need two worlds.
12		*
13		* - At an origin — a fake Forgejo API in front of a second real forge
14		* that is the git host behind its clone URLs. That is the only way to test
15		* forking and proposing honestly: the fork is a real repository, the push
16		* really leaves the machine, and the pull is opened on the upstream with
17		* the `owner:branch` head form both forges take.
18		* - At home — one forge, an org with two writers, and one pull. Verdicts,
19		* the merge gate, and thread resolution are all about *who said what about
20		* which head*, and nothing about that needs another machine.
	11	* One forge, an org with two writers, and one pull. Verdicts, the merge
	12	* gate, and thread resolution are all about *who said what about which
	13	* head*, and nothing about that needs another machine.
21	14	*/
22	15
23	16	import { afterAll, beforeAll, describe, expect, test } from "bun:test";
24	17	import { mkdtemp, rm } from "node:fs/promises";
25	18	import { tmpdir } from "node:os";
26	19	import { join } from "node:path";
27		import { connectOrigin, resetConnectLimit } from "../src/actions/origins.ts";
28	20	import { addTeamMember, createOrg, createTeam } from "../src/actions/orgs.ts";
29	21	import { openPull } from "../src/actions/pulls.ts";
30	22	import { commitToBranch, createRepo } from "../src/actions/repos.ts";
31	23	import { signUp } from "../src/actions/users.ts";
32	24	import { createApp, type App as Forge } from "../src/app.ts";
33		import { getRepo, type Repo } from "../src/core/repos.ts";
	25	import type { Repo } from "../src/core/repos.ts";
34	26	import { listReviews } from "../src/core/reviews.ts";
35	27	import { getPull } from "../src/core/pulls.ts";
36	28	import type { User } from "../src/core/users.ts";
37		import { serve, type Servers } from "../src/http/server.ts";
38	29	import { quietLogs } from "./helpers/globals.ts";
39		import { forgetProviders } from "../src/origins/providers/index.ts";
40	30	import type { App } from "../src/tui/app/app.ts";
41	31	import { createForgeApp } from "../src/tui/forge.ts";
42	32	import type { TuiIdentity } from "../src/tui/session.ts";
		@@ -45,7 +35,6 @@ import {
45	35	type HeadlessTerminal,
46	36	} from "../src/tui/term/terminal.ts";
47	37	import { settleApp } from "./helpers/tui.ts";
48		import { newFakeState, serveFakeForge, type FakeForge } from "./fake-origin.ts";
49	38
50	39	quietLogs();
51	40
		@@ -173,360 +162,6 @@ const identityFor = (user: User): TuiIdentity => ({
173	162
174	163	// ---------------------------------------------------------------------------
175	164
176		describe("workflows at an origin", () => {
177		let dataDir: string;
178		let originDataDir: string;
179		let forge: Forge;
180		let originApp: Forge;
181		let originServers: Servers;
182		let fake: FakeForge;
183		let alice: User;
184		let originToken = "";
185
186		const ORIGIN_LOGIN = "me";
187		const UPSTREAM = "octo";
188		const PASSWORD = "workflow-account-passphrase";
189
190		const basic = (user: string): string =>
191		`Basic ${Buffer.from(`${user}:${PASSWORD}`).toString("base64")}`;
192
193		const upstream = (
194		path: string,
195		init: RequestInit & { as?: string } = {},
196		): Promise<Response> => {
197		const headers = new Headers(init.headers);
198		if (init.body !== undefined)
199		headers.set("content-type", "application/json");
200		headers.set("authorization", basic(init.as ?? UPSTREAM));
201		return fetch(`${originServers.url}${path}`, { ...init, headers });
202		};
203
204		async function mkAccount(username: string): Promise<string> {
205		await fetch(`${originServers.url}/api/v1/users`, {
206		method: "POST",
207		headers: { "content-type": "application/json" },
208		body: JSON.stringify({
209		username,
210		email: `${username}@upstream.test`,
211		password: PASSWORD,
212		}),
213		});
214		const made = (await (
215		await fetch(`${originServers.url}/api/v1/tokens`, {
216		method: "POST",
217		headers: { "content-type": "application/json" },
218		body: JSON.stringify({
219		username,
220		password: PASSWORD,
221		name: "t",
222		scope: "admin",
223		}),
224		})
225		).json()) as { token: string };
226		return made.token;
227		}
228
229		async function seed(name: string, owner = UPSTREAM): Promise<void> {
230		await upstream("/api/v1/repos", {
231		as: owner,
232		method: "POST",
233		body: JSON.stringify({ name, visibility: "public" }),
234		});
235		await upstream(`/api/v1/repos/${owner}/${name}/contents`, {
236		as: owner,
237		method: "POST",
238		body: JSON.stringify({
239		branch: "main",
240		message: "first",
241		files: [
242		{ path: "README.md", content: `# ${name}\n\nread live\n` },
243		{ path: "a.txt", content: "one\n" },
244		],
245		}),
246		});
247		}
248
249		/** Dashboard → account → origins → browse this origin's repositories. */
250		const openPicker = async (h: Harness): Promise<void> => {
251		await h.press("A");
252		await h.until("Account");
253		await h.press("o");
254		await h.until("Origins");
255		await h.press("r");
256		await h.until(`${UPSTREAM}/gears`);
257		};
258
259		/**
260		* Put the picker's cursor on a named row. `row()` marks the selected one
261		* with `▸`, so this asserts on what the reader would look at rather than on
262		* an index that shifts the moment the listing is sorted differently.
263		*/
264		const select = async (h: Harness, name: string): Promise<void> => {
265		await h.press("g");
266		for (let i = 0; i < 20; i++) {
267		if (h.rows().some((line) => line.includes(`▸ ${name} `))) return;
268		await h.press("j");
269		}
270		throw new Error(`never selected ${name}:\n${h.text()}`);
271		};
272
273		beforeAll(async () => {
274		dataDir = await mkdtemp(join(tmpdir(), "forge-tuiwf-"));
275		originDataDir = await mkdtemp(join(tmpdir(), "forge-tuiwf-up-"));
276
277		originApp = createApp({ dataDir: originDataDir, port: 0 });
278		originServers = await serve(originApp);
279		await mkAccount(UPSTREAM);
280		originToken = await mkAccount(ORIGIN_LOGIN);
281		await seed("gears");
282		await seed("widgets");
283		await seed("own", ORIGIN_LOGIN);
284
285		// `me` really forks both upstreams on the git host, so the clone URL
286		// the fake hands back for a fork points at a repository that exists and
287		// that `me` may push to. The fake's own state deliberately does not know
288		// about them, so the TUI's `F` really does POST /forks and really does
289		// poll for the repository the origin promised.
290		for (const name of ["gears", "widgets"]) {
291		const forked = await upstream(`/api/v1/repos/${UPSTREAM}/${name}/forks`, {
292		as: ORIGIN_LOGIN,
293		method: "POST",
294		body: "{}",
295		});
296		expect(forked.status).toBe(201);
297		}
298
299		const git = (name: string, owner = UPSTREAM): string =>
300		`${originServers.url}/${owner}/${name}.git`;
301		const state = newFakeState("forgejo", ORIGIN_LOGIN, originToken);
302		state.repos.push(
303		{
304		id: 1,
305		fullName: `${UPSTREAM}/gears`,
306		description: "cannot push here",
307		cloneUrl: git("gears"),
308		htmlUrl: `${originServers.url}/${UPSTREAM}/gears`,
309		defaultBranch: "main",
310		push: false,
311		admin: false,
312		},
313		{
314		id: 2,
315		fullName: `${UPSTREAM}/widgets`,
316		description: "cannot push here either",
317		cloneUrl: git("widgets"),
318		htmlUrl: `${originServers.url}/${UPSTREAM}/widgets`,
319		defaultBranch: "main",
320		push: false,
321		admin: false,
322		},
323		{
324		id: 3,
325		fullName: `${ORIGIN_LOGIN}/own`,
326		description: "mine, and I may push",
327		cloneUrl: git("own", ORIGIN_LOGIN),
328		htmlUrl: `${originServers.url}/${ORIGIN_LOGIN}/own`,
329		defaultBranch: "main",
330		push: true,
331		admin: true,
332		},
333		);
334		// The origin does not finish making a fork before it answers.
335		state.forkDelayReads = 1;
336		for (const name of [
337		`${UPSTREAM}/gears`,
338		`${UPSTREAM}/widgets`,
339		`${ORIGIN_LOGIN}/own`,
340		]) {
341		state.branches.set(name, [
342		{ name: "main", sha: "1".repeat(40), protected: false },
343		]);
344		state.files.set(
345		name,
346		new Map([
347		["README.md", `# ${name.split("/")[1]}\n\nread live\n`],
348		["a.txt", "one\n"],
349		]),
350		);
351		}
352		fake = serveFakeForge(state);
353
354		forge = createApp({ dataDir, port: 0 });
355		const created = await signUp(forge, {
356		username: "alice",
357		email: "[email protected]",
358		password: "a-long-passphrase",
359		});
360		if (!created.ok) throw new Error("signup failed");
361		alice = created.value;
362		resetConnectLimit();
363		forgetProviders(dataDir);
364
365		const connected = await connectOrigin(forge, alice, {
366		host: fake.url,
367		token: originToken,
368		});
369		if (!connected.ok)
370		throw new Error(`connect failed: ${String(connected.error)}`);
371		}, 120_000);
372
373		afterAll(async () => {
374		fake.stop();
375		originServers.stop();
376		forge.close();
377		originApp.close();
378		forgetProviders(dataDir);
379		await rm(dataDir, { recursive: true, force: true });
380		await rm(originDataDir, { recursive: true, force: true });
381		}, 60_000);
382
383		test("F on a live browse forks at the origin and lands in the fork", async () => {
384		const h = boot(forge, identityFor(alice));
385		try {
386		await h.settle();
387		await openPicker(h);
388		await select(h, `${UPSTREAM}/gears`);
389		// Opened with the pointer: a click selects, a second click opens —
390		// the picker's rows answer the mouse like every other list.
391		const row = h.rowOf(`${UPSTREAM}/gears`);
392		expect(row).toBeGreaterThan(0);
393		await h.click(4, row, 2);
394		await h.until("read live");
395		expect(h.text()).toContain("reading live from");
396
397		await h.press("F");
398		// The card says the whole sentence: two machines are involved.
399		await h.until(`Fork ${UPSTREAM}/gears to your account`);
400		expect(h.text()).toContain("and mirror it here?");
401
402		await h.press("enter");
403		// The mirror runs over the job the fork started; wait for the
404		// outcome — the fork's own workspace — rather than the mirror card,
405		// which can finish and be gone before the next poll ever sees it.
406		await h.until(`fork of ${UPSTREAM}/gears`, 60_000);
407		// The card was still shown: the harness saw it pushed.
408		expect(h.opened().some((t) => t.startsWith("Mirroring"))).toBe(true);
409
410		const fork = getRepo(forge.db, "alice", "gears");
411		expect(fork).toBeDefined();
412		// The about card says it too, in words, beside the clone URLs.
413		await h.press("I");
414		await h.until("About");
415		expect(h.text()).toContain(`fork of ${UPSTREAM}/gears`);
416		await h.press("esc");
417
418		const posts = fake.state.requests.filter(
419		(r) => r.method === "POST" && r.path.endsWith("/gears/forks"),
420		);
421		expect(posts).toHaveLength(1);
422		} finally {
423		h.stop();
424		}
425		}, 120_000);
426
427		test("a change on an unpushable upstream becomes a pull on it", async () => {
428		const h = boot(forge, identityFor(alice));
429		try {
430		await h.settle();
431		await openPicker(h);
432		// Take a copy of `octo/widgets` first, so the pull that comes back has
433		// somewhere here to be imported into — the "local import" half.
434		await select(h, `${UPSTREAM}/widgets`);
435		await h.press("m");
436		// Wait for the outcome, not the mirror card: on a fast machine the
437		// job can finish before the next poll ever sees "Mirroring".
438		await h.until("mirrored as alice/widgets", 60_000);
439		expect(getRepo(forge.db, "alice", "widgets")).toBeDefined();
440		expect(h.opened()).toContain(`Mirroring ${UPSTREAM}/widgets`);
441
442		// Now browse it live: read-only, and not ours to push to.
443		await h.press("enter");
444		await h.until("read live");
445		expect(h.text()).toContain(`proposing to ${UPSTREAM}/widgets`);
446
447		// Edit the README and propose it.
448		await h.press("e");
449		await h.settle();
450		await h.type("hello from alice");
451		await h.press("esc");
452		await h.press("c");
453		await h.until("Propose a change");
454		const dialog = h.text();
455		// The proposal dialog, not the commit dialog.
456		expect(dialog).not.toContain("commit to main");
457		expect(dialog).toContain("Branch in your fork");
458		expect(dialog).toContain(`Pull request`);
459		expect(dialog).toContain(`${UPSTREAM}/widgets`);
460
461		await h.press("ctrl+s");
462		await h.until(`opened pull #1 on ${UPSTREAM}/widgets`, 90_000);
463
464		// The head form both forges take, with the fork's owner on the front.
465		const opened = fake.state.requests.find(
466		(r) => r.method === "POST" && r.path.endsWith("/widgets/pulls"),
467		);
468		expect(opened).toBeDefined();
469		const body = JSON.parse(opened!.body) as { head: string; base: string };
470		expect(body.head).toContain(":");
471		expect(body.head.split(":")[0]).toBe(ORIGIN_LOGIN);
472		expect(body.head.split(":").at(-1)).toContain("edit-");
473		expect(body.base).toBe("main");
474
475		// The branch really landed in the fork's git — asked of the git host
476		// itself, not of anything this forge remembers about it.
477		const branch = body.head.split(":").at(-1)!;
478		const branches = (await (
479		await upstream(`/api/v1/repos/${ORIGIN_LOGIN}/widgets/branches`, {
480		as: ORIGIN_LOGIN,
481		})
482		).json()) as { name: string }[];
483		expect(branches.map((b) => b.name)).toContain(branch);
484
485		// And the pull was imported into our mirror of the upstream, so the
486		// screen could follow the reader straight to it.
487		await h.until("Merge", 30_000);
488		expect(h.text()).toContain("#1");
489		expect(h.text()).toContain("Conversation");
490		} finally {
491		h.stop();
492		}
493		}, 180_000);
494
495		test("a repository you may push to keeps the ordinary commit dialog", async () => {
496		const h = boot(forge, identityFor(alice));
497		try {
498		await h.settle();
499		await openPicker(h);
500		await select(h, `${ORIGIN_LOGIN}/own`);
501		// Mirror it, then work on the copy: this is the push-capable path.
502		// Wait for the outcome, not the mirror card — see the fork test above.
503		await h.press("m");
504		await h.until("mirrored as alice/own", 60_000);
505		expect(h.opened()).toContain(`Mirroring ${ORIGIN_LOGIN}/own`);
506		await h.press("enter");
507		await h.until("read live");
508		// The origin says this one is ours to push to, so nothing is proposed.
509		expect(h.text()).not.toContain("proposing to");
510
511		// On the copy we hold, the ordinary dialog: a ref to commit onto.
512		await h.press("W");
513		await h.until("workbench");
514		await h.press("e");
515		await h.settle();
516		await h.type("x");
517		await h.press("esc");
518		await h.press("c");
519		await h.until("commit to main");
520		expect(h.text()).not.toContain("Propose a change");
521		await h.press("esc");
522		} finally {
523		h.stop();
524		}
525		}, 180_000);
526		});
527
528		// ---------------------------------------------------------------------------
529
530	165	describe("reviews, threads and the merge gate", () => {
531	166	let dataDir: string;
532	167	let forge: Forge;