@dylanpiercey/work 0.0.223 → 0.1.0

package/scripts/migrate.mjs

@@ -1,682 +0,0 @@
-#!/usr/bin/env node
-// migrate.mjs — one-shot cleanups for changes between versions, run by
-// `work setup` and `work migrate` (update.sh) so the runtime stays free of
-// legacy handling. The machine repairs run every time; the database's
-// sweeps run once, while it is below schema version 1 (`PRAGMA
-// user_version`), which this script then stamps — the baseline 0.1
-// upgrades from. `npx @dylanpiercey/work@<this version> migrate` is how a
-// later version brings an older database up to it.
-import crypto from "node:crypto";
-import { execFileSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { dialHost } from "../lib/setup/listen.mjs";
-
-const dataDir =
-  process.env.WORK_DATA_DIR ||
-  path.join(
-    process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share"),
-    "work",
-  );
-const dbPath = path.join(dataDir, "work.db");
-
-// Machine repairs that need no db come first: a fresh install, or one whose
-// data dir this environment does not name, stops at the check below.
-
-// `gh auth setup-git` bakes the absolute path of the gh binary into
-// ~/.gitconfig, and git runs that string literally rather than looking gh up
-// on PATH. Where gh came from a version manager that path dies on the next gh
-// upgrade, and every https push fails with "could not read Username" — a
-// break with no visible cause, since `gh` itself still works. Repoint any
-// helper naming a gh that no longer exists at the launcher on PATH.
-{
-  const versioned = /\/(installs|Cellar|versions|toolchains)\//;
-  const git = (args) => execFileSync("git", args, { encoding: "utf8" }).trim();
-  try {
-    let gh = "";
-    try {
-      // Quietly: with no gh there is nothing to repair, and this runs on
-      // every setup, fresh installs included.
-      gh = execFileSync("which", ["gh"], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }).trim();
-    } catch {}
-    if (gh && !versioned.test(gh)) {
-      let lines = [];
-      try {
-        lines = git([
-          "config",
-          "--global",
-          "--get-regexp",
-          String.raw`^credential\..*\.helper$`,
-        ])
-          .split("\n")
-          .filter(Boolean);
-      } catch {} // no such entries — nothing to repair
-      let fixed = 0;
-      for (const line of lines) {
-        const sp = line.indexOf(" ");
-        const [key, value] = [line.slice(0, sp), line.slice(sp + 1)];
-        const bin = /^!(\S+) auth git-credential$/.exec(value)?.[1];
-        if (!bin || bin === gh || fs.existsSync(bin)) continue;
-        git([
-          "config",
-          "--global",
-          "--replace-all",
-          key,
-          `!${gh} auth git-credential`,
-          "auth git-credential",
-        ]);
-        fixed++;
-      }
-      if (fixed)
-        console.log(
-          `==> migrate: repaired ${fixed} stale gh credential helper(s)`,
-        );
-    }
-  } catch {}
-}
-
-// Grok's hook registry ($GROK_HOME/hooks-paths) names work's hook file by
-// absolute path. A line left by a data dir since moved or removed (a
-// scratch server's temp dir, an uninstall) names nothing, and Grok's
-// sandbox refuses to start while one does. The app drops them as it
-// registers; this reaches machines that stopped launching Grok. Keep in
-// sync with registerHooks in src/agents/grok/index.ts.
-{
-  try {
-    const registry = path.join(
-      process.env.GROK_HOME || path.join(os.homedir(), ".grok"),
-      "hooks-paths",
-    );
-    const current = fs.readFileSync(registry, "utf8");
-    const lines = current.split("\n");
-    const kept = lines.filter((line) => {
-      const target = line.trim();
-      return !target.endsWith("/grok-hooks.json") || fs.existsSync(target);
-    });
-    if (kept.length !== lines.length) {
-      fs.writeFileSync(registry, kept.join("\n"));
-      console.log(
-        `==> migrate: dropped ${lines.length - kept.length} stale Grok hook registry line(s)`,
-      );
-    }
-  } catch {} // no registry — nothing to clean
-}
-
-if (!fs.existsSync(dbPath)) process.exit(0);
-
-/** A write connection that waits out the running server's transactions, as
- * db.ts does: setup and update.sh migrate while the old server still runs,
- * and a lock thrown here would end the script before every later sweep. */
-function writer() {
-  const wr = new DatabaseSync(dbPath);
-  wr.exec("PRAGMA busy_timeout = 5000");
-  return wr;
-}
-
-// Version 1 is exactly the schema below: every table the app keeps, with
-// the columns later releases added, and nothing it retired. A database at
-// it has had the sweeps; one below it gets them now, then the stamp.
-{
-  const wr = writer();
-  try {
-    if (wr.prepare("PRAGMA user_version").get().user_version >= 1)
-      process.exit(0);
-    // Keep in sync with src/server/db.ts: this is the schema a version-1
-    // database has, whichever of the two brought it there.
-    wr.exec(`
-      CREATE TABLE IF NOT EXISTS workspaces (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        path TEXT NOT NULL UNIQUE,
-        branch TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'archived')),
-        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-      );
-      CREATE TABLE IF NOT EXISTS repos (
-        workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
-        full_name TEXT NOT NULL,
-        worktree TEXT NOT NULL,
-        base_branch TEXT NOT NULL,
-        default_branch TEXT NOT NULL,
-        PRIMARY KEY (workspace_id, full_name)
-      );
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        workspace_id TEXT REFERENCES workspaces(id) ON DELETE SET NULL,
-        agent TEXT NOT NULL,
-        title TEXT,
-        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-      );
-      CREATE TABLE IF NOT EXISTS settings (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS review_comments (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
-        worktree TEXT NOT NULL,
-        path TEXT NOT NULL,
-        side TEXT NOT NULL DEFAULT 'additions',
-        line_start INTEGER NOT NULL,
-        line_end INTEGER NOT NULL,
-        text TEXT NOT NULL,
-        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-      );
-      CREATE TABLE IF NOT EXISTS push_subscriptions (
-        endpoint TEXT PRIMARY KEY,
-        data TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS dismissed_prs (
-        workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
-        full_name TEXT NOT NULL,
-        number INTEGER NOT NULL,
-        PRIMARY KEY (workspace_id, full_name, number)
-      );
-      CREATE TABLE IF NOT EXISTS review_marks (
-        workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
-        worktree TEXT NOT NULL,
-        branch TEXT NOT NULL,
-        path TEXT NOT NULL,
-        fingerprint TEXT NOT NULL,
-        PRIMARY KEY (workspace_id, worktree, branch, path)
-      );
-    `);
-    for (const [table, column, decl] of [
-      ["review_comments", "head", "TEXT"],
-      ["review_comments", "snippet", "TEXT"],
-      ["workspaces", "materialized", "INTEGER NOT NULL DEFAULT 1"],
-      ["workspaces", "origin_branch", "TEXT"],
-      ["workspaces", "imported_at", "TEXT"],
-    ]) {
-      const cols = wr.prepare(`PRAGMA table_info(${table})`).all();
-      if (!cols.some((c) => c.name === column))
-        wr.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${decl}`);
-    }
-  } finally {
-    wr.close();
-  }
-}
-
-const db = new DatabaseSync(dbPath, { readOnly: true });
-
-// Pre-scrape versions wrote agent hook files into every workspace
-// (identified by their agent-state callback); state now comes from
-// terminal scraping and launch flags, so sweep them out.
-const LEGACY_HOOK_FILES = [
-  ".claude/settings.json",
-  ".codex/hooks.json",
-  ".cursor/hooks.json",
-  ".cursor/hooks/work-working.sh",
-  ".cursor/hooks/work-done.sh",
-  ".github/hooks/work-agent-state.json",
-];
-
-let removed = 0;
-for (const { path: wsPath } of db
-  .prepare("SELECT path FROM workspaces")
-  .all()) {
-  for (const rel of LEGACY_HOOK_FILES) {
-    const file = path.join(wsPath, rel);
-    try {
-      const text = fs.readFileSync(file, "utf8");
-      if (
-        !text.includes("/api/agent-state") &&
-        !text.includes(".cursor/hooks/work-")
-      ) {
-        continue;
-      }
-      fs.rmSync(file);
-      removed++;
-      // Prune now-empty dirs the old version created.
-      for (
-        let dir = path.dirname(file);
-        dir !== wsPath && !fs.readdirSync(dir).length;
-        dir = path.dirname(dir)
-      ) {
-        fs.rmdirSync(dir);
-      }
-    } catch {}
-  }
-}
-if (removed) console.log(`==> migrate: removed ${removed} legacy hook file(s)`);
-
-// Default review base/algorithm changed (workspace branch vs origin/<base>,
-// containment empty-check, then commit-to-commit). Existing comments are
-// keyed only by path+line, so they would silently re-anchor: wipe them
-// once. db.ts sets the flag on a db it creates, which has no such comments
-// to wipe. The viewed flags of that time go with their table, below.
-{
-  const wr = writer();
-  try {
-    const FLAG = "review-cleared-diff-v2";
-    const seen = wr.prepare("SELECT 1 FROM settings WHERE key = ?").get(FLAG);
-    if (!seen) {
-      const comments = wr.prepare("DELETE FROM review_comments").run();
-      wr.prepare("INSERT INTO settings (key, value) VALUES (?, '1')").run(FLAG);
-      if (comments.changes) {
-        console.log(
-          `==> migrate: cleared ${comments.changes} review comment(s)`,
-        );
-      }
-    }
-  } finally {
-    wr.close();
-  }
-}
-
-// The review flagged what moved since the reviewer's last visit, from a
-// head per section kept in `review.seen:<ws>`. Viewed marks replace it
-// (review_marks, src/server/viewed.ts): each head becomes a visit to its
-// section's branch, which the server turns into per-file marks at that
-// head when it next shows the section (a PR's under `#<number>`, the
-// only name its section had). The working-tree hashes beside the heads
-// name no branch's change and go. So does the table of the viewed flags
-// of that time, which nothing reads.
-{
-  const wr = writer();
-  try {
-    const insert = wr.prepare(
-      "INSERT OR IGNORE INTO review_marks (workspace_id, worktree, branch, path, fingerprint) VALUES (?, ?, ?, '', ?)",
-    );
-    let visits = 0;
-    for (const { key, value } of wr
-      .prepare("SELECT key, value FROM settings WHERE key GLOB 'review.seen:*'")
-      .all()) {
-      const id = key.slice("review.seen:".length);
-      const ws = wr
-        .prepare("SELECT branch FROM workspaces WHERE id = ?")
-        .get(id);
-      let heads = {};
-      try {
-        heads = JSON.parse(value)?.heads ?? {};
-      } catch {}
-      for (const [section, head] of Object.entries(ws ? heads : {})) {
-        // `worktree`, `worktree@topic` or `worktree#pr`.
-        const m = /^([^@#]+)(?:@(.+)|#(\d+))?$/.exec(section);
-        if (!m || typeof head !== "string" || !/^[0-9a-f]{40,64}$/.test(head))
-          continue;
-        const branch = m[2]
-          ? `${ws.branch}-${m[2]}`
-          : m[3]
-            ? `#${m[3]}`
-            : ws.branch;
-        insert.run(id, m[1], branch, `seen:${head}`);
-        visits++;
-      }
-      wr.prepare("DELETE FROM settings WHERE key = ?").run(key);
-    }
-    if (visits)
-      console.log(
-        `==> migrate: carried ${visits} review visit(s) over to Viewed marks`,
-      );
-    wr.exec("DROP TABLE IF EXISTS review_viewed");
-  } finally {
-    wr.close();
-  }
-}
-
-// Backfill the push-signal hook into bare caches that predate it (new
-// caches get it from ensureBare — keep this script in sync with
-// src/server/repo-events.ts).
-const workRoot = process.env.WORK_ROOT || path.join(os.homedir(), "work");
-const gitHost = "github.com";
-const appPort = Number(process.env.WORK_APP_PORT || 7171);
-// Same token file the server uses (src/server/hook-token.ts) — hooks ride
-// the public port and the endpoint refuses pings without it. dataDir is
-// declared at the top of this script.
-const tokenFile = path.join(dataDir, "hook-token");
-let hookTokenValue = "";
-try {
-  hookTokenValue = fs.readFileSync(tokenFile, "utf8").trim();
-} catch {}
-if (!hookTokenValue) {
-  hookTokenValue = crypto.randomBytes(16).toString("hex");
-  fs.mkdirSync(dataDir, { recursive: true });
-  fs.writeFileSync(tokenFile, `${hookTokenValue}\n`, { mode: 0o600 });
-}
-const cacheHost = path.join(workRoot, ".cache", gitHost);
-let hooked = 0;
-try {
-  for (const owner of fs.readdirSync(cacheHost)) {
-    const ownerDir = path.join(cacheHost, owner);
-    for (const repoDir of fs.readdirSync(ownerDir)) {
-      if (!repoDir.endsWith(".git")) continue;
-      const fullName = `${owner}/${repoDir.slice(0, -4)}`;
-      const script =
-        `#!/bin/sh\n` +
-        `# installed by work: signals ref updates to the app server.\n` +
-        `[ "$1" = "committed" ] || exit 0\n` +
-        `refs=$(cat)\n` +
-        `case "$refs" in *"refs/remotes/origin/"*) ;; *) exit 0 ;; esac\n` +
-        `printf '%s\\n' "$refs" | curl -sf -m 2 -X POST --data-binary @- "http://${dialHost(process.env.WORK_LISTEN)}:${appPort}` +
-        `/api/repo-pushed?repo=${encodeURIComponent(fullName)}&token=${hookTokenValue}" >/dev/null 2>&1 &\n` +
-        `exit 0\n`;
-      const file = path.join(
-        ownerDir,
-        repoDir,
-        "hooks",
-        "reference-transaction",
-      );
-      let current = "";
-      try {
-        current = fs.readFileSync(file, "utf8");
-      } catch {}
-      try {
-        if (current !== script) {
-          fs.mkdirSync(path.dirname(file), { recursive: true });
-          fs.writeFileSync(file, script, { mode: 0o700 });
-          hooked++;
-        }
-        // It carries the hook token: this user's alone.
-        fs.chmodSync(file, 0o700);
-      } catch {}
-    }
-  }
-} catch {}
-if (hooked)
-  console.log(`==> migrate: installed push hook in ${hooked} cache repo(s)`);
-
-// Lane branches used to accumulate in the bare caches: nothing deleted one
-// when its PR finished, only removing the repo or the whole workspace did,
-// and a long-lived workspace here reached 66 of them against a single live
-// branch. The app now prunes a lane when its merged PR is dismissed (see
-// pruneLaneBranch in src/server/workspaces.ts), which only reaches lanes
-// finished from here on — so sweep the backlog once, with the same guards.
-// Best-effort: without gh, a token, or the network this does nothing.
-const laneWorkspaces = db
-  .prepare("SELECT id, branch FROM workspaces")
-  .all()
-  .map((w) => ({ ...w, repos: [] }));
-for (const row of db
-  .prepare("SELECT workspace_id, full_name FROM repos")
-  .all()) {
-  laneWorkspaces
-    .find((w) => w.id === row.workspace_id)
-    ?.repos.push(row.full_name);
-}
-const ownsRef = (ref, prefix) => ref === prefix || ref.startsWith(`${prefix}-`);
-const gitIn = (dir, args) =>
-  execFileSync("git", ["-C", dir, ...args], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"],
-  });
-
-// Candidate lanes: owned by a workspace branch, not the branch itself, not
-// claimed by another workspace whose branch extends this one's prefix, and
-// not checked out in a worktree.
-const candidates = [];
-for (const ws of laneWorkspaces) {
-  const others = laneWorkspaces
-    .filter((w) => w.id !== ws.id)
-    .map((w) => w.branch);
-  for (const fullName of ws.repos) {
-    const bare = path.join(cacheHost, `${fullName}.git`);
-    let refs, checkedOut;
-    try {
-      refs = gitIn(bare, [
-        "for-each-ref",
-        "--format=%(refname:short) %(objectname)",
-        "refs/heads/",
-      ])
-        .split("\n")
-        .filter(Boolean)
-        .map((line) => line.split(" "));
-      checkedOut = new Set(
-        gitIn(bare, ["worktree", "list", "--porcelain"])
-          .split("\n")
-          .filter((l) => l.startsWith("branch refs/heads/"))
-          .map((l) => l.slice("branch refs/heads/".length)),
-      );
-    } catch {
-      continue;
-    }
-    for (const [lane, oid] of refs) {
-      if (lane === ws.branch || !ownsRef(lane, ws.branch)) continue;
-      if (others.some((b) => ownsRef(lane, b)) || checkedOut.has(lane))
-        continue;
-      candidates.push({ bare, fullName, lane, oid });
-    }
-  }
-}
-
-let pruned = 0;
-for (let i = 0; i < candidates.length; i += 40) {
-  const chunk = candidates.slice(i, i + 40);
-  // One aliased query per chunk rather than a request per lane.
-  const query =
-    "query {" +
-    chunk
-      .map(({ fullName, lane }, n) => {
-        const [owner, name] = fullName.split("/");
-        return (
-          `l${n}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {` +
-          ` pullRequests(headRefName: ${JSON.stringify(lane)}, first: 5) {` +
-          " nodes { state headRefOid } } }"
-        );
-      })
-      .join(" ") +
-    "}";
-  let data;
-  try {
-    data = JSON.parse(
-      execFileSync("gh", ["api", "graphql", "-f", `query=${query}`], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }),
-    ).data;
-  } catch {
-    break;
-  }
-  chunk.forEach((c, n) => {
-    const nodes = data?.[`l${n}`]?.pullRequests?.nodes;
-    if (!nodes?.length || nodes.some((p) => p.state === "OPEN")) return;
-    // The lane has to still be sitting on the finished PR's head: anything
-    // further along is work that PR never carried, and deleting it here
-    // would be the only copy.
-    if (!nodes.some((p) => p.state !== "OPEN" && p.headRefOid === c.oid))
-      return;
-    try {
-      gitIn(c.bare, ["branch", "-D", c.lane]);
-      pruned++;
-    } catch {}
-  });
-}
-if (pruned)
-  console.log(`==> migrate: pruned ${pruned} finished lane branch(es)`);
-
-// Caches made with `git clone --bare` (every cache before init+fetch in
-// ensureBare) copied each remote branch into refs/heads, so a cache carries
-// every branch anyone ever pushed as a local head of its own. Drop the
-// mirrors: a head that no worktree checks out, no workspace here owns,
-// and that still sits exactly on its origin counterpart — the last guard
-// keeps anything with local-only commits, whoever made it.
-const ownedPrefixes = db
-  .prepare("SELECT branch FROM workspaces")
-  .all()
-  .map((w) => w.branch);
-let mirrors = 0;
-try {
-  const cacheRoot = path.join(workRoot, ".cache");
-  for (const host of fs.readdirSync(cacheRoot)) {
-    const hostDir = path.join(cacheRoot, host);
-    if (!fs.statSync(hostDir).isDirectory()) continue;
-    for (const owner of fs.readdirSync(hostDir)) {
-      const ownerDir = path.join(hostDir, owner);
-      if (!fs.statSync(ownerDir).isDirectory()) continue;
-      for (const repoDir of fs.readdirSync(ownerDir)) {
-        if (!repoDir.endsWith(".git")) continue;
-        const bare = path.join(ownerDir, repoDir);
-        let heads, remotes, checkedOut;
-        try {
-          const refLines = (glob) =>
-            gitIn(bare, [
-              "for-each-ref",
-              "--format=%(refname) %(objectname)",
-              glob,
-            ])
-              .split("\n")
-              .filter(Boolean)
-              .map((l) => l.split(" "));
-          heads = refLines("refs/heads/");
-          remotes = new Map(
-            refLines("refs/remotes/origin/").map(([ref, oid]) => [
-              ref.slice("refs/remotes/origin/".length),
-              oid,
-            ]),
-          );
-          checkedOut = new Set(
-            gitIn(bare, ["worktree", "list", "--porcelain"])
-              .split("\n")
-              .filter((l) => l.startsWith("branch refs/heads/"))
-              .map((l) => l.slice("branch refs/heads/".length)),
-          );
-        } catch {
-          continue;
-        }
-        for (const [ref, oid] of heads) {
-          const name = ref.slice("refs/heads/".length);
-          if (checkedOut.has(name)) continue;
-          if (ownedPrefixes.some((b) => ownsRef(name, b))) continue;
-          if (remotes.get(name) !== oid) continue;
-          try {
-            gitIn(bare, ["branch", "-D", name]);
-            mirrors++;
-          } catch {}
-        }
-      }
-    }
-  }
-} catch {}
-if (mirrors)
-  console.log(`==> migrate: dropped ${mirrors} mirrored remote branch(es)`);
-
-// Per-workspace UI prefs were never swept on delete; they ride every SSR
-// document via allPrefs(). Prune orphans once — runtime delete handles new ones.
-{
-  const wr = writer();
-  try {
-    const live = new Set(
-      wr
-        .prepare("SELECT id FROM workspaces")
-        .all()
-        .map((r) => r.id),
-    );
-    // Kept equal to WORKSPACE_PREFS in src/server/settings.ts, a .ts file
-    // this plain script cannot import.
-    const prefixes = [
-      "tab",
-      "diff-filter",
-      "diff-folded",
-      "diff-collapsed",
-      "diff-focus",
-      "diff-pos",
-      "files-recent",
-    ].map((name) => `ui.${name}:`);
-    let pruned = 0;
-    for (const prefix of prefixes) {
-      for (const { key } of wr
-        .prepare("SELECT key FROM settings WHERE key GLOB ?")
-        .all(prefix + "*")) {
-        if (live.has(key.slice(prefix.length))) continue;
-        wr.prepare("DELETE FROM settings WHERE key = ?").run(key);
-        pruned++;
-      }
-    }
-    if (pruned)
-      console.log(`==> migrate: pruned ${pruned} orphaned ui pref(s)`);
-  } finally {
-    wr.close();
-  }
-}
-
-// The review's two-way toggle (`ui.diff-uncommitted`) became the three-way
-// `diff-scope` pref, and nothing reads the old row: drop it, since it rides
-// every SSR prefs payload. Not folded into the scope: that would switch
-// long-time users to uncommitted changes without their asking.
-{
-  const wr = writer();
-  try {
-    const dropped = wr
-      .prepare(
-        "DELETE FROM settings WHERE key IN ('ui.diff-uncommitted', 'diff-uncommitted')",
-      )
-      .run();
-    if (dropped.changes)
-      console.log("==> migrate: dropped the old diff-uncommitted pref");
-  } finally {
-    wr.close();
-  }
-}
-
-// The terminal's two text sizes were one JSON pref (`term-font`), which a
-// device rewrote whole from a stale copy when it set its own size. Split
-// it into the per-device prefs once (keep in sync with termFontPref in
-// src/client/prefs.ts).
-{
-  const wr = writer();
-  try {
-    const legacy = wr
-      .prepare("SELECT value FROM settings WHERE key = 'ui.term-font'")
-      .get();
-    if (legacy) {
-      let sizes = {};
-      try {
-        sizes = JSON.parse(legacy.value) ?? {};
-      } catch {}
-      for (const [field, key] of [
-        ["desktop", "ui.term-font-desktop"],
-        ["touch", "ui.term-font-touch"],
-      ]) {
-        if (!Number.isInteger(sizes[field])) continue;
-        wr.prepare(
-          "INSERT OR IGNORE INTO settings (key, value) VALUES (?, ?)",
-        ).run(key, String(sizes[field]));
-      }
-      wr.prepare("DELETE FROM settings WHERE key = 'ui.term-font'").run();
-      console.log("==> migrate: split term-font into per-device prefs");
-    }
-  } finally {
-    wr.close();
-  }
-}
-
-// The phone pad's pref was once a bare list of the keys after the pad's
-// own nine. It is `{ base, extra }` now, and a change to one key
-// (src/client/pref-change.ts) finds no `extra` in a list, so it would
-// start the pad afresh. Wrap such a list once.
-{
-  const wr = writer();
-  try {
-    const row = wr
-      .prepare("SELECT value FROM settings WHERE key = 'ui.phone-keys'")
-      .get();
-    let keys;
-    try {
-      keys = row && JSON.parse(row.value);
-    } catch {}
-    if (Array.isArray(keys)) {
-      wr.prepare(
-        "UPDATE settings SET value = ? WHERE key = 'ui.phone-keys'",
-      ).run(JSON.stringify({ base: [], extra: keys }));
-      console.log("==> migrate: moved the phone pad's keys into its new shape");
-    }
-  } finally {
-    wr.close();
-  }
-}
-
-// Every sweep has run: the stamp that makes the next run skip them, and
-// that 0.1 reads as the baseline it upgrades from.
-{
-  const wr = writer();
-  try {
-    wr.exec("PRAGMA user_version = 1");
-  } finally {
-    wr.close();
-  }
-}