rvlib-shipkit 1.2.0 → 1.3.0

package/src/home/process-rows.ts

@@ -0,0 +1,205 @@
+// the processes as rows: shipkit's own first (pm, the daemon, the web: the
+// core group), then one group per declaring repo, one row per process, in the
+// order the page and `shipkit global-processes` both show.
+// The page's table and the command's text and json are all drawn from these
+// rows, so the two can never disagree. A row carries no clock: ages are words
+// computed at render time from `since`.
+import type { GlobalProcessDecl } from './global-units.ts'
+import type { CorePorts, PmAnswer } from './pm.ts'
+import type { ProcessIcon, ResourceView } from './resources.ts'
+import type { ProcStatus } from './supervise.ts'
+
+/** a status as pm reports it, or unknown while pm does not answer */
+export type RowStatus = ProcStatus | 'unknown'
+
+/** the dot a row wears: green up, red crashed, grey stopped or unknown, orange on its way */
+export type RowDot = 'up' | 'crashed' | 'down' | 'starting' | 'unknown'
+
+export type ProcessRow = {
+    id: string
+    label: string
+    repo: string
+    file: string
+    status: RowStatus
+    dot: RowDot
+    url: string | null
+    /** the url without its scheme, what the table shows dimmed */
+    host: string | null
+    pid: number | null
+    /** epoch ms its state counts from (up: its pid's start when it has one), null when pm never said */
+    since: number | null
+    note: string | null
+    description: string | null
+    where: string | null
+    /** the last line of its log, null when it has none */
+    lastLog: string | null
+    tail: string[]
+    canStop: boolean
+    /** the page offers restart: a global process pm runs and can stop, while
+     *  up; the daemon and the web always, through pm; never pm itself */
+    canRestart: boolean
+    /** one of shipkit's own: always on, no stop, no open */
+    core: boolean
+    /** the shipkit version it runs, when known (core rows only) */
+    version: string | null
+    takeOver: ResourceView['takeOver']
+    actions: { id: string; label: string }[]
+    running: string | null
+    icon: ProcessIcon | null
+}
+
+/** a repo's processes, or shipkit's own (`core`, always the first group) */
+export type ProcessGroup = { repo: string; core?: true; rows: ProcessRow[] }
+
+/** the core group's name */
+export const CORE_GROUP = 'shipkit'
+
+export const dotOf = (s: RowStatus): RowDot =>
+    s === 'up' ? 'up' : s === 'crashed' ? 'crashed' : s === 'starting' || s === 'stopping' ? 'starting' : s === 'down' ? 'down' : 'unknown'
+
+const hostOf = (url: string | null): string | null => (url == null ? null : url.replace(/^https?:\/\//, '').replace(/\/$/, ''))
+
+/** a process as pm serves it. A pm older than pid and since reads them as null */
+export function rowOf(r: ResourceView): ProcessRow {
+    return {
+        id: r.id,
+        label: r.label,
+        repo: r.repo,
+        file: r.file,
+        status: r.status,
+        dot: dotOf(r.status),
+        url: r.url,
+        host: hostOf(r.url),
+        pid: r.pid ?? null,
+        since: r.since ?? null,
+        note: r.note,
+        description: r.description,
+        where: r.where,
+        lastLog: r.tail.at(-1) ?? null,
+        tail: r.tail,
+        canStop: r.canStop,
+        canRestart: r.status === 'up' && r.canStop,
+        core: false,
+        version: null,
+        takeOver: r.takeOver,
+        actions: r.actions,
+        running: r.running,
+        icon: r.icon,
+    }
+}
+
+/** a declared process while pm does not answer: everything but its state */
+export function declaredRow(d: GlobalProcessDecl): ProcessRow {
+    return {
+        id: d.id,
+        label: d.label,
+        repo: d.repo,
+        file: d.file,
+        status: 'unknown',
+        dot: 'unknown',
+        url: d.url,
+        host: hostOf(d.url),
+        pid: null,
+        since: null,
+        note: null,
+        description: d.description,
+        where: d.where,
+        lastLog: null,
+        tail: [],
+        canStop: false,
+        canRestart: false,
+        core: false,
+        version: null,
+        takeOver: null,
+        actions: d.actions.map((a) => ({ id: a.id, label: a.label })),
+        running: null,
+        // an image is pm's to serve, and pm does not answer
+        icon: d.icon == null || /\.[a-z0-9]+$/i.test(d.icon) ? null : { text: d.icon },
+    }
+}
+
+/** one group per repo, in `order` (the project list), the repos it does not
+ *  list after it by name; a group keeps pm's order */
+export function groupRows(rows: ProcessRow[], order: string[]): ProcessGroup[] {
+    const by = new Map<string, ProcessRow[]>()
+    for (const r of rows) by.set(r.repo, [...(by.get(r.repo) ?? []), r])
+    const rank = (repo: string): number => {
+        const i = order.indexOf(repo)
+        return i < 0 ? order.length : i
+    }
+    return [...by.keys()]
+        .sort((a, b) => rank(a) - rank(b) || a.localeCompare(b))
+        .map((repo) => ({ repo, rows: by.get(repo)! }))
+}
+
+export const CORE_ABOUT = {
+    pm: 'the process manager, the LaunchAgent com.shipkit.pm: launchd starts it at login and again when it dies, so the page has no restart for it (from a terminal: launchctl kickstart -k gui/$(id -u)/com.shipkit.pm)',
+    daemon: 'loads every house repo hub in one process and serves their api, restarted through pm',
+    web: 'serves this page and passes every api request to the daemon, restarted through pm',
+} as const
+
+export type CoreOpts = {
+    /** the daemon's own version, asked of the daemon; null when it does not answer */
+    daemonVersion?: string | null
+    /** where each listens, when pm does not say (an older pm, or pm down) */
+    ports?: CorePorts | null
+}
+
+function coreRow(id: 'pm' | 'daemon' | 'web', o: { status: RowStatus; pid: number | null; since: number | null; note: string | null; tail: string[]; version: string | null; port: number | null; restart: boolean }): ProcessRow {
+    const url = o.port == null ? null : `http://127.0.0.1:${o.port}`
+    return {
+        id, label: id, repo: CORE_GROUP, file: '', status: o.status, dot: dotOf(o.status), url, host: hostOf(url), pid: o.pid, since: o.since, note: o.note,
+        description: CORE_ABOUT[id], where: null, lastLog: o.tail.at(-1) ?? null, tail: o.tail,
+        canStop: false, canRestart: o.restart, core: true, version: o.version, takeOver: null, actions: [], running: null, icon: null,
+    }
+}
+
+/** shipkit's own processes, one row each: pm as it answers (down when it does
+ *  not), then the daemon and the web as pm reports them (unknown without pm) */
+export function coreGroup(pm: PmAnswer | null, o: CoreOpts = {}): ProcessGroup {
+    const ports = pm?.ports ?? o.ports ?? null
+    const rows: ProcessRow[] = [pm == null
+        ? coreRow('pm', { status: 'down', pid: null, since: null, note: 'pm does not answer', tail: [], version: null, port: ports?.pm ?? null, restart: false })
+        : coreRow('pm', { status: 'up', pid: pm.pid, since: pm.since ?? null, note: null, tail: pm.tail ?? [], version: pm.version, port: ports?.pm ?? null, restart: false })]
+    for (const id of ['daemon', 'web'] as const) {
+        const c = pm?.children.find((x) => x.id === id)
+        const port = ports?.[id] ?? null
+        const version = id === 'daemon' ? (o.daemonVersion ?? null) : null
+        if (c == null) rows.push(coreRow(id, { status: 'unknown', pid: null, since: null, note: null, tail: [], version, port, restart: false }))
+        else {
+            const note = [c.note, c.restarts > 0 ? `${c.restarts} restart(s)` : null].filter((x) => x != null).join(', ')
+            rows.push(coreRow(id, { status: c.status, pid: c.pid, since: c.since, note: note === '' ? null : note, tail: c.tail, version, port, restart: true }))
+        }
+    }
+    return { repo: CORE_GROUP, core: true, rows }
+}
+
+/** what the page's table holds, from pm's answer: the core group, then the
+ *  global processes by repo */
+export const processGroups = (pm: PmAnswer | null, order: string[], o: CoreOpts = {}): ProcessGroup[] =>
+    [coreGroup(pm, o), ...groupRows((pm?.resources ?? []).map(rowOf), order)]
+
+/** the declared icon, else the repo's own, else none */
+export const processIcon = (r: { icon: ProcessIcon | null }, repoIcon: string | null): ProcessIcon | null =>
+    r.icon ?? (repoIcon == null ? null : { src: repoIcon })
+
+/** a span in its largest whole unit: 45s, 3m, 2h, 4d */
+export function spanWords(ms: number): string {
+    const s = Math.max(0, Math.floor(ms / 1000))
+    if (s < 60) return `${s}s`
+    if (s < 3600) return `${Math.floor(s / 60)}m`
+    if (s < 86400) return `${Math.floor(s / 3600)}h`
+    return `${Math.floor(s / 86400)}d`
+}
+
+/** the state in words: `up 2h`, `crashed 3m ago`, `stopped`, `starting` */
+export function stateWords(r: Pick<ProcessRow, 'status' | 'since'>, now: number): string {
+    const age = r.since == null ? null : spanWords(now - r.since)
+    switch (r.status) {
+        case 'up': return age == null ? 'up' : `up ${age}`
+        case 'crashed': return age == null ? 'crashed' : `crashed ${age} ago`
+        case 'down': return 'stopped'
+        case 'unknown': return 'unknown (pm down)'
+        default: return r.status
+    }
+}

package/src/home/resources.ts

@@ -1,7 +1,8 @@
 // the machine's global processes (ComfyUI, a TTS server, an app panel), each
 // declared once in a repo's `<name>.shipkit.ts` as `globalProcess({...})`
 // (shipkit-files.ts) and owned by pm: a switch, a restart, its log, its
-// action buttons, and for an app the window that opens on its url.
+// action buttons, and its url opened in the default browser or as a shipkit
+// app window.
 //
 // two kinds: with no `down`, the command IS the service, supervised like a
 // hub (restarted on a crash, signalled on stop). With `down`, the command is
@@ -11,6 +12,7 @@ import { mkdirSync, openSync, closeSync } from 'fs'
 import { dirname, join } from 'path'
 import { fileURLToPath } from 'url'
 import type { GlobalProcessDecl } from './global-units.ts'
+import { iconImageType } from '../shipkit-files.ts'
 import { Proc, realDeps, tailLines, type ProcStatus, type SuperviseDeps } from './supervise.ts'
 import { resourceLog, resourcePid } from './home-paths.ts'
 import { groupOf, localPort, portHolders } from '../core/port-holders.ts'
@@ -21,6 +23,11 @@ export type ResourceView = {
     description: string | null
     where: string | null
     status: ProcStatus
+    /** the pid pm holds for it, null for a bring-up or one started elsewhere */
+    pid: number | null
+    /** epoch ms its uptime counts from while up (its pid's start when it has
+     *  one, else its last status change), its crash time when crashed */
+    since: number
     /** what the owner last asked for */
     want: 'up' | 'down'
     note: string | null
@@ -35,13 +42,20 @@ export type ResourceView = {
     repo: string
     file: string
     url: string | null
-    /** opens as a shipkit app window on its url */
-    app: boolean
+    /** what its card wears, as declared: null leaves the card its repo's icon */
+    icon: ProcessIcon | null
     actions: { id: string; label: string }[]
     /** the action running now, or null */
     running: string | null
 }
 
+/** an emoji, or the url pm serves a declared image file at */
+export type ProcessIcon = { text: string } | { src: string }
+
+/** the page's url for a process's declared icon */
+export const processIconOf = (d: GlobalProcessDecl): ProcessIcon | null =>
+    d.icon == null ? null : iconImageType(d.icon) != null ? { src: `/api/pm/icon/${encodeURIComponent(d.id)}` } : { text: d.icon }
+
 export type HttpProbe = (url: string) => Promise<boolean>
 
 export const probeUrl: HttpProbe = async (url) => {
@@ -138,14 +152,22 @@ export class Resource {
     private failed = false
     /** open it once it answers: in the default browser, or as an app window */
     private openWhenUp: 'browser' | 'app' | null = null
+    /** the status a tick last saw, and since when, for the bring-up kind */
+    private seen: ProcStatus = 'down'
+    private seenAt: number
     readonly log: string
 
     constructor(readonly decl: GlobalProcessDecl, dir: string, private o: ResourceOpts = {}) {
         this.log = resourceLog(dir, decl.id)
+        this.seenAt = this.now()
         if (decl.down == null)
             this.proc = new Proc({ id: decl.id, cmd: decl.cmd, cwd: decl.cwd, log: this.log, pidKey: resourcePid(dir, decl.id), probe: decl.probe == null ? undefined : () => this.probe() }, o.deps ?? realDeps)
     }
 
+    private now(): number {
+        return this.o.deps?.now() ?? Date.now()
+    }
+
     private probe(): Promise<boolean> {
         return this.decl.probe == null ? Promise.resolve(true) : (this.o.probe ?? probeUrl)(this.decl.probe)
     }
@@ -226,12 +248,10 @@ export class Resource {
         await this.set('up')
     }
 
-    /** its url in the default browser, or as a shipkit app window (app:
-     *  true only): at once while it answers, else it starts and opens once
-     *  it does */
+    /** its url in the default browser, or as a shipkit app window: at once
+     *  while it answers, else it starts and opens once it does */
     async open(how: 'browser' | 'app'): Promise<void> {
         if (this.decl.url == null) throw new Error(`${this.decl.id} declares no url to open`)
-        if (how === 'app' && !this.decl.app) throw new Error(`${this.decl.id} does not declare app: true, so it has no app window: open it in the browser`)
         if (this.status === 'up') {
             this.show(how, this.decl.url)
             return
@@ -275,6 +295,10 @@ export class Resource {
             const up = await this.probe()
             this.status = up ? 'up' : this.failed && this.want === 'up' ? 'crashed' : 'down'
         }
+        if (this.status !== this.seen) {
+            this.seen = this.status
+            this.seenAt = this.now()
+        }
         if (this.openWhenUp != null && this.status === 'up' && this.decl.url != null) {
             const how = this.openWhenUp
             this.openWhenUp = null
@@ -290,6 +314,9 @@ export class Resource {
             description: d.description,
             where: d.where,
             status: this.status,
+            pid: this.proc?.pid ?? null,
+            // up with a pid: since that pid started, so a pm reload never resets its uptime
+            since: (this.status === 'up' ? this.proc?.startedAt() : null) ?? this.proc?.since ?? this.seenAt,
             want: this.want,
             note: this.note,
             canStop: this.canStop,
@@ -298,7 +325,7 @@ export class Resource {
             repo: d.repo,
             file: d.file,
             url: d.url,
-            app: d.app,
+            icon: processIconOf(d),
             actions: d.actions.map((a) => ({ id: a.id, label: a.label })),
             running: this.running,
         }

package/src/home/run-daemon.ts

@@ -20,6 +20,7 @@ import { daemonPort, homeDir, homePort, homeUp, hubBase, WORKER_ENV } from './ho
 import { HomeState } from './home-state.ts'
 import { Hubs } from './hubs.ts'
 import { Planner } from '../plan/planner.ts'
+import { machineCatchUp } from '../plan/catch-up.ts'
 import { serveDaemon } from './serve-daemon.ts'
 import { startSweeps } from './machine-stores.ts'
 import { Widgets } from './widgets.ts'
@@ -58,10 +59,11 @@ export async function runDaemon(root: string, io: HomeIo, o: { port?: number } =
     if (reclaimed.killed.length > 0) io.print(`ok: the daemon restarted in place: killed ${reclaimed.killed.length} check process(es) its previous image left running`)
     const c = await loadRepoConfig(root)
     const dir = homeDir()
-    const gutter = projectGutter({ root, warn: (l) => io.printErr(l) })
-    const names = new Set(house.repos.map((r) => r.name))
-    // the machine's one plan: every repo and check pair, ticked by the daemon
-    const plan = new Planner({ onError: (repo, e) => io.printErr(`WARN the plan of ${repo} broke: ${e.message}`) })
+    // the machine's one plan: every repo and check pair, ticked by the daemon.
+    // Its catch up window lives in the machine db, so a restart in place keeps it
+    const plan = new Planner({ catchUp: machineCatchUp, onError: (repo, e) => io.printErr(`WARN the plan of ${repo} broke: ${e.message}`) })
+    // a repo's colour counts only the checks its plan holds today
+    const gutter = projectGutter({ root, warn: (l) => io.printErr(l), declared: (name) => plan.declared(name) })
     const hubs = new Hubs({
         dir,
         port,
@@ -84,8 +86,6 @@ export async function runDaemon(root: string, io: HomeIo, o: { port?: number } =
                 fresh: o.fresh,
                 // every gate is a detached job: a reload of this process never kills one
                 jobs: { cli: CLI },
-                // a lane click of the live strip opens that repo's page, on the page's own origin
-                repoHub: async (other) => (names.has(other) ? `${hubBase(other)}/` : null),
             })
             hubIo.print(`${rt.name} hub → http://localhost:${port}${hubBase(repo.name)}/`)
             return { ...rt, uses: rt.deps.uses ?? [] }

package/src/home/run-pm.ts

@@ -75,6 +75,7 @@ export async function runPm(root: string, io: HomeIo, o: { port?: number } = {})
     const pm = new Pm({
         dir,
         root,
+        port,
         cmd: (role) => [process.execPath, CLI, role],
         probe: roleAnswers,
         resources: new Resources(c.processes, dir),

package/src/home/serve-web.ts

@@ -1,5 +1,5 @@
 // the web: ONE Bun.serve on the home port. It serves the one page bundle (the
-// overview at `/`, the plan at `/planned`, a repo's hub page at `/r/<repo>/`,
+// overview at `/`, the plan at `/planned`, the activity at `/activity`, a repo's hub page at `/r/<repo>/`,
 // all views of one app) and proxies every api,
 // graph and media request to the daemon, streams included, and /api/pm/* to
 // pm. A browser only ever sees this origin.
@@ -14,7 +14,7 @@ import { hubBase } from './home-paths.ts'
 /** the page routes: ONE app for the overview, the plan, and the hub page of
  *  each known repo, which moves between them in place (home-st.ts) */
 export function pageRoutes<T>(names: string[], page: T): Record<string, T> {
-    const out: Record<string, T> = { '/': page, '/planned': page }
+    const out: Record<string, T> = { '/': page, '/planned': page, '/activity': page, '/archived': page }
     for (const n of names) out[`${hubBase(n)}/`] = page
     return out
 }
@@ -51,6 +51,9 @@ export const REPO_ANSWER_MS = 30_000
 export const LIST_EVERY_MS = 30_000
 export const LIST_RETRY_MS = 1_000
 
+/** the one home answer that can wait on git: the activity page's first read of a window */
+export const readsGit = (path: string): boolean => path === '/api/home/activity.json'
+
 /** a run or a check run streams for minutes, and a silent one is never cut */
 export const streams = (path: string): boolean => /\/api\/(run|check\/run)$/.test(path)
 
@@ -94,7 +97,7 @@ export function serveWeb<T extends Bun.HTMLBundle | Response>(d: WebDeps<T>) {
         const path = url.pathname
         const pm = toPm(path)
         const target = pm ? d.pm : d.daemon
-        const wait = streams(path) ? null : path.startsWith('/r/') ? (d.repoMs ?? REPO_ANSWER_MS) : (d.machineMs ?? MACHINE_ANSWER_MS)
+        const wait = streams(path) ? null : path.startsWith('/r/') || readsGit(path) ? (d.repoMs ?? REPO_ANSWER_MS) : (d.machineMs ?? MACHINE_ANSWER_MS)
         // the wait covers the answer headers only: a body already flowing is never cut
         const ctl = new AbortController()
         const timer = wait == null ? null : setTimeout(() => ctl.abort(new Error(`no answer in ${wait / 1000}s: it runs but hangs`)), wait)

package/src/home/supervise.ts

@@ -143,19 +143,33 @@ export class Proc {
     external = false
     /** the pid came from the pid record an earlier image wrote, not from a start */
     adopted = false
+    /** when the pid started, kept per pid: a pid's start never moves, so the
+     *  OS is asked once for an adopted pid and never for one this image spawned */
+    private started: { pid: number; at: number | null } | null = null
 
     constructor(readonly spec: ProcSpec, private d: SuperviseDeps = realDeps) {
         this.since = d.now()
         const rec = readPid(spec.pidKey)
         // an earlier image started it and it still runs: adopt, never double
-        if (rec != null && d.alive(rec.pid) && !((d.startedAt?.(rec.pid) ?? 0) > rec.at + RECORD_SLACK_MS)) {
+        const at = rec != null && d.alive(rec.pid) ? (d.startedAt?.(rec.pid) ?? null) : undefined
+        if (rec != null && at !== undefined && !((at ?? 0) > rec.at + RECORD_SLACK_MS)) {
             this.pid = rec.pid
+            this.started = { pid: rec.pid, at }
             this.adopted = true
             this.want = 'up'
             this.set('starting')
         } else if (rec != null) dropPid(spec.pidKey)
     }
 
+    /** epoch ms its pid started, what its uptime counts from; null without
+     *  a pid, or when the OS cannot say */
+    startedAt(): number | null {
+        const pid = this.pid
+        if (pid == null) return null
+        if (this.started?.pid !== pid) this.started = { pid, at: this.d.startedAt?.(pid) ?? null }
+        return this.started.at
+    }
+
     private set(s: ProcStatus, note: string | null = null): void {
         if (s !== this.status) this.since = this.d.now()
         this.status = s
@@ -185,6 +199,7 @@ export class Proc {
         try {
             const pid = this.d.spawn(this.spec)
             this.pid = pid
+            this.started = { pid, at: this.d.now() }
             this.adopted = false
             writePid(this.spec.pidKey, { pid, cmd: this.spec.cmd, at: this.d.now() })
             this.set('starting')

package/src/home/widget-text.ts

@@ -0,0 +1,119 @@
+// a widget's html as console lines, for `shipkit overview`: the html the
+// daemon rendered for the page, tags stripped, a table's cells aligned in
+// columns, a block element on its own line, and a `.wbar` meter (its width
+// in `--p:NN%`) drawn as `█████░░░░░`. It reads, never runs: no script, no
+// style, no layout, so a widget that draws only with css reads as its text.
+
+const BLOCK = new Set(['div', 'p', 'section', 'article', 'header', 'footer', 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'pre', 'hr', 'dl', 'dt', 'dd', 'figure', 'figcaption', 'blockquote'])
+const SKIP = new Set(['script', 'style', 'template', 'svg'])
+const BAR_CELLS = 10
+
+const ENTITY: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', middot: '·', deg: '°', hellip: '…', times: '×' }
+
+export function decodeEntities(s: string): string {
+    return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e: string) => {
+        if (e[0] === '#') {
+            const n = e[1] === 'x' || e[1] === 'X' ? parseInt(e.slice(2), 16) : Number(e.slice(1))
+            return Number.isFinite(n) ? String.fromCodePoint(n) : m
+        }
+        return ENTITY[e.toLowerCase()] ?? m
+    })
+}
+
+/** a meter of BAR_CELLS cells, `p` in 0..100 */
+export function barText(p: number): string {
+    const on = Math.round((Math.min(100, Math.max(0, p)) / 100) * BAR_CELLS)
+    return '█'.repeat(on) + '░'.repeat(BAR_CELLS - on)
+}
+
+type Block = { kind: 'line'; text: string } | { kind: 'table'; rows: string[][] }
+
+const attr = (attrs: string, name: string): string | null => {
+    const m = new RegExp(`\\b${name}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i').exec(attrs)
+    return m == null ? null : (m[2] ?? m[3] ?? m[4] ?? '')
+}
+
+const squash = (s: string): string => s.replace(/\s+/g, ' ').trim()
+
+/** a table's rows as aligned lines: each column as wide as its widest cell */
+export function alignRows(rows: string[][]): string[] {
+    const w: number[] = []
+    for (const r of rows) r.forEach((c, i) => { w[i] = Math.max(w[i] ?? 0, c.length) })
+    return rows.map((r) => r.map((c, i) => (i === r.length - 1 ? c : c.padEnd(w[i]!))).join('  ').trimEnd())
+}
+
+/** a widget's leading `<header>`: the words it puts on its card's title
+ *  line (state, age), apart from the body drawn under that line */
+export function splitWidgetHead(html: string): { head: string | null; body: string } {
+    const m = /^\s*<header\b[^>]*>([\s\S]*?)<\/header>/i.exec(html)
+    return m == null ? { head: null, body: html } : { head: m[1]!, body: html.slice(m[0].length) }
+}
+
+/** the html as lines, no empty one */
+export function widgetText(html: string): string[] {
+    const blocks: Block[] = []
+    let line = ''
+    let table: string[][] | null = null
+    let cell: string | null = null
+    let skip: string | null = null
+    const put = (s: string): void => {
+        if (cell != null) cell += s
+        else line += s
+    }
+    const flush = (): void => {
+        for (const part of line.split('\n')) if (squash(part) !== '') blocks.push({ kind: 'line', text: squash(part) })
+        line = ''
+    }
+    const endCell = (): void => {
+        if (cell != null && table != null) table.at(-1)?.push(squash(cell))
+        cell = null
+    }
+    const tokens = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][a-zA-Z0-9-]*)([^>]*)>|([^<]+)|</g
+    for (const m of html.matchAll(tokens)) {
+        const [whole, close, rawTag, attrs = '', text] = m
+        if (text != null || whole === '<') {
+            if (skip == null) put(decodeEntities(text ?? '<'))
+            continue
+        }
+        if (rawTag == null) continue
+        const tag = rawTag.toLowerCase()
+        if (skip != null) {
+            if (close === '/' && tag === skip) skip = null
+            continue
+        }
+        if (SKIP.has(tag) && close !== '/' && !attrs.trim().endsWith('/')) {
+            skip = tag
+            continue
+        }
+        if (tag === 'table') {
+            endCell()
+            if (close === '/') {
+                if (table != null) blocks.push({ kind: 'table', rows: table.filter((r) => r.some((c) => c !== '')) })
+                table = null
+            } else {
+                flush()
+                table = []
+            }
+        } else if (tag === 'tr' && table != null) {
+            endCell()
+            if (close !== '/') table.push([])
+        } else if ((tag === 'td' || tag === 'th') && table != null) {
+            endCell()
+            if (close !== '/') {
+                if (table.length === 0) table.push([])
+                cell = ''
+            }
+        } else if (tag === 'br') put(cell != null ? ' ' : '\n')
+        else if (BLOCK.has(tag)) {
+            if (cell != null) put(' ')
+            else flush()
+        } else if (close !== '/' && /\bwbar\b/.test(attr(attrs, 'class') ?? '')) {
+            const p = /--p\s*:\s*(-?\d+(?:\.\d+)?)%/.exec(attr(attrs, 'style') ?? '')
+            if (p != null) put(` ${barText(Number(p[1]))} `)
+        }
+    }
+    endCell()
+    if (table != null) blocks.push({ kind: 'table', rows: table })
+    flush()
+    return blocks.flatMap((b) => (b.kind === 'line' ? [b.text] : alignRows(b.rows)))
+}

package/src/hooks/run-hooks.ts

@@ -43,7 +43,10 @@ export type HooksConfig = {
      *  hooks/leak-guard.ts */
     leakAllow?: LeakAllowEntry[]
     /** staged-path prefixes that can never enter git (local state like
-     *  '.comfy-ts/'). A gitignore line is advisory and editable. This gate is not. */
+     *  '.comfy-ts/'). A gitignore line is advisory and editable. This gate is not.
+     *  A repo declaring `visibility: 'private'` still commits
+     *  '.comfy-ts/drafts/' through a broader prefix. Public and undeclared
+     *  repos block it. */
     blockedPaths?: string[]
     /** words the commit-message language gate never counts as French
      *  (proper nouns that carry accents without being a language choice) */
@@ -191,6 +194,20 @@ function waivedLines(waived: LeakWaiver[]): string[] {
     )
 }
 
+const COMFY_DRAFTS = '.comfy-ts/drafts/'
+
+/** the staged files the `blocked-paths` gate refuses. A repo DECLARED private
+ *  (never by default) commits its comfy drafts through a
+ *  broader block: a draft names private loras, which a private tree may hold.
+ *  A prefix naming the drafts folder itself keeps them blocked. */
+export function blockedStaged(staged: string[], config: RepoConfig): string[] {
+    const prefixes = config.hooks?.blockedPaths ?? []
+    const open = draftsOpen(config)
+    return staged.filter((f) => prefixes.some((p) => f.startsWith(p) && !(open && f.startsWith(COMFY_DRAFTS) && !p.startsWith(COMFY_DRAFTS))))
+}
+
+const draftsOpen = (c: RepoConfig): boolean => c.visibility === 'private'
+
 /** the pre-commit gate: built-in leak guard, then the repo's own commands.
  *  A commit takes ~1s (build/shipkit.md): the gate times itself, and going
  *  over budget WARNs naming the fix, so drift back to slow commits is loud. */
@@ -226,7 +243,7 @@ export async function runPreCommit(root: string, config: RepoConfig): Promise<Ga
     if ((h.blockedPaths ?? []).length > 0) {
         const names = Bun.spawnSync([gitBin(), 'diff', '--cached', '--name-only'], { cwd: root })
         const staged = names.stdout.toString().split('\n').filter(Boolean)
-        const blocked = staged.filter((f) => h.blockedPaths!.some((p) => f.startsWith(p)))
+        const blocked = blockedStaged(staged, config)
         out.push(blocked.length === 0
             ? { id: 'blocked-paths', ok: true, lines: [`ok: blocked-paths clean (${h.blockedPaths!.join(', ')})`] }
             : {
@@ -327,7 +344,7 @@ export function listGates(config: RepoConfig, root = process.cwd()): string[] {
     const leakAllowState = waivers === 0 ? '' : `, ${(h.leakAllow ?? []).length} repo waiver(s)${globalAllowFile() == null ? '' : ' + ~/.shipkit/private/leak-allow.json'}`
     return [
         `pre-commit  leak-guard${leakState} — staged added lines + paths vs ${kw} + ~/.shipkit/private/banned-keywords.txt${leakAllowState}`,
-        ...((h.blockedPaths ?? []).length > 0 ? [`pre-commit  blocked-paths — nothing under ${h.blockedPaths!.join(', ')} enters git`] : []),
+        ...((h.blockedPaths ?? []).length > 0 ? [`pre-commit  blocked-paths — nothing under ${h.blockedPaths!.join(', ')} enters git${draftsOpen(config) && blockedStaged([COMFY_DRAFTS], config).length === 0 && h.blockedPaths!.some((p) => COMFY_DRAFTS.startsWith(p)) ? `, except ${COMFY_DRAFTS} (declared private)` : ''}`] : []),
         `pre-commit  root-identity${off.has('root-identity') ? ' (DISABLED by config)' : ''} — the repo's own name in package.json + repo.config.ts, and scratch files`,
         ...(h.preCommit ?? []).map((c) => `pre-commit  ${c.id} — ${c.cmd.join(' ')}`),
         `commit-msg  commit-message${off.has('commit-message') ? ' (DISABLED by config)' : ''} — dash punctuation + AI attribution + French${off.has('commit-language') ? ' (commit-language DISABLED by config)' : ''}`,

package/src/ledger/db.ts

@@ -287,7 +287,7 @@ function migrate(db: Database): void {
 /** give the file back its free pages once more than half of it is free and
  *  that is worth it: a DELETE frees pages for reuse but never shrinks the
  *  file. VACUUM holds the write lock while it runs: a gate that asks then
- *  measures instead of waiting. The daemon's sweep and `check --fix SK023`
+ *  measures instead of waiting. The daemon's sweep and `check --fix stores-under-cap` (house repo)
  *  call it. True when it ran */
 export function compactDb(path: string, o: { minFreeBytes?: number } = {}): boolean {
     const opened = openDb(path, { create: false })