4cdea78 · 80e1a02 · 02d1186 · 9112d0c · ff741c2 · 8f6b30f
@@ -474,3 +474,22 @@
Flags: none.
$ forge talk "what is waiting on me?"
Two pulls are green and wait for your merge: #12 and #15.
```
## forge data
The SQLite files you may read, from a shell (so nvim and other editors can use
them). The forge decides what you see (an admin: its own `forge.db`; a writer
of an app: that app's databases per environment) and masks secrets, exactly as
the Data screen and the MCP `data` tool do.
- `forge data` lists the databases.
- `forge data <app> [env]` lists that app's tables (`env` defaults to production).
- `forge data <app> [env] --table name [--page n]` prints 50 rows.
- `forge data <app> [env] "SELECT …"` runs one read-only SELECT (5 s, 1,000 rows); a write is refused with the forge's words and exit 1. SQL is 20 runs a minute per person, shared with the web and terminal; past that it prints "try again in N s" and exits 1.
`--file x.db` picks among several databases of one environment (`app.db` is the default). `--json` prints an array of objects (rows) or of tables. An unknown or unreadable app exits 2; not logged in exits 3.
```console
$ forge data notes "select name from users" --json
[{"name":"ann"}]
```
@@ -31,6 +31,7 @@
forge open owner/name --web        # the page, in a browser
forge ship 12                      # land pull #12 after a y/N, as Merge does
forge pulls                        # open pulls of this clone, newest first
forge runs                         # the crew's last 10 runs here: state, agent, #N, title, age, cost
forge data notes "select * from users" --json   # read an app's SQLite, read-only, secrets masked
forge asks                         # what waits on you, most important first
forge asks --repo owner/name       # only that repository's; --json for the API's answer
forge asks --ship 1 3              # decide by the line numbers just printed: planned, then Apply? [y/N]
@@ -12,7 +12,9 @@
Views are masked whole when their text mentions a masked column (an alias cannot
Limits on work: `query` runs at most 2 workers at once (a third is told it is busy), each with a 128 MB heap cap (`hard_heap_limit`), a 5 s timer, 1,000 rows and about 250 KB of result; every cell is cut to 1,000 characters inside SQLite and a blob shows as its size. `rows()` cuts cells the same way.
Terminal: `src/tui/screens/data.ts` (files → tables → rows, `n`/`p` for pages, `s` sort, `f` filter, `c` clear, `x` read-only SQL), offered by `maySeeData`; the forge's own database is among an admin's files. SQL on either door is 20 runs a minute per person (`src/data/sql_window.ts`); beyond that it says when to retry.
Terminal: `src/tui/screens/data.ts` is a tree (repos → apps → environments → files → tables → first 50 rows; `src/data/tree.ts` builds it), offered by `maySeeData`. Keys: `j`/`k` move, `l`/Enter open, `h` close or go up, `/` filter the open lines, `:` a read-only SQL prompt against the file under the cursor (same caps; a write is refused), `y` yank a row as JSON (OSC 52), `n`/`p` next/previous page of 50 rows on a table or row, `r` read the files afresh. The tree is built once and rebuilt only when a node opens, a page turns or `r` is pressed; the files are read once per open node. Shell: `forge data <app> [env] [sql] [--json]` (docs/CLI.md) calls the MCP tool.
Not done: a filter that reaches into closed lines, SQL on the web page. SQL on any door (web, terminal, `forge data` and the MCP `data` tool) is 20 runs a minute per person (`src/data/sql_window.ts`); beyond that it says when to retry.
API and MCP by repository (`data/repo_scope.ts`, `http/api/data.ts`): `GET /api/v1/repos/:o/:n/data` (databases as `{ env, file }`), `…/data/:env/:file/tables`, `…/rows?table=&page=`, `POST …/query {sql}`; MCP `data` with `{ repo, env?, file?, table?, sql? }` answers the same. Only writers of the repository (and admins) see anything; everyone else gets a 404 (an error from the tool). Same masking, read-only SQL and 1,000-row cap as the web; SQL shares the per-person 20 a minute (`sql_window.ts`), and past it the API answers 429 with `retry-after`, the tool an error. `page` is a whole number from 0 to 1000.
@@ -187,6 +187,30 @@
export class ForgeApi {
    return ok(parsed as T);
  }
  /**
   * One MCP tool call (`POST /mcp`, tools/call): the tool's JSON answer, or
   * the forge's words when it refused.
   */
  async tool(name: string, args: Record<string, unknown>): Promise<ApiResult<unknown>> {
    const got = await this.call<{ result?: { content?: { text?: unknown }[]; isError?: boolean }; error?: { message?: unknown } }>(
      "/mcp",
      {
        method: "POST",
        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
      },
    );
    if (!got.ok) return got;
    const text = got.value.result?.content?.[0]?.text;
    if (typeof text !== "string")
      return err({ code: "bad_response", message: String(got.value.error?.message ?? "unexpected answer"), status: 200 });
    if (got.value.result?.isError === true) return err({ code: "tool", message: text, status: 400 });
    try {
      return ok(JSON.parse(text) as unknown);
    } catch {
      return err({ code: "bad_response", message: "the answer was not JSON", status: 200 });
    }
  }
  async whoami(): Promise<ApiResult<Whoami>> {
    const out = await this.call<{ username?: string; displayName?: string }>(
      "/api/v1/user",
@@ -0,0 +1,108 @@
import { ForgeApi } from "../api.ts";
import { requireConfig } from "../context.ts";
import { EXIT } from "../exit.ts";
import { cell, inert, type Out } from "../out.ts";
import { cellLine, rowObject, type Cell } from "../../data/shape.ts";
import type { Command } from "./types.ts";
interface Listed {
  source: string;
  label: string;
}
const isList = (v: unknown): v is Listed[] =>
  Array.isArray(v) && v.every((x) => typeof x === "object" && x !== null && typeof (x as Listed).source === "string" && typeof (x as Listed).label === "string");
const ENV = /^(production|pull-[1-9]\d*|build-[0-9a-f]{7})$/;
/** The file `forge data <app> [env]` means, among those the forge listed; an error message when it is none or many. */
export function pick(list: readonly Listed[], app: string, env: string | undefined, file: string | undefined): Listed | string {
  const parts = (l: Listed) => l.label.split(" · ");
  const named = list.filter((l) => {
    const [slug, e, f] = parts(l);
    return slug === app && (env === undefined || e === env) && (file === undefined || f === file);
  });
  if (named.length === 0) return `no database for ${[app, env, file].filter(Boolean).join(" ")} that you may read`;
  const prod = named.filter((l) => parts(l)[1] === "production");
  const pool = env === undefined && prod.length > 0 ? prod : named;
  const preferred = pool.filter((l) => parts(l)[2] === "app.db");
  const chosen = file === undefined && preferred.length > 0 ? preferred : pool;
  if (chosen.length === 1) return chosen[0]!;
  return `several databases match: ${chosen.map((l) => l.label.replaceAll(" · ", " ")).join(", ")} — name the env, or pass --file`;
}
function show(out: Out, columns: readonly string[], rows: readonly (readonly Cell[])[], json: boolean): void {
  if (json) {
    out.line(JSON.stringify(rows.map((r) => rowObject(columns, r))));
    return;
  }
  if (rows.length === 0) {
    out.line("No rows.");
    return;
  }
  out.table(
    columns.map((header) => ({ header, max: 40 })),
    rows.map((r) => r.map((v) => cell(cellLine(v)))),
  );
}
/**
 * `forge data` lists the databases you may read; `forge data <app> [env]`
 * its tables; with `--table` a page of rows; with SQL the answer to a
 * read-only SELECT. The forge decides what you may see and masks secrets.
 */
async function data(out: Out, args: Parameters<Command["run"]>[1]): Promise<number> {
  const loaded = await requireConfig(out);
  if (typeof loaded === "number") return loaded;
  const json = args.flag("json");
  const api = new ForgeApi(loaded.url, loaded.token);
  const fail = (m: string, code: number = EXIT.failed): number => (out.err(`forge data: ${inert(m)}`), code);
  const listed = await api.tool("data", {});
  if (!listed.ok) return fail(listed.error.message, listed.error.status === 401 ? EXIT.notConfigured : EXIT.failed);
  if (!isList(listed.value)) return fail("unexpected answer");
  const [app, ...rest] = args.positional;
  if (app === undefined) {
    if (json) out.line(JSON.stringify(listed.value));
    else if (listed.value.length === 0) out.line("No databases you may read.");
    else for (const l of listed.value) out.line(inert(l.label.replaceAll(" · ", " ")));
    return EXIT.ok;
  }
  // `[env] [sql]`: a lone word that names an environment is the env; anything else is SQL.
  const env = rest[0] !== undefined && ENV.test(rest[0]) ? rest.shift() : undefined;
  const sql = rest.join(" ").trim();
  if (sql === "" && rest.length > 0) return fail("empty SQL", EXIT.usage);
  const chosen = pick(listed.value, app, env, args.value("file"));
  if (typeof chosen === "string") return fail(chosen, EXIT.usage);
  const table = args.value("table");
  if (table !== undefined && sql !== "") return fail("--table and SQL together: pick one", EXIT.usage);
  const rawPage = args.value("page");
  if (args.flag("page") && (rawPage === undefined || !/^\d{1,4}$/.test(rawPage))) return fail("--page is a whole number, 0 or more", EXIT.usage);
  const answer = await api.tool("data", {
    source: chosen.source,
    ...(sql !== "" ? { sql } : table !== undefined ? { table } : {}),
    ...(rawPage !== undefined ? { page: Number(rawPage) } : {}),
  });
  if (!answer.ok) return fail(answer.error.message);
  const v = answer.value as { columns?: string[]; rows?: Cell[][]; truncated?: boolean };
  if (Array.isArray(answer.value)) {
    const tables = answer.value as { name: string; rows: number }[];
    if (json) out.line(JSON.stringify(tables));
    else if (tables.length === 0) out.line("No tables.");
    else out.table([{ header: "TABLE" }, { header: "ROWS", align: "right" }], tables.map((t) => [cell(t.name), cell(String(t.rows))]));
    return EXIT.ok;
  }
  if (!Array.isArray(v.columns) || !Array.isArray(v.rows)) return fail("unexpected answer");
  show(out, v.columns, v.rows, json);
  if (v.truncated === true) out.err("forge data: the answer was cut at the forge's cap");
  return EXIT.ok;
}
export const command: Command = {
  name: "data",
  usage: { synopsis: "forge data [app] [env] [sql]", flags: "[--table name] [--file x.db] [--page n] [--json]" },
  run: (out, args) => data(out, args),
};
@@ -21,6 +21,7 @@
import { command as tell } from "./tell.ts";
import { command as talk } from "./talk.ts";
import { command as newApp } from "./new.ts";
import { command as ship } from "./ship.ts";
import { command as data } from "./data.ts";
import type { Command } from "./types.ts";
export const commands: readonly Command[] = [
@@ -43,4 +44,5 @@
export const commands: readonly Command[] = [
  talk,
  newApp,
  ship,
  data,
];
@@ -36,7 +36,7 @@
export { EXIT };
/** Every command by name, built once from `commands/index.ts`. */
const TABLE = new Map(commands.map((c) => [c.name, c]));
const VALUE_FLAGS = ["token", "interval", "root", "url", "limit", "repo", "kind", "reason", "owner", "variants", "from"];
const VALUE_FLAGS = ["token", "interval", "root", "url", "limit", "repo", "kind", "reason", "owner", "variants", "from", "table", "file", "page"];
export async function main(
  argv: readonly string[],
@@ -0,0 +1,14 @@
/** A row as the object an editor wants: column → value. Plain data in, plain data out. */
export type Cell = string | number | null;
export function rowObject(columns: readonly string[], row: readonly Cell[]): Record<string, Cell> {
  const out: Record<string, Cell> = {};
  columns.forEach((c, i) => {
    out[c] = row[i] ?? null;
  });
  return out;
}
/** One line of a row, for a list: no newline or control byte can reach the terminal. */
export const cellLine = (v: Cell): string =>
  v === null ? "" : String(v).replace(/[\u0000-\u001f\u007f]+/g, " ");
@@ -19,6 +19,8 @@
export interface Source {
  readonly label: string;
  readonly kind: "forge" | "app";
  readonly path: string;
  /** For an app's file: where it sits, so a tree can group by it. */
  readonly where?: { readonly repo: string; readonly app: string; readonly env: string; readonly file: string };
}
const DB_FILE = /^[\w.-]+\.db$/;
@@ -42,8 +44,8 @@
export function listSources(
    apps.map((a) => a.repoId),
  );
  for (const app of apps) {
    if (!writable.has(app.repoId) || getRepoById(db, app.repoId) === undefined)
      continue;
    const repo = writable.has(app.repoId) ? getRepoById(db, app.repoId) : undefined;
    if (repo === undefined) continue;
    let envs: string[];
    try {
      envs = readdirSync(join(dataDir, "apps", app.id)).filter(isEnvName);
@@ -65,6 +67,7 @@
export function listSources(
          label: `${app.slug} · ${env} · ${file}`,
          kind: "app",
          path: join(dir, file),
          where: { repo: `${repo.ownerName}/${repo.name}`, app: app.slug, env, file },
        });
    }
  }
@@ -0,0 +1,143 @@
/**
 * The forge's data as a file tree: repos → apps → environments → files →
 * tables → rows. Pure: which nodes are open and what to filter by come in,
 * the visible lines go out. Reads happen only for an open file or table.
 */
import { PAGE_SIZE, rows as readRows, tables as readTables, type RowsResult, type TableInfo } from "./browse.ts";
import { rowObject, cellLine, type Cell } from "./shape.ts";
import type { Source } from "./sources.ts";
export type Kind = "repo" | "app" | "env" | "file" | "table" | "row";
export interface Node {
  /** Unique path; a child's key starts with its parent's. */
  readonly key: string;
  readonly kind: Kind;
  readonly depth: number;
  readonly label: string;
  /** The file this node is in or is (not on a repo, app or env). */
  readonly source?: Source;
  readonly table?: string;
  /** A table's row count, for paging; the label is only for display. */
  readonly total?: number;
  /** A row's JSON, masked as every read is. */
  readonly json?: Record<string, Cell>;
}
const SEP = "\u0001";
const join = (parent: string, part: string): string => (parent === "" ? part : parent + SEP + part);
const isUnder = (key: string, parent: string): boolean => key.startsWith(parent + SEP);
/**
 * What was read from the files, kept so a rebuild of the tree reads nothing
 * it has read: each open file's tables once, each open table's page once.
 * Drop it to read afresh.
 */
export interface Reads {
  readonly tables: Map<string, TableInfo[]>;
  readonly pages: Map<string, RowsResult | undefined>;
}
export const newReads = (): Reads => ({ tables: new Map(), pages: new Map() });
/** The pages of a table of `total` rows. */
export const pageCount = (total: number): number => Math.max(1, Math.ceil(total / PAGE_SIZE));
/**
 * Every node that is visible with `open` expanded, in order. `page` is the
 * zero-based page of each open table, by its key. Reads happen only for an
 * open file or table, and once each while `reads` is kept.
 */
export function visible(
  sources: readonly Source[],
  open: ReadonlySet<string>,
  reads: Reads = newReads(),
  page: ReadonlyMap<string, number> = new Map(),
): Node[] {
  const out: Node[] = [];
  const tableNodes = (file: Node, depth: number) => {
    const source = file.source!;
    let list = reads.tables.get(file.key);
    if (list === undefined) {
      try {
        list = readTables(source);
      } catch {
        list = [];
      }
      reads.tables.set(file.key, list);
    }
    for (const t of list) {
      const key = join(file.key, t.name);
      const at = page.get(key) ?? 0;
      const paged = t.rows > PAGE_SIZE ? `  page ${at + 1}/${pageCount(t.rows)}` : "";
      const node: Node = { key, kind: "table", depth, label: `${t.name}  ${t.rows} rows${open.has(key) ? paged : ""}`, source, table: t.name, total: t.rows };
      out.push(node);
      if (!open.has(node.key)) continue;
      const pk = `${key}${SEP}${at}`;
      if (!reads.pages.has(pk)) {
        try {
          reads.pages.set(pk, readRows(source, t.name, { page: at }));
        } catch {
          reads.pages.set(pk, undefined);
        }
      }
      const got = reads.pages.get(pk);
      for (const [i, r] of (got?.rows ?? []).entries())
        out.push({
          key: join(node.key, String(i)),
          kind: "row",
          depth: depth + 1,
          label: r.map(cellLine).join(" | "),
          source,
          table: t.name,
          json: rowObject(got!.columns, r),
        });
    }
  };
  const fileNode = (source: Source, key: string, depth: number, label: string) => {
    const node: Node = { key, kind: "file", depth, label, source };
    out.push(node);
    if (open.has(key)) tableNodes(node, depth + 1);
  };
  for (const s of sources.filter((x) => x.where === undefined)) fileNode(s, join("", `file:${s.id}`), 0, `${s.label}.db`);
  const byRepo = Map.groupBy(
    sources.filter((x) => x.where !== undefined),
    (s) => s.where!.repo,
  );
  for (const [repo, ofRepo] of byRepo) {
    const rk = join("", `repo:${repo}`);
    out.push({ key: rk, kind: "repo", depth: 0, label: repo });
    if (!open.has(rk)) continue;
    for (const [app, ofApp] of Map.groupBy(ofRepo, (s) => s.where!.app)) {
      const ak = join(rk, `app:${app}`);
      out.push({ key: ak, kind: "app", depth: 1, label: app });
      if (!open.has(ak)) continue;
      for (const [env, ofEnv] of Map.groupBy(ofApp, (s) => s.where!.env)) {
        const ek = join(ak, `env:${env}`);
        out.push({ key: ek, kind: "env", depth: 2, label: env });
        if (!open.has(ek)) continue;
        for (const s of ofEnv) fileNode(s, join(ek, `file:${s.id}`), 3, s.where!.file);
      }
    }
  }
  return out;
}
/** Whether a node opens at all (a row is a leaf). */
export const opens = (n: Node): boolean => n.kind !== "row";
/**
 * `text` keeps the lines that contain it (any case) and the lines above
 * them that lead there; an empty `text` keeps everything.
 */
export function filtered(nodes: readonly Node[], text: string): Node[] {
  const want = text.trim().toLowerCase();
  if (want === "") return [...nodes];
  const hits = nodes.filter((n) => n.label.toLowerCase().includes(want));
  return nodes.filter((n) => hits.some((h) => h.key === n.key || isUnder(h.key, n.key)));
}
/** The parent line's key, or undefined at the top. */
export function parentKey(key: string): string | undefined {
  const at = key.lastIndexOf(SEP);
  return at < 0 ? undefined : key.slice(0, at);
}
@@ -1,200 +1,246 @@
/**
 * `/data` in the terminal: the SQLite files the viewer may see, a file's
 * tables, a table's rows 50 a page, secrets masked. The same reads, and the
 * same gate (`maySeeData`, `listSources`), as the web page and MCP `data`.
 * `s` sorts a table by a column (`-name` for descending), `f` filters it
 * (`text`, or `column=text`), `c` clears both; `x` on a file's tables runs one
 * read-only SELECT, on the page's per-person budget (`sqlWindow`).
 * `/data` in the terminal, as a file tree: repos → apps → environments →
 * files → tables → rows, over the same reads and the same gate
 * (`maySeeData`, `listSources`) as the web page and the MCP `data` tool.
 *
 * Keys: j/k move, l or Enter opens, h closes (or goes up), `/` filters the
 * lines shown, `:` asks the file under the cursor a read-only question (the
 * same SELECT-only caps as the tool), `y` yanks a row as JSON. Secrets stay
 * masked: rows come from the masked reads.
 */
import { PAGE_SIZE, rows, tables, type RowsOptions } from "../../data/browse.ts";
import { query } from "../../data/query.ts";
import { listSources, maySeeData, type Source } from "../../data/sources.ts";
import { query, type QueryResult } from "../../data/query.ts";
import { cellLine, rowObject, type Cell } from "../../data/shape.ts";
import { listSources, maySeeData } from "../../data/sources.ts";
import { sqlWindow } from "../../data/sql_window.ts";
import { PAGE_SIZE } from "../../data/browse.ts";
import { filtered, newReads, opens, pageCount, parentKey, visible, type Node } from "../../data/tree.ts";
import type { Ctx, Screen } from "../app/app.ts";
import { binding } from "../app/keys.ts";
import type { KeyEvent } from "../term/input.ts";
import type { Session } from "../session.ts";
import { style } from "../term/style.ts";
import { truncate } from "../term/width.ts";
import { later, promptScreen } from "./common.ts";
/** A list of rows to move through; `open` is what Enter does on one. */
function listScreen(
  ctx: Ctx,
  title: string,
  intro: string,
  items: () => readonly string[],
  open: (index: number) => void,
  extra?: (key: string) => boolean,
  keys: ReturnType<typeof binding>[] = [],
): Screen {
/** The longest SQL the prompt takes, and the longest filter. */
export const SQL_MAX = 4000;
export const FILTER_MAX = 200;
/** A one-line editor: what a prompt types into, cut at `max` characters however it arrives. */
export function typing(max: number, initial = "") {
  const cap = (t: string) => [...t].slice(0, max).join("");
  let text = cap(initial);
  return {
    get text() {
      return text;
    },
    /** True when the key was text (or an edit) and is spent. */
    key(e: KeyEvent): boolean {
      if (e.ctrl || e.alt) return false;
      if (e.key === "backspace") text = [...text].slice(0, -1).join("");
      else if (e.key === "space") text = cap(text + " ");
      else if ([...e.key].length === 1) text = cap(text + e.key);
      else return false;
      return true;
    },
    paste(t: string) {
      text = cap(text + t.replace(/\s+/g, " "));
    },
  };
}
/** The lines of a SQL answer; `y` yanks the highlighted row. */
function resultScreen(ctx: Ctx, sql: string, r: Extract<QueryResult, { ok: true }>): Screen {
  let at = 0;
  return {
    title,
    keys: [binding(["j", "k"], "move"), binding(["enter"], "open"), ...keys, binding(["esc"], "back")],
    title: "Result",
    keys: [binding(["j", "k"], "move"), binding("y", "yank row as JSON"), binding("esc", "back")],
    render(area, s) {
      const c = ctx.theme.c;
      s.text(area.x + 1, area.y, truncate(intro, area.w - 2), style(c.mutedFg, c.bg), area.x + area.w);
      const list = items();
      if (list.length === 0) s.text(area.x + 1, area.y + 2, "Nothing here yet.", style(c.mutedFg, c.bg), area.x + area.w);
      const h = Math.max(1, area.h - 2);
      const from = Math.max(0, Math.min(at - h + 1, list.length - h));
      list.slice(from, from + h).forEach((line, i) => {
      const note = `${r.rows.length} rows${r.truncated ? " (cut)" : ""} · ${sql}`;
      s.text(area.x + 1, area.y, truncate(note, area.w - 2), style(c.mutedFg, c.bg), area.x + area.w);
      s.text(area.x + 1, area.y + 1, truncate(`  ${r.columns.join(" | ")}`, area.w - 2), style(c.mutedFg, c.bg), area.x + area.w);
      const h = Math.max(1, area.h - 3);
      const from = Math.max(0, Math.min(at - h + 1, r.rows.length - h));
      r.rows.slice(from, from + h).forEach((row, i) => {
        const on = from + i === at;
        s.text(area.x + 1, area.y + 2 + i, truncate(`${on ? "> " : "  "}${line}`, area.w - 2), on ? style(c.accent, c.bg) : style(c.fg, c.bg), area.x + area.w);
        s.text(area.x + 1, area.y + 2 + i, truncate(`${on ? "> " : "  "}${row.map(cellLine).join(" | ")}`, area.w - 2), style(on ? c.accent : c.fg, c.bg), area.x + area.w);
      });
    },
    key(e) {
      if (e.ctrl || e.alt) return false;
      const n = items().length;
      if (e.key === "esc" || e.key === "q") ctx.pop();
      else if (e.key === "j" || e.key === "down") at = Math.min(Math.max(0, n - 1), at + 1);
      else if (e.key === "j" || e.key === "down") at = Math.min(Math.max(0, r.rows.length - 1), at + 1);
      else if (e.key === "k" || e.key === "up") at = Math.max(0, at - 1);
      else if (e.key === "enter") {
        if (n > 0) open(at);
      } else return extra?.(e.key) ?? false;
      return true;
    },
  };
}
const cellText = (v: string | number | null): string => (v === null ? "" : String(v).replace(/[\r\n\t]+/g, " ").replace(/[\u0000-\u001f\u007f]/g, " "));
/** Splits `-name` / `name` into a sort; `undefined` for nothing. */
const parseSort = (text: string): RowsOptions["order"] | undefined => {
  const t = text.trim();
  if (t === "") return undefined;
  return t.startsWith("-") ? { column: t.slice(1), dir: "desc" } : { column: t, dir: "asc" };
};
/** `text` or `column=text`; an empty string is no filter. */
const parseFilter = (text: string, columns: readonly string[]): RowsOptions["filter"] | undefined => {
  const eq = text.indexOf("=");
  const head = eq > 0 ? text.slice(0, eq).trim() : "";
  if (head !== "" && columns.includes(head)) return { column: head, text: text.slice(eq + 1) };
  return text === "" ? undefined : { text };
};
function rowsScreen(ctx: Ctx, source: Source, table: string): Screen {
  let page = 0;
  let order: RowsOptions["order"] | undefined;
  let filter: RowsOptions["filter"] | undefined;
  let note = "";
  const read = () => {
    const wanted = { page, ...(order ? { order } : {}), ...(filter ? { filter } : {}) };
    const r = rows(source, table, wanted);
    if (r || (!order && !filter)) return r;
    // An unknown or sealed column cannot be sorted or searched: show the table, say so.
    note = " · that column cannot be sorted or searched";
    return rows(source, table, { page });
  };
  const screen: Screen = listScreen(
    ctx,
    `${table} · ${source.label}`,
    "",
    () => {
      note = "";
      const r = read();
      if (!r) return [];
      const how = `${order ? ` · by ${order.column} ${order.dir}` : ""}${filter ? ` · filter ${filter.column ? `${filter.column}=` : ""}${filter.text}` : ""}`;
      return [
        `${r.total} rows, page ${r.page + 1}${how}${note} · ${r.columns.join(" | ")}`,
        ...r.rows.map((row) => row.map(cellText).join(" | ")),
      ];
    },
    () => undefined,
    (key) => {
      const r = read();
      if (!r) return false;
      if (key === "n" && (r.page + 1) * PAGE_SIZE < r.total) page = r.page + 1;
      else if (key === "p" && r.page > 0) page = r.page - 1;
      else if (key === "c") {
        order = undefined;
        filter = undefined;
        page = 0;
      } else if (key === "s" || key === "f") {
        const sorting = key === "s";
        ctx.push(
          promptScreen(ctx, screen, {
            title: sorting ? "Sort by" : "Filter",
            label: sorting ? "Column" : "Text",
            placeholder: sorting ? "name, or -name for descending" : "text, or column=text",
            onSubmit: (v) => {
              if (sorting) order = parseSort(v);
              else filter = parseFilter(v.trim().slice(0, 200), r.columns);
              page = 0;
              return undefined;
            },
          }),
        );
      else if (e.key === "y") {
        const row = r.rows[at];
        if (!row) return true;
        ctx.copy(JSON.stringify(rowObject(r.columns, row as readonly Cell[])));
        ctx.toast("Row sent to your clipboard as JSON.");
      } else return false;
      return true;
    },
    [binding(["n", "p"], "next / previous page"), binding(["s", "f", "c"], "sort / filter / clear")],
  );
  return screen;
}
/** One SELECT's rows as lines, or the reason it was refused. */
async function sqlLines(source: Source, sql: string): Promise<string[]> {
  const t0 = performance.now();
  const r = await query(source, sql);
  const ms = Math.max(1, Math.round(performance.now() - t0));
  if (!r.ok) return [`${r.message} · ${ms} ms`];
  return [
    `${r.rows.length} rows${r.truncated ? " (cut)" : ""} · ${ms} ms · ${r.columns.join(" | ")}`,
    ...r.rows.map((row) => row.map(cellText).join(" | ")),
  ];
}
function tablesScreen(ctx: Ctx, session: Session, source: Source): Screen {
  const list = tables(source);
  const screen: Screen = listScreen(
    ctx,
    source.label,
    "Tables; secrets are masked.",
    () => list.map((t) => `${t.name}  ${t.rows} rows`),
    (i) => {
      const t = list[i];
      if (t) ctx.push(rowsScreen(ctx, source, t.name));
    },
    (key) => {
      if (key !== "x") return false;
      ctx.push(
        promptScreen(ctx, screen, {
          title: "SQL",
          label: "SELECT",
          placeholder: "SELECT * FROM … (read-only, one statement)",
          onSubmit: (sql) => {
            const text = sql.trim().slice(0, 4000);
            if (text === "") return "Type one SELECT.";
            const wait = session.user ? sqlWindow(session.app, session.user.id) : 1;
            if (wait !== undefined) return `Too many queries; try again in ${wait} s.`;
            return sqlLines(source, text).then((lines) => {
              void later(ctx, () => listScreen(ctx, "SQL", "", () => lines, () => undefined));
            });
          },
        }),
      );
      return true;
    },
    [binding(["x"], "run SQL")],
  );
  return screen;
  };
}
export function dataScreen(session: Session, ctx: Ctx): Screen {
  const sources = () => listSources(session.app.db, session.app.config.dataDir, session.user);
  return listScreen(
    ctx,
    "Data",
    "The SQLite files you may read.",
    () => sources().map((s) => s.label),
    (i) => {
      const s = sources()[i];
      if (s) ctx.push(tablesScreen(ctx, session, s));
  const open = new Set<string>();
  let at = 0;
  let filter = "";
  let mode: "filter" | "sql" | undefined;
  let line = typing(FILTER_MAX);
  // Built once and rebuilt only when `open`, a page, the filter or a reload changes it.
  const pages = new Map<string, number>();
  let reads = newReads();
  let files: ReturnType<typeof listSources> | undefined;
  let built: Node[] | undefined;
  let shown: Node[] | undefined;
  const dirty = (all = false) => {
    shown = undefined;
    if (all) built = undefined;
  };
  const lines = (): Node[] => {
    if (shown) return shown;
    files ??= listSources(session.app.db, session.app.config.dataDir, session.user);
    built ??= visible(files, open, reads, pages);
    return (shown = filtered(built, filter));
  };
  const reload = () => {
    files = undefined;
    reads = newReads();
    dirty(true);
  };
  /** The table key a node belongs to, for paging. */
  const tableKey = (n: Node) => (n.kind === "table" ? n.key : n.kind === "row" ? parentKey(n.key) : undefined);
  function turn(n: Node | undefined, by: number) {
    const tk = n && tableKey(n);
    if (tk === undefined) return;
    const total = built?.find((x) => x.key === tk)?.total ?? 0;
    const next = Math.max(0, Math.min(pageCount(total) - 1, (pages.get(tk) ?? 0) + by));
    if (next === (pages.get(tk) ?? 0)) return ctx.toast(by > 0 ? "That is the last page." : "That is the first page.");
    pages.set(tk, next);
    dirty(true);
    at = Math.max(0, lines().findIndex((x) => x.key === tk));
  }
  const current = (): Node | undefined => lines()[at];
  const clamp = () => {
    at = Math.max(0, Math.min(at, lines().length - 1));
  };
  function ask(text: string) {
    const sql = text.trim();
    if (sql === "") return ctx.toast("Type one SELECT.", "danger");
    const source = current()?.source;
    if (!source) return ctx.toast("Move onto a file, table or row first: the question goes to that file.", "danger");
    const wait = session.user ? sqlWindow(session.app, session.user.id) : 1;
    if (wait !== undefined) return ctx.toast(`Too many queries; try again in ${wait} s.`, "danger");
    ctx.track(
      query(source, sql).then((r) => {
        if (r.ok) ctx.push(resultScreen(ctx, sql, r));
        else ctx.toast(r.message, "danger");
      }),
    );
  }
  return {
    title: "Data",
    get keys() {
      return mode
        ? [binding("enter", mode === "sql" ? "run" : "keep"), binding("esc", "cancel")]
        : [
            binding(["j", "k"], "move"),
            binding(["h", "l"], "close / open"),
            binding("/", "filter"),
            binding(":", "SQL"),
            binding("y", "yank row as JSON"),
            binding(["n", "p"], `page of ${PAGE_SIZE}`),
            binding("r", "reload"),
            binding("esc", "back"),
          ];
    },
  );
    render(area, s) {
      const c = ctx.theme.c;
      const top = filter === "" ? "The SQLite files you may read; secrets are masked." : `Filter: ${filter}`;
      s.text(area.x + 1, area.y, truncate(top, area.w - 2), style(c.mutedFg, c.bg), area.x + area.w);
      const list = lines();
      if (list.length === 0) s.text(area.x + 1, area.y + 2, filter === "" ? "Nothing here yet." : "No open line matches.", style(c.mutedFg, c.bg), area.x + area.w);
      const h = Math.max(1, area.h - 3);
      const from = Math.max(0, Math.min(at - h + 1, list.length - h));
      list.slice(from, from + h).forEach((n, i) => {
        const on = from + i === at;
        const mark = opens(n) ? (open.has(n.key) ? "v " : "> ") : "  ";
        s.text(area.x + 1, area.y + 2 + i, truncate(`${"  ".repeat(n.depth)}${mark}${n.label}`, area.w - 2), style(on ? c.accent : c.fg, c.bg), area.x + area.w);
      });
      if (mode) {
        s.text(area.x + 1, area.y + area.h - 1, truncate(`${mode === "sql" ? ":" : "/"}${line.text}`, area.w - 2), style(c.fg, c.card), area.x + area.w);
      }
    },
    key(e) {
      if (mode) {
        if (e.key === "esc") {
          if (mode === "filter") (filter = ""), dirty();
          mode = undefined;
        } else if (e.key === "enter") {
          const done = mode;
          mode = undefined;
          if (done === "filter") {
            filter = line.text;
            dirty();
            at = 0;
          } else ask(line.text);
        } else if (!line.key(e)) return true;
        else if (mode === "filter") {
          filter = line.text;
          dirty();
          at = 0;
        }
        return true;
      }
      if (e.ctrl || e.alt) return false;
      const n = current();
      if (e.key === "esc" || e.key === "q") {
        if (filter !== "") (filter = ""), dirty();
        else ctx.pop();
      } else if (e.key === "j" || e.key === "down") at = Math.min(Math.max(0, lines().length - 1), at + 1);
      else if (e.key === "k" || e.key === "up") at = Math.max(0, at - 1);
      else if ((e.key === "l" || e.key === "right" || e.key === "enter") && n && opens(n)) (open.add(n.key), dirty(true));
      else if (e.key === "h" || e.key === "left") {
        if (n && open.has(n.key)) (open.delete(n.key), dirty(true));
        else if (n) {
          const up = parentKey(n.key);
          if (up !== undefined) {
            open.delete(up);
            dirty(true);
            at = Math.max(0, lines().findIndex((x) => x.key === up));
          }
        }
      } else if (e.key === "/") {
        mode = "filter";
        line = typing(FILTER_MAX, filter);
      } else if (e.key === ":") {
        mode = "sql";
        line = typing(SQL_MAX, n?.table ? `SELECT * FROM "${n.table.replaceAll('"', '""')}" LIMIT 20` : "");
      } else if (e.key === "n" || e.key === "p") turn(n, e.key === "n" ? 1 : -1);
      else if (e.key === "r") {
        reload();
        ctx.toast("Reloaded.");
      } else if (e.key === "y") {
        if (n?.json) {
          ctx.copy(JSON.stringify(n.json));
          ctx.toast("Row sent to your clipboard as JSON.");
        } else ctx.toast("Move onto a row to yank it.");
      } else return false;
      clamp();
      return true;
    },
    paste(text) {
      if (!mode) return false;
      line.paste(text);
      if (mode === "filter") (filter = line.text), dirty();
      return true;
    },
  };
}
/** Offered to an admin and to an app's writers; a reader and a guest see nothing. */
@@ -204,7 +250,7 @@
export const dataCommand = (session: Session, ctx: Ctx) =>
        {
          id: "data",
          title: "Data",
          hint: "the SQLite files you may read, secrets masked",
          hint: "the SQLite files you may read as a tree; / filters, : asks in SQL, y yanks a row",
          run: () => ctx.push(dataScreen(session, ctx)),
        },
      ]
@@ -0,0 +1,185 @@
/** `forge data`: lists, tables, rows and read-only SQL, from a shell, over the MCP tool. */
import { afterAll, beforeAll, expect, test } from "bun:test";
import { Database } from "bun:sqlite";
import { mkdirSync } from "node:fs";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { envDataDir } from "../src/apps/data.ts";
import { EXIT, main } from "../src/cli/main.ts";
import { pick } from "../src/cli/commands/data.ts";
import { createApp as createAppRecord } from "../src/core/apps.ts";
import { createRepo } from "../src/core/repos.ts";
import { SQL_PER_MINUTE } from "../src/data/sql_window.ts";
import { createToken } from "../src/core/tokens.ts";
import { createUser } from "../src/core/users.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { quietLogs } from "./helpers/globals.ts";
quietLogs();
let dir: string;
let app: App;
let servers: Servers;
const token: Record<string, string> = {};
const env = { url: process.env["FORGE_URL"], token: process.env["FORGE_TOKEN"] };
beforeAll(async () => {
  dir = await mkdtemp(join(tmpdir(), "forge-cli-data-"));
  app = createApp({ dataDir: dir, port: 0, host: "forge.test" });
  servers = await serve(app);
  const ids: Record<string, string> = {};
  for (const name of ["owner1", "alice", "bob"]) {
    const made = await createUser(app.db, { origin: "seed", trusted: true, username: name, email: `${name}@forge.local`, password: "a-good-passphrase", adminIfFirst: name === "owner1" });
    if (!made.ok) throw new Error(made.error);
    ids[name] = made.value.id;
    token[name] = createToken(app.db, made.value.id, "t", "admin").token;
  }
  const repo = await createRepo(app.db, app.reposRoot, { ownerId: ids["alice"]!, name: "notes", visibility: "public" });
  if (!repo.ok) throw new Error(repo.error);
  const rec = createAppRecord(app.db, { repoId: repo.value.id, slug: "notes", access: "public" });
  if (!rec.ok) throw new Error(rec.error);
  const where = envDataDir(dir, rec.value.id, "production");
  mkdirSync(where, { recursive: true });
  const d = new Database(join(where, "app.db"));
  d.exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, api_token TEXT)");
  d.exec("INSERT INTO users VALUES (1, 'ann-visible', 'tok-secret-1')");
  d.exec("CREATE TABLE big (id INTEGER PRIMARY KEY)");
  d.exec("WITH RECURSIVE c(i) AS (SELECT 1 UNION ALL SELECT i + 1 FROM c WHERE i < 60) INSERT INTO big SELECT i FROM c");
  d.close();
  const o = new Database(join(where, "other.db"));
  o.exec("CREATE TABLE extra (v TEXT)");
  o.exec("INSERT INTO extra VALUES ('from-other')");
  o.close();
}, 60_000);
afterAll(async () => {
  servers.stop();
  app.close();
  for (const [k, v] of [["FORGE_URL", env.url], ["FORGE_TOKEN", env.token]] as const)
    if (v === undefined) delete process.env[k];
    else process.env[k] = v;
  await rm(dir, { recursive: true, force: true });
});
async function run(who: string, argv: string[]) {
  process.env["FORGE_URL"] = servers.url;
  process.env["FORGE_TOKEN"] = token[who]!;
  const lines: string[] = [];
  const errs: string[] = [];
  const write = process.stdout.write.bind(process.stdout);
  const werr = process.stderr.write.bind(process.stderr);
  process.stdout.write = ((s: string) => (lines.push(String(s)), true)) as never;
  process.stderr.write = ((s: string) => (errs.push(String(s)), true)) as never;
  try {
    const code = await main(argv);
    return { code, text: lines.join(""), err: errs.join("") };
  } finally {
    process.stdout.write = write;
    process.stderr.write = werr;
  }
}
test("lists the databases a writer may read", async () => {
  const r = await run("alice", ["data"]);
  expect(r.code).toBe(EXIT.ok);
  expect(r.text).toContain("notes production app.db");
  expect((await run("bob", ["data", "--json"])).text.trim()).toBe("[]");
});
test("a table list, then rows with secrets masked", async () => {
  const t = await run("alice", ["data", "notes", "--json"]);
  expect(JSON.parse(t.text)).toEqual([{ name: "big", rows: 60 }, { name: "users", rows: 1 }]);
  const rows = await run("alice", ["data", "notes", "production", "--table", "users"]);
  expect(rows.text).toContain("ann-visible");
  expect(rows.text).not.toContain("tok-secret-1");
});
test("SQL prints JSON with --json, as objects", async () => {
  const r = await run("alice", ["data", "notes", "select id, name from users", "--json"]);
  expect(r.code).toBe(EXIT.ok);
  expect(JSON.parse(r.text)).toEqual([{ id: 1, name: "ann-visible" }]);
});
test("a write is refused, and a reader finds no such app", async () => {
  const w = await run("alice", ["data", "notes", "delete from users"]);
  expect(w.code).toBe(EXIT.failed);
  expect(w.err).toContain("Only SELECT and WITH statements are allowed.");
  const b = await run("bob", ["data", "notes", "select 1"]);
  expect(b.code).toBe(EXIT.usage);
});
test("--file picks another database of the environment; an unknown one is a usage error", async () => {
  const r = await run("alice", ["data", "notes", "--file", "other.db", "--table", "extra"]);
  expect(r.text).toContain("from-other");
  const none = await run("alice", ["data", "notes", "--file", "nope.db"]);
  expect(none.code).toBe(EXIT.usage);
});
test("an env argument names the environment; one that has no files is a usage error", async () => {
  expect((await run("alice", ["data", "notes", "production", "--json"])).code).toBe(EXIT.ok);
  expect((await run("alice", ["data", "notes", "pull-9"])).code).toBe(EXIT.usage);
});
test("--page turns the page; a bad one exits 2 before asking the forge", async () => {
  const one = JSON.parse((await run("alice", ["data", "notes", "--table", "big", "--page", "1", "--json"])).text);
  expect(one.length).toBe(10);
  expect(one[0]).toEqual({ id: 51 });
  for (const bad of [["--page", "x"], ["--page", "-1"], ["--page=-1"], ["--page", "1.5"], ["--page="], ["--page"]]) {
    const r = await run("alice", ["data", "notes", "--table", "big", ...bad]);
    expect(r.code).toBe(EXIT.usage);
    expect(r.err).toContain("--page");
  }
});
test("--table with SQL is refused, not half-obeyed", async () => {
  const r = await run("alice", ["data", "notes", "select 1", "--table", "users"]);
  expect(r.code).toBe(EXIT.usage);
  expect(r.err).toContain("--table");
});
test("an unknown table is the forge's words, exit 1", async () => {
  const r = await run("alice", ["data", "notes", "--table", "nope"]);
  expect(r.code).toBe(EXIT.failed);
  expect(r.err).toContain("no such table");
});
test("SQL from the shell keeps the per-person budget: the 21st run in a minute is refused, exit 1", async () => {
  // owner1 runs no other SQL in this file, so its window starts empty.
  for (let i = 0; i < SQL_PER_MINUTE; i++) expect((await run("owner1", ["data", "notes", "select 1", "--json"])).code).toBe(EXIT.ok);
  const r = await run("owner1", ["data", "notes", "select 1"]);
  expect(r.code).toBe(EXIT.failed);
  expect(r.err).toMatch(/try again in \d+ s/);
  // Browsing a table is not SQL and stays open.
  expect((await run("owner1", ["data", "notes", "--table", "users"])).code).toBe(EXIT.ok);
});
test("not signed in exits 3", async () => {
  process.env["FORGE_URL"] = "";
  process.env["FORGE_TOKEN"] = "";
  const prev = process.env["FORGE_CONFIG_DIR"];
  process.env["FORGE_CONFIG_DIR"] = join(dir, "no-config");
  const errs: string[] = [];
  const werr = process.stderr.write.bind(process.stderr);
  process.stderr.write = ((x: string) => (errs.push(String(x)), true)) as never;
  try {
    expect(await main(["data"])).toBe(EXIT.notConfigured);
  } finally {
    process.stderr.write = werr;
    if (prev === undefined) delete process.env["FORGE_CONFIG_DIR"];
    else process.env["FORGE_CONFIG_DIR"] = prev;
  }
  expect(errs.join("")).toContain("forge login");
});
test("pick: several matches are named, not guessed", () => {
  const list = [
    { source: "1", label: "notes · production · a.db" },
    { source: "2", label: "notes · production · b.db" },
  ];
  const r = pick(list, "notes", undefined, undefined);
  expect(typeof r).toBe("string");
  expect(r).toContain("several databases match");
  expect(pick(list, "notes", undefined, "b.db")).toEqual(list[1]!);
});
@@ -0,0 +1,119 @@
/** The data tree: grouping, filter, parent, paging, one read per open node, an unreadable file. */
import { afterAll, beforeAll, expect, test } from "bun:test";
import { Database } from "bun:sqlite";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { copyFileSync, rmSync } from "node:fs";
import type { Source } from "../src/data/sources.ts";
import { filtered, newReads, opens, parentKey, visible } from "../src/data/tree.ts";
let dir: string;
let good: Source;
let bad: Source;
let forgeDb: Source;
beforeAll(async () => {
  dir = await mkdtemp(join(tmpdir(), "forge-tree-"));
  const p = join(dir, "app.db");
  const d = new Database(p);
  d.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, note TEXT)");
  d.exec("WITH RECURSIVE c(i) AS (SELECT 1 UNION ALL SELECT i + 1 FROM c WHERE i < 60) INSERT INTO t SELECT i, 'n' || i FROM c");
  d.exec("CREATE TABLE ctl (v TEXT)");
  d.run("INSERT INTO ctl VALUES (?)", ["a\u001b[31mb\u0007\nc"]);
  d.close();
  const where = { repo: "alice/notes", app: "notes", env: "production", file: "app.db" };
  good = { id: "g", label: "notes · production · app.db", kind: "app", path: p, where };
  bad = { id: "b", label: "notes · production · bad.db", kind: "app", path: join(dir, "bad.db"), where: { ...where, file: "bad.db" } };
  await Bun.write(bad.path, "this is not a database, only text".repeat(40));
  forgeDb = { id: "forge", label: "forge", kind: "forge", path: p };
});
afterAll(() => rm(dir, { recursive: true, force: true }));
const all = (open: string[]) => visible([good, bad, forgeDb], new Set(open));
test("files outside any app come first, then repos group apps, envs and files", () => {
  const nodes = visible([good, bad, forgeDb], new Set());
  expect(nodes.map((n) => [n.kind, n.label])).toEqual([["file", "forge.db"], ["repo", "alice/notes"]]);
  const repo = nodes[1]!;
  const deeper = visible([good, bad, forgeDb], new Set([repo.key]));
  expect(deeper.map((n) => n.kind)).toEqual(["file", "repo", "app"]);
  expect(opens(deeper[2]!)).toBe(true);
});
test("parentKey names the line above, undefined at the top", () => {
  const nodes = all([]);
  const repo = nodes.find((n) => n.kind === "repo")!;
  const app = visible([good], new Set([repo.key])).find((n) => n.kind === "app")!;
  expect(parentKey(app.key)).toBe(repo.key);
  expect(parentKey(repo.key)).toBeUndefined();
});
test("filtered keeps hits and the lines that lead to them; empty keeps all", () => {
  const repo = all([]).find((n) => n.kind === "repo")!;
  const open = new Set<string>([repo.key]);
  let nodes = visible([good], open);
  const app = nodes.find((n) => n.kind === "app")!;
  open.add(app.key);
  nodes = visible([good], open);
  expect(filtered(nodes, "").length).toBe(nodes.length);
  expect(filtered(nodes, "  ").length).toBe(nodes.length);
  expect(filtered(nodes, "PRODUCTION").map((n) => n.kind)).toEqual(["repo", "app", "env"]);
  expect(filtered(nodes, "zzz")).toEqual([]);
});
function openAll(sources: Source[], extra: (k: string) => boolean = () => false) {
  const open = new Set<string>();
  const reads = newReads();
  const pages = new Map<string, number>();
  for (let i = 0; i < 6; i++)
    for (const n of visible(sources, open, reads, pages)) if (n.kind !== "row" && (n.kind !== "table" || extra(n.label))) open.add(n.key);
  return { open, reads, pages };
}
test("an unreadable file shows as a file with no tables, and the rest still shows", () => {
  const { open } = openAll([good, bad]);
  const nodes = visible([good, bad], open);
  const labels = nodes.map((n) => n.label);
  expect(labels).toContain("bad.db");
  expect(labels).toContain("app.db");
  const at = nodes.findIndex((n) => n.label === "bad.db");
  expect(nodes[at + 1]?.kind).not.toBe("table");
});
test("a table pages 50 rows at a time, and a row carries its JSON", () => {
  const { open, reads, pages } = openAll([good], (l) => l.startsWith("t "));
  const rows = (page: number) => {
    const t = visible([good], open, reads, pages).find((n) => n.kind === "table" && n.table === "t")!;
    pages.set(t.key, page);
    return visible([good], open, reads, pages).filter((n) => n.kind === "row" && n.table === "t");
  };
  expect(rows(0).length).toBe(50);
  expect(rows(1).length).toBe(10);
  expect(rows(1)[0]!.json).toEqual({ id: 51, note: "n51" });
});
test("a rebuild reads nothing again while the reads are kept", () => {
  const copy = join(dir, "gone.db");
  copyFileSync(good.path, copy);
  const src: Source = { ...good, id: "x", path: copy };
  const { open, reads, pages } = openAll([src], (l) => l.startsWith("t "));
  const first = visible([src], open, reads, pages).map((n) => n.label);
  rmSync(copy);
  expect(visible([src], open, reads, pages).map((n) => n.label)).toEqual(first);
  expect(visible([src], open, newReads(), pages).filter((n) => n.kind === "table")).toEqual([]);
});
test("a table carries its row count as data, not only in its label", () => {
  const { open } = openAll([good], () => false);
  const t = visible([good], open).find((n) => n.kind === "table" && n.table === "t")!;
  expect(typeof t.total).toBe("number");
  expect(t.label).toContain(`${t.total} rows`);
});
test("a control byte or newline in a cell never reaches a row's line", () => {
  const { open } = openAll([good], (l) => l.startsWith("ctl"));
  const row = visible([good], open).find((n) => n.kind === "row" && n.table === "ctl")!;
  expect(row.label).toBe("a [31mb c");
  expect(row.label).not.toMatch(/[\u0000-\u001f\u007f]/);
});
@@ -48,7 +48,7 @@
test("a site-admin person is offered the whole roster", () => {
    ["home", "Home", "your repositories"],
    ["explore", "Explore", "on the web"],
    ["packs", "Forge packs", "premade forges to deploy, and how to help build their apps"],
    ["data", "Data", "the SQLite files you may read, secrets masked"],
    ["data", "Data", "the SQLite files you may read as a tree; / filters, : asks in SQL, y yanks a row"],
    ["fleet", "Fleet rows", "the rows a fleet query line selects"],
    ["profile", "Open a profile", "username or org"],
    ["repos", "Repositories", "the repositories you may write"],
@@ -165,7 +165,7 @@
test("a site-admin agent is offered the roster without the person-only entries",
    ["home", "Home", "your repositories"],
    ["explore", "Explore", "on the web"],
    ["packs", "Forge packs", "premade forges to deploy, and how to help build their apps"],
    ["data", "Data", "the SQLite files you may read, secrets masked"],
    ["data", "Data", "the SQLite files you may read as a tree; / filters, : asks in SQL, y yanks a row"],
    ["fleet", "Fleet rows", "the rows a fleet query line selects"],
    ["profile", "Open a profile", "username or org"],
    ["repos", "Repositories", "the repositories you may write"],
@@ -1,4 +1,5 @@
/** The terminal's Data screen: gated as the page is, reads the same masked rows. */
import { sqlWindow } from "../src/data/sql_window.ts";
import { afterAll, beforeAll, expect, test } from "bun:test";
import { Database } from "bun:sqlite";
import { mkdirSync } from "node:fs";
@@ -12,9 +13,7 @@
import { createRepo } from "../src/core/repos.ts";
import { createUser, getUserByName } from "../src/core/users.ts";
import { forgeCommands } from "../src/tui/forge.ts";
import { createForgeApp } from "../src/tui/forge.ts";
import { query } from "../src/data/query.ts";
import { listSources } from "../src/data/sources.ts";
import { dataScreen } from "../src/tui/screens/data.ts";
import { dataScreen, FILTER_MAX, SQL_MAX, typing } from "../src/tui/screens/data.ts";
import { headlessTerminal } from "../src/tui/term/terminal.ts";
import { quietLogs } from "./helpers/globals.ts";
import { settleApp } from "./helpers/tui.ts";
@@ -23,8 +22,6 @@
quietLogs();
let dir: string;
let app: App;
let appRecordId = "";
const appIdOf = () => appRecordId;
beforeAll(async () => {
  dir = await mkdtemp(join(tmpdir(), "forge-tui-data-"));
@@ -39,12 +36,13 @@
beforeAll(async () => {
  if (!repo.ok) throw new Error(repo.error);
  const rec = createAppRecord(app.db, { repoId: repo.value.id, slug: "notes", access: "public" });
  if (!rec.ok) throw new Error(rec.error);
  appRecordId = rec.value.id;
  const where = envDataDir(dir, rec.value.id, "production");
  mkdirSync(where, { recursive: true });
  const d = new Database(join(where, "app.db"));
  d.exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, api_token TEXT)");
  d.exec("INSERT INTO users VALUES (1, 'ann-visible', 'tok-secret-1')");
  d.exec("CREATE TABLE zbig (id INTEGER PRIMARY KEY)");
  d.exec("WITH RECURSIVE c(i) AS (SELECT 1 UNION ALL SELECT i + 1 FROM c WHERE i < 60) INSERT INTO zbig SELECT i FROM c");
  d.close();
});
afterAll(async () => {
@@ -72,23 +70,6 @@
test("an admin and an app's writer are offered it; a reader and a guest are not"
  expect(offered()).toBe(false);
});
test("a writer walks from the files to the tables to masked rows", async () => {
  const { app: tui, session } = open("alice");
  tui.start();
  tui.ctx.push(dataScreen(session, tui.ctx));
  await settleApp(tui);
  expect(tui.screen.toText()).toContain("notes · production · app.db");
  tui.dispatch({ type: "key", key: "enter", ctrl: false, alt: false, shift: false });
  await settleApp(tui);
  expect(tui.screen.toText()).toContain("users  1 rows");
  tui.dispatch({ type: "key", key: "enter", ctrl: false, alt: false, shift: false });
  await settleApp(tui);
  const text = tui.screen.toText();
  expect(text).toContain("ann-visible");
  expect(text).not.toContain("tok-secret-1");
  tui.stop?.();
});
test("an admin sees forge.db among the files", async () => {
  const { app: tui, session } = open("owner1");
  tui.start();
@@ -98,60 +79,188 @@
test("an admin sees forge.db among the files", async () => {
  tui.stop?.();
});
const press = async (tui: ReturnType<typeof open>["app"], ...keys: string[]) => {
  for (const key of keys) {
    tui.dispatch({ type: "key", key, ctrl: false, alt: false, shift: false });
const press = (tui: ReturnType<typeof open>["app"], key: string) =>
  tui.dispatch({ type: "key", key, ctrl: false, alt: false, shift: false });
const open_ = async (tui: ReturnType<typeof open>["app"], times: number) => {
  for (let i = 0; i < times; i++) {
    press(tui, "l");
    await settleApp(tui);
    press(tui, "j");
  }
  press(tui, "l");
  await settleApp(tui);
};
const typeText = (tui: ReturnType<typeof open>["app"], text: string) => {
  for (const ch of text) press(tui, ch === " " ? "space" : ch);
};
/** `:` with the prompt's prefill erased, `sql` typed, and enter. */
const askSql = async (tui: ReturnType<typeof open>["app"], sql: string) => {
  press(tui, ":");
  for (let i = 0; i < 80; i++) press(tui, "backspace");
  typeText(tui, sql);
  press(tui, "enter");
  await settleApp(tui);
};
const type = (tui: ReturnType<typeof open>["app"], text: string) => press(tui, ...text.split(""));
test("a writer sorts and filters a table, and runs read-only SQL with secrets masked", async () => {
  const d = new Database(join(envDataDir(dir, appIdOf(), "production"), "app.db"));
  d.exec("INSERT INTO users VALUES (2, 'zed-visible', 'tok-secret-2')");
  d.close();
test("the tree lists a writer's repo, app, environment, file, table, then rows", async () => {
  const { app: tui, session } = open("alice");
  tui.start();
  tui.ctx.push(dataScreen(session, tui.ctx));
  await settleApp(tui);
  await press(tui, "enter");
  await press(tui, "x");
  await type(tui, "SELECT api_token, name FROM users");
  await press(tui, "enter");
  await new Promise((r) => setTimeout(r, 300));
  await settleApp(tui);
  let text = tui.screen.toText();
  expect(text).toContain("zed-visible");
  expect(text).not.toContain("tok-secret");
  await press(tui, "esc", "enter");
  await press(tui, "s");
  await type(tui, "-name");
  await press(tui, "enter");
  text = tui.screen.toText();
  expect(text.indexOf("zed-visible")).toBeLessThan(text.indexOf("ann-visible"));
  await press(tui, "f");
  await type(tui, "name=ann");
  await press(tui, "enter");
  text = tui.screen.toText();
  expect(text).toContain("ann-visible");
  expect(text).not.toContain("zed-visible");
  expect(tui.screen.toText()).toContain("alice/notes");
  await open_(tui, 4);
  const text = tui.screen.toText();
  for (const word of ["alice/notes", "notes", "production", "app.db", "users  1 rows", "ann-visible"]) expect(text).toContain(word);
  expect(text).not.toContain("tok-secret-1");
  tui.stop?.();
});
test("a reader and a guest get no files, so no SQL either", () => {
  for (const who of ["bob", undefined]) {
    const { app: tui, session } = open(who);
    expect(listSources(app.db, dir, session.user)).toEqual([]);
    tui.stop?.();
  }
test("/ filters the lines and h closes", async () => {
  const { app: tui, session } = open("alice");
  tui.start();
  tui.ctx.push(dataScreen(session, tui.ctx));
  await settleApp(tui);
  await open_(tui, 1);
  press(tui, "/");
  typeText(tui, "zzz");
  await settleApp(tui);
  expect(tui.screen.toText()).toContain("No open line matches.");
  press(tui, "esc");
  await settleApp(tui);
  expect(tui.screen.toText()).toContain("production");
  press(tui, "h");
  press(tui, "h");
  await settleApp(tui);
  expect(tui.screen.toText()).not.toContain("production");
  tui.stop?.();
});
test("the forge database is among an admin's files, and SQL on it is masked", async () => {
  const forge = listSources(app.db, dir, getUserByName(app.db, "owner1")!).find((s) => s.kind === "forge")!;
  const r = await query(forge, "SELECT password_hash FROM user");
  expect(r.ok).toBe(true);
  const hash = app.db.query<{ h: string }, []>("SELECT password_hash AS h FROM user LIMIT 1").get()!.h;
  expect(hash.length).toBeGreaterThan(10);
  expect(JSON.stringify(r)).not.toContain(hash);
  expect(JSON.stringify(r)).toContain("••••••");
test(": runs a read-only SELECT and refuses a write; y yanks a row as JSON", async () => {
  const { app: tui, session } = open("alice");
  const copied: string[] = [];
  tui.ctx.copy = (t: string) => void copied.push(t);
  tui.start();
  tui.ctx.push(dataScreen(session, tui.ctx));
  await settleApp(tui);
  await open_(tui, 4);
  await askSql(tui, "DELETE FROM users");
  expect(tui.screen.toText()).toContain("Only SELECT and WITH statements are allowed.");
  await askSql(tui, "SELECT id, name FROM users");
  expect(tui.screen.toText()).toContain("1 | ann-visible");
  press(tui, "y");
  expect(JSON.parse(copied[0]!)).toEqual({ id: 1, name: "ann-visible" });
  tui.stop?.();
});
const fresh = async (who: string) => {
  const { app: tui, session } = open(who);
  const copied: string[] = [];
  tui.ctx.copy = (t: string) => void copied.push(t);
  tui.start();
  tui.ctx.push(dataScreen(session, tui.ctx));
  await settleApp(tui);
  return { tui, copied };
};
test("a reader opening the screen sees no file, not the forge's, not an app's", async () => {
  const { tui } = await fresh("bob");
  const text = tui.screen.toText();
  expect(text).toContain("Nothing here yet.");
  expect(text).not.toContain("alice/notes");
  expect(text).not.toContain("forge.db");
  tui.stop?.();
});
test("h on a closed line goes up to its parent and closes it", async () => {
  const { tui } = await fresh("alice");
  await open_(tui, 3); // file open, cursor on the first table
  expect(tui.screen.toText()).toContain("users  1 rows");
  press(tui, "h"); // table is closed already: up to the file, which closes
  await settleApp(tui);
  const text = tui.screen.toText();
  expect(text).toContain("app.db");
  expect(text).not.toContain("users  1 rows");
  tui.stop?.();
});
test("y on a row in the tree yanks it as JSON, masked; y elsewhere yanks nothing", async () => {
  const { tui, copied } = await fresh("alice");
  await open_(tui, 4);
  press(tui, "y"); // on the table
  expect(copied).toEqual([]);
  press(tui, "j");
  press(tui, "y");
  expect(JSON.parse(copied[0]!)).toEqual({ id: 1, name: "ann-visible", api_token: expect.not.stringContaining("tok-secret") });
  tui.stop?.();
});
test("n and p turn the pages of a table past 50 rows", async () => {
  const { tui } = await fresh("alice");
  await open_(tui, 3);
  press(tui, "j"); // users
  press(tui, "j"); // zbig
  press(tui, "l");
  await settleApp(tui);
  expect(tui.screen.toText()).toContain("zbig  60 rows  page 1/2");
  press(tui, "n");
  await settleApp(tui);
  const text = tui.screen.toText();
  expect(text).toContain("page 2/2");
  expect(text).toContain("51");
  press(tui, "n");
  await settleApp(tui);
  expect(tui.screen.toText()).toContain("That is the last page.");
  press(tui, "p");
  await settleApp(tui);
  expect(tui.screen.toText()).toContain("page 1/2");
  tui.stop?.();
});
test("a control byte in a cell cannot reach the terminal from a result, and y on a result yanks the row", async () => {
  const { tui, copied } = await fresh("alice");
  await open_(tui, 4);
  await askSql(tui, "SELECT char(27) || '[31mred' || char(7) AS v, 2 AS n");
  const text = tui.screen.toText();
  expect(text).toContain("[31mred");
  expect(text).not.toMatch(/[\u0000-\u0008\u000b-\u001f\u007f]/);
  press(tui, "y");
  expect(JSON.parse(copied[0]!)).toEqual({ v: "\u001b[31mred\u0007", n: 2 });
  tui.stop?.();
});
test(": is refused once the person's SQL budget is spent", async () => {
  const { tui, session } = await (async () => {
    const { app: tui, session } = open("alice");
    tui.start();
    tui.ctx.push(dataScreen(session, tui.ctx));
    await settleApp(tui);
    return { tui, session };
  })();
  await open_(tui, 4);
  for (let i = 0; i < 25; i++) sqlWindow(session.app, session.user!.id);
  press(tui, ":");
  press(tui, "enter");
  await settleApp(tui);
  expect(tui.screen.toText()).toContain("Too many queries");
  tui.stop?.();
});
test("an empty SELECT asks for one and runs nothing", async () => {
  const { tui } = await fresh("alice");
  await open_(tui, 4);
  await askSql(tui, "   ");
  expect(tui.screen.toText()).toContain("Type one SELECT.");
  tui.stop?.();
});
test("the prompts cut SQL at 4000 characters and the filter at 200, typed or pasted", () => {
  const sql = typing(SQL_MAX, "x".repeat(SQL_MAX + 10));
  expect(sql.text.length).toBe(SQL_MAX);
  sql.paste("y".repeat(50));
  sql.key({ type: "key", key: "z", ctrl: false, alt: false, shift: false });
  expect(sql.text).toBe("x".repeat(SQL_MAX));
  const filter = typing(FILTER_MAX);
  filter.paste("a".repeat(FILTER_MAX - 1));
  filter.paste("bc");
  expect(filter.text).toBe(`${"a".repeat(FILTER_MAX - 1)}b`);
});
		@@ -474,3 +474,22 @@ Flags: none.
474	474	$ forge talk "what is waiting on me?"
475	475	Two pulls are green and wait for your merge: #12 and #15.
476	476	```
	477
	478	## forge data
	479
	480	The SQLite files you may read, from a shell (so nvim and other editors can use
	481	them). The forge decides what you see (an admin: its own `forge.db`; a writer
	482	of an app: that app's databases per environment) and masks secrets, exactly as
	483	the Data screen and the MCP `data` tool do.
	484
	485	- `forge data` lists the databases.
	486	- `forge data <app> [env]` lists that app's tables (`env` defaults to production).
	487	- `forge data <app> [env] --table name [--page n]` prints 50 rows.
	488	- `forge data <app> [env] "SELECT …"` runs one read-only SELECT (5 s, 1,000 rows); a write is refused with the forge's words and exit 1. SQL is 20 runs a minute per person, shared with the web and terminal; past that it prints "try again in N s" and exits 1.
	489
	490	`--file x.db` picks among several databases of one environment (`app.db` is the default). `--json` prints an array of objects (rows) or of tables. An unknown or unreadable app exits 2; not logged in exits 3.
	491
	492	```console
	493	$ forge data notes "select name from users" --json
	494	[{"name":"ann"}]
	495	```
		@@ -31,6 +31,7 @@ forge open owner/name --web # the page, in a browser
31	31	forge ship 12 # land pull #12 after a y/N, as Merge does
32	32	forge pulls # open pulls of this clone, newest first
33	33	forge runs # the crew's last 10 runs here: state, agent, #N, title, age, cost
	34	forge data notes "select * from users" --json # read an app's SQLite, read-only, secrets masked
34	35	forge asks # what waits on you, most important first
35	36	forge asks --repo owner/name # only that repository's; --json for the API's answer
36	37	forge asks --ship 1 3 # decide by the line numbers just printed: planned, then Apply? [y/N]
		@@ -12,7 +12,9 @@ Views are masked whole when their text mentions a masked column (an alias cannot
12	12
13	13	Limits on work: `query` runs at most 2 workers at once (a third is told it is busy), each with a 128 MB heap cap (`hard_heap_limit`), a 5 s timer, 1,000 rows and about 250 KB of result; every cell is cut to 1,000 characters inside SQLite and a blob shows as its size. `rows()` cuts cells the same way.
14	14
15		Terminal: `src/tui/screens/data.ts` (files → tables → rows, `n`/`p` for pages, `s` sort, `f` filter, `c` clear, `x` read-only SQL), offered by `maySeeData`; the forge's own database is among an admin's files. SQL on either door is 20 runs a minute per person (`src/data/sql_window.ts`); beyond that it says when to retry.
	15	Terminal: `src/tui/screens/data.ts` is a tree (repos → apps → environments → files → tables → first 50 rows; `src/data/tree.ts` builds it), offered by `maySeeData`. Keys: `j`/`k` move, `l`/Enter open, `h` close or go up, `/` filter the open lines, `:` a read-only SQL prompt against the file under the cursor (same caps; a write is refused), `y` yank a row as JSON (OSC 52), `n`/`p` next/previous page of 50 rows on a table or row, `r` read the files afresh. The tree is built once and rebuilt only when a node opens, a page turns or `r` is pressed; the files are read once per open node. Shell: `forge data <app> [env] [sql] [--json]` (docs/CLI.md) calls the MCP tool.
	16
	17	Not done: a filter that reaches into closed lines, SQL on the web page. SQL on any door (web, terminal, `forge data` and the MCP `data` tool) is 20 runs a minute per person (`src/data/sql_window.ts`); beyond that it says when to retry.
16	18
17	19	API and MCP by repository (`data/repo_scope.ts`, `http/api/data.ts`): `GET /api/v1/repos/:o/:n/data` (databases as `{ env, file }`), `…/data/:env/:file/tables`, `…/rows?table=&page=`, `POST …/query {sql}`; MCP `data` with `{ repo, env?, file?, table?, sql? }` answers the same. Only writers of the repository (and admins) see anything; everyone else gets a 404 (an error from the tool). Same masking, read-only SQL and 1,000-row cap as the web; SQL shares the per-person 20 a minute (`sql_window.ts`), and past it the API answers 429 with `retry-after`, the tool an error. `page` is a whole number from 0 to 1000.
18	20
		@@ -187,6 +187,30 @@ export class ForgeApi {
187	187	return ok(parsed as T);
188	188	}
189	189
	190	/**
	191	* One MCP tool call (`POST /mcp`, tools/call): the tool's JSON answer, or
	192	* the forge's words when it refused.
	193	*/
	194	async tool(name: string, args: Record<string, unknown>): Promise<ApiResult<unknown>> {
	195	const got = await this.call<{ result?: { content?: { text?: unknown }[]; isError?: boolean }; error?: { message?: unknown } }>(
	196	"/mcp",
	197	{
	198	method: "POST",
	199	body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
	200	},
	201	);
	202	if (!got.ok) return got;
	203	const text = got.value.result?.content?.[0]?.text;
	204	if (typeof text !== "string")
	205	return err({ code: "bad_response", message: String(got.value.error?.message ?? "unexpected answer"), status: 200 });
	206	if (got.value.result?.isError === true) return err({ code: "tool", message: text, status: 400 });
	207	try {
	208	return ok(JSON.parse(text) as unknown);
	209	} catch {
	210	return err({ code: "bad_response", message: "the answer was not JSON", status: 200 });
	211	}
	212	}
	213
190	214	async whoami(): Promise<ApiResult<Whoami>> {
191	215	const out = await this.call<{ username?: string; displayName?: string }>(
192	216	"/api/v1/user",
		@@ -0,0 +1,108 @@
	1	import { ForgeApi } from "../api.ts";
	2	import { requireConfig } from "../context.ts";
	3	import { EXIT } from "../exit.ts";
	4	import { cell, inert, type Out } from "../out.ts";
	5	import { cellLine, rowObject, type Cell } from "../../data/shape.ts";
	6	import type { Command } from "./types.ts";
	7
	8	interface Listed {
	9	source: string;
	10	label: string;
	11	}
	12
	13	const isList = (v: unknown): v is Listed[] =>
	14	Array.isArray(v) && v.every((x) => typeof x === "object" && x !== null && typeof (x as Listed).source === "string" && typeof (x as Listed).label === "string");
	15
	16	const ENV = /^(production\|pull-[1-9]\d*\|build-[0-9a-f]{7})$/;
	17
	18	/** The file `forge data <app> [env]` means, among those the forge listed; an error message when it is none or many. */
	19	export function pick(list: readonly Listed[], app: string, env: string \| undefined, file: string \| undefined): Listed \| string {
	20	const parts = (l: Listed) => l.label.split(" · ");
	21	const named = list.filter((l) => {
	22	const [slug, e, f] = parts(l);
	23	return slug === app && (env === undefined \|\| e === env) && (file === undefined \|\| f === file);
	24	});
	25	if (named.length === 0) return `no database for ${[app, env, file].filter(Boolean).join(" ")} that you may read`;
	26	const prod = named.filter((l) => parts(l)[1] === "production");
	27	const pool = env === undefined && prod.length > 0 ? prod : named;
	28	const preferred = pool.filter((l) => parts(l)[2] === "app.db");
	29	const chosen = file === undefined && preferred.length > 0 ? preferred : pool;
	30	if (chosen.length === 1) return chosen[0]!;
	31	return `several databases match: ${chosen.map((l) => l.label.replaceAll(" · ", " ")).join(", ")} — name the env, or pass --file`;
	32	}
	33
	34	function show(out: Out, columns: readonly string[], rows: readonly (readonly Cell[])[], json: boolean): void {
	35	if (json) {
	36	out.line(JSON.stringify(rows.map((r) => rowObject(columns, r))));
	37	return;
	38	}
	39	if (rows.length === 0) {
	40	out.line("No rows.");
	41	return;
	42	}
	43	out.table(
	44	columns.map((header) => ({ header, max: 40 })),
	45	rows.map((r) => r.map((v) => cell(cellLine(v)))),
	46	);
	47	}
	48
	49	/**
	50	* `forge data` lists the databases you may read; `forge data <app> [env]`
	51	* its tables; with `--table` a page of rows; with SQL the answer to a
	52	* read-only SELECT. The forge decides what you may see and masks secrets.
	53	*/
	54	async function data(out: Out, args: Parameters<Command["run"]>[1]): Promise<number> {
	55	const loaded = await requireConfig(out);
	56	if (typeof loaded === "number") return loaded;
	57	const json = args.flag("json");
	58	const api = new ForgeApi(loaded.url, loaded.token);
	59	const fail = (m: string, code: number = EXIT.failed): number => (out.err(`forge data: ${inert(m)}`), code);
	60
	61	const listed = await api.tool("data", {});
	62	if (!listed.ok) return fail(listed.error.message, listed.error.status === 401 ? EXIT.notConfigured : EXIT.failed);
	63	if (!isList(listed.value)) return fail("unexpected answer");
	64
	65	const [app, ...rest] = args.positional;
	66	if (app === undefined) {
	67	if (json) out.line(JSON.stringify(listed.value));
	68	else if (listed.value.length === 0) out.line("No databases you may read.");
	69	else for (const l of listed.value) out.line(inert(l.label.replaceAll(" · ", " ")));
	70	return EXIT.ok;
	71	}
	72	// `[env] [sql]`: a lone word that names an environment is the env; anything else is SQL.
	73	const env = rest[0] !== undefined && ENV.test(rest[0]) ? rest.shift() : undefined;
	74	const sql = rest.join(" ").trim();
	75	if (sql === "" && rest.length > 0) return fail("empty SQL", EXIT.usage);
	76
	77	const chosen = pick(listed.value, app, env, args.value("file"));
	78	if (typeof chosen === "string") return fail(chosen, EXIT.usage);
	79
	80	const table = args.value("table");
	81	if (table !== undefined && sql !== "") return fail("--table and SQL together: pick one", EXIT.usage);
	82	const rawPage = args.value("page");
	83	if (args.flag("page") && (rawPage === undefined \|\| !/^\d{1,4}$/.test(rawPage))) return fail("--page is a whole number, 0 or more", EXIT.usage);
	84	const answer = await api.tool("data", {
	85	source: chosen.source,
	86	...(sql !== "" ? { sql } : table !== undefined ? { table } : {}),
	87	...(rawPage !== undefined ? { page: Number(rawPage) } : {}),
	88	});
	89	if (!answer.ok) return fail(answer.error.message);
	90	const v = answer.value as { columns?: string[]; rows?: Cell[][]; truncated?: boolean };
	91	if (Array.isArray(answer.value)) {
	92	const tables = answer.value as { name: string; rows: number }[];
	93	if (json) out.line(JSON.stringify(tables));
	94	else if (tables.length === 0) out.line("No tables.");
	95	else out.table([{ header: "TABLE" }, { header: "ROWS", align: "right" }], tables.map((t) => [cell(t.name), cell(String(t.rows))]));
	96	return EXIT.ok;
	97	}
	98	if (!Array.isArray(v.columns) \|\| !Array.isArray(v.rows)) return fail("unexpected answer");
	99	show(out, v.columns, v.rows, json);
	100	if (v.truncated === true) out.err("forge data: the answer was cut at the forge's cap");
	101	return EXIT.ok;
	102	}
	103
	104	export const command: Command = {
	105	name: "data",
	106	usage: { synopsis: "forge data [app] [env] [sql]", flags: "[--table name] [--file x.db] [--page n] [--json]" },
	107	run: (out, args) => data(out, args),
	108	};
		@@ -21,6 +21,7 @@ import { command as tell } from "./tell.ts";
21	21	import { command as talk } from "./talk.ts";
22	22	import { command as newApp } from "./new.ts";
23	23	import { command as ship } from "./ship.ts";
	24	import { command as data } from "./data.ts";
24	25	import type { Command } from "./types.ts";
25	26
26	27	export const commands: readonly Command[] = [
		@@ -43,4 +44,5 @@ export const commands: readonly Command[] = [
43	44	talk,
44	45	newApp,
45	46	ship,
	47	data,
46	48	];
		@@ -36,7 +36,7 @@ export { EXIT };
36	36	/** Every command by name, built once from `commands/index.ts`. */
37	37	const TABLE = new Map(commands.map((c) => [c.name, c]));
38	38
39		const VALUE_FLAGS = ["token", "interval", "root", "url", "limit", "repo", "kind", "reason", "owner", "variants", "from"];
	39	const VALUE_FLAGS = ["token", "interval", "root", "url", "limit", "repo", "kind", "reason", "owner", "variants", "from", "table", "file", "page"];
40	40
41	41	export async function main(
42	42	argv: readonly string[],
		@@ -0,0 +1,14 @@
	1	/** A row as the object an editor wants: column → value. Plain data in, plain data out. */
	2	export type Cell = string \| number \| null;
	3
	4	export function rowObject(columns: readonly string[], row: readonly Cell[]): Record<string, Cell> {
	5	const out: Record<string, Cell> = {};
	6	columns.forEach((c, i) => {
	7	out[c] = row[i] ?? null;
	8	});
	9	return out;
	10	}
	11
	12	/** One line of a row, for a list: no newline or control byte can reach the terminal. */
	13	export const cellLine = (v: Cell): string =>
	14	v === null ? "" : String(v).replace(/[\u0000-\u001f\u007f]+/g, " ");
		@@ -19,6 +19,8 @@ export interface Source {
19	19	readonly label: string;
20	20	readonly kind: "forge" \| "app";
21	21	readonly path: string;
	22	/** For an app's file: where it sits, so a tree can group by it. */
	23	readonly where?: { readonly repo: string; readonly app: string; readonly env: string; readonly file: string };
22	24	}
23	25
24	26	const DB_FILE = /^[\w.-]+\.db$/;
		@@ -42,8 +44,8 @@ export function listSources(
42	44	apps.map((a) => a.repoId),
43	45	);
44	46	for (const app of apps) {
45		if (!writable.has(app.repoId) \|\| getRepoById(db, app.repoId) === undefined)
46		continue;
	47	const repo = writable.has(app.repoId) ? getRepoById(db, app.repoId) : undefined;
	48	if (repo === undefined) continue;
47	49	let envs: string[];
48	50	try {
49	51	envs = readdirSync(join(dataDir, "apps", app.id)).filter(isEnvName);
		@@ -65,6 +67,7 @@ export function listSources(
65	67	label: `${app.slug} · ${env} · ${file}`,
66	68	kind: "app",
67	69	path: join(dir, file),
	70	where: { repo: `${repo.ownerName}/${repo.name}`, app: app.slug, env, file },
68	71	});
69	72	}
70	73	}
		@@ -0,0 +1,143 @@
	1	/**
	2	* The forge's data as a file tree: repos → apps → environments → files →
	3	* tables → rows. Pure: which nodes are open and what to filter by come in,
	4	* the visible lines go out. Reads happen only for an open file or table.
	5	*/
	6	import { PAGE_SIZE, rows as readRows, tables as readTables, type RowsResult, type TableInfo } from "./browse.ts";
	7	import { rowObject, cellLine, type Cell } from "./shape.ts";
	8	import type { Source } from "./sources.ts";
	9
	10	export type Kind = "repo" \| "app" \| "env" \| "file" \| "table" \| "row";
	11
	12	export interface Node {
	13	/** Unique path; a child's key starts with its parent's. */
	14	readonly key: string;
	15	readonly kind: Kind;
	16	readonly depth: number;
	17	readonly label: string;
	18	/** The file this node is in or is (not on a repo, app or env). */
	19	readonly source?: Source;
	20	readonly table?: string;
	21	/** A table's row count, for paging; the label is only for display. */
	22	readonly total?: number;
	23	/** A row's JSON, masked as every read is. */
	24	readonly json?: Record<string, Cell>;
	25	}
	26
	27	const SEP = "\u0001";
	28	const join = (parent: string, part: string): string => (parent === "" ? part : parent + SEP + part);
	29	const isUnder = (key: string, parent: string): boolean => key.startsWith(parent + SEP);
	30
	31	/**
	32	* What was read from the files, kept so a rebuild of the tree reads nothing
	33	* it has read: each open file's tables once, each open table's page once.
	34	* Drop it to read afresh.
	35	*/
	36	export interface Reads {
	37	readonly tables: Map<string, TableInfo[]>;
	38	readonly pages: Map<string, RowsResult \| undefined>;
	39	}
	40	export const newReads = (): Reads => ({ tables: new Map(), pages: new Map() });
	41
	42	/** The pages of a table of `total` rows. */
	43	export const pageCount = (total: number): number => Math.max(1, Math.ceil(total / PAGE_SIZE));
	44
	45	/**
	46	* Every node that is visible with `open` expanded, in order. `page` is the
	47	* zero-based page of each open table, by its key. Reads happen only for an
	48	* open file or table, and once each while `reads` is kept.
	49	*/
	50	export function visible(
	51	sources: readonly Source[],
	52	open: ReadonlySet<string>,
	53	reads: Reads = newReads(),
	54	page: ReadonlyMap<string, number> = new Map(),
	55	): Node[] {
	56	const out: Node[] = [];
	57	const tableNodes = (file: Node, depth: number) => {
	58	const source = file.source!;
	59	let list = reads.tables.get(file.key);
	60	if (list === undefined) {
	61	try {
	62	list = readTables(source);
	63	} catch {
	64	list = [];
	65	}
	66	reads.tables.set(file.key, list);
	67	}
	68	for (const t of list) {
	69	const key = join(file.key, t.name);
	70	const at = page.get(key) ?? 0;
	71	const paged = t.rows > PAGE_SIZE ? ` page ${at + 1}/${pageCount(t.rows)}` : "";
	72	const node: Node = { key, kind: "table", depth, label: `${t.name} ${t.rows} rows${open.has(key) ? paged : ""}`, source, table: t.name, total: t.rows };
	73	out.push(node);
	74	if (!open.has(node.key)) continue;
	75	const pk = `${key}${SEP}${at}`;
	76	if (!reads.pages.has(pk)) {
	77	try {
	78	reads.pages.set(pk, readRows(source, t.name, { page: at }));
	79	} catch {
	80	reads.pages.set(pk, undefined);
	81	}
	82	}
	83	const got = reads.pages.get(pk);
	84	for (const [i, r] of (got?.rows ?? []).entries())
	85	out.push({
	86	key: join(node.key, String(i)),
	87	kind: "row",
	88	depth: depth + 1,
	89	label: r.map(cellLine).join(" \| "),
	90	source,
	91	table: t.name,
	92	json: rowObject(got!.columns, r),
	93	});
	94	}
	95	};
	96	const fileNode = (source: Source, key: string, depth: number, label: string) => {
	97	const node: Node = { key, kind: "file", depth, label, source };
	98	out.push(node);
	99	if (open.has(key)) tableNodes(node, depth + 1);
	100	};
	101	for (const s of sources.filter((x) => x.where === undefined)) fileNode(s, join("", `file:${s.id}`), 0, `${s.label}.db`);
	102	const byRepo = Map.groupBy(
	103	sources.filter((x) => x.where !== undefined),
	104	(s) => s.where!.repo,
	105	);
	106	for (const [repo, ofRepo] of byRepo) {
	107	const rk = join("", `repo:${repo}`);
	108	out.push({ key: rk, kind: "repo", depth: 0, label: repo });
	109	if (!open.has(rk)) continue;
	110	for (const [app, ofApp] of Map.groupBy(ofRepo, (s) => s.where!.app)) {
	111	const ak = join(rk, `app:${app}`);
	112	out.push({ key: ak, kind: "app", depth: 1, label: app });
	113	if (!open.has(ak)) continue;
	114	for (const [env, ofEnv] of Map.groupBy(ofApp, (s) => s.where!.env)) {
	115	const ek = join(ak, `env:${env}`);
	116	out.push({ key: ek, kind: "env", depth: 2, label: env });
	117	if (!open.has(ek)) continue;
	118	for (const s of ofEnv) fileNode(s, join(ek, `file:${s.id}`), 3, s.where!.file);
	119	}
	120	}
	121	}
	122	return out;
	123	}
	124
	125	/** Whether a node opens at all (a row is a leaf). */
	126	export const opens = (n: Node): boolean => n.kind !== "row";
	127
	128	/**
	129	* `text` keeps the lines that contain it (any case) and the lines above
	130	* them that lead there; an empty `text` keeps everything.
	131	*/
	132	export function filtered(nodes: readonly Node[], text: string): Node[] {
	133	const want = text.trim().toLowerCase();
	134	if (want === "") return [...nodes];
	135	const hits = nodes.filter((n) => n.label.toLowerCase().includes(want));
	136	return nodes.filter((n) => hits.some((h) => h.key === n.key \|\| isUnder(h.key, n.key)));
	137	}
	138
	139	/** The parent line's key, or undefined at the top. */
	140	export function parentKey(key: string): string \| undefined {
	141	const at = key.lastIndexOf(SEP);
	142	return at < 0 ? undefined : key.slice(0, at);
	143	}