rvlib-shipkit 1.5.0 → 1.7.0

package/src/home/gui-app/ShipkitGui.swift

@@ -17,55 +17,110 @@ func stays(_ url: URL) -> Bool {
     url.host == "127.0.0.1" || url.host == "localhost" || url.host == startURL.host
 }
 
-/** a window's content: the web view, and the find bar above it when shown.
- *  WKWebView is an NSTextFinderClient, so the platform find bar searches the
- *  page; this view is the bar's container */
-final class Pane: NSView, NSTextFinderBarContainer {
+/** a window's content: the find bar above the web view when shown. WebKit's
+ *  public find api searches the page: NSTextFinder never shows its bar for a
+ *  WKWebView, which is no NSTextFinderClient at runtime */
+final class Pane: NSView, NSSearchFieldDelegate {
     let web: WKWebView
-    let finder = NSTextFinder()
+    let bar = NSStackView()
+    let field = NSSearchField()
+    let status = NSTextField(labelWithString: "")
+    static let barHeight: CGFloat = 34
 
     init(web: WKWebView) {
         self.web = web
         super.init(frame: .zero)
         addSubview(web)
-        finder.client = web
-        finder.findBarContainer = self
-        finder.isIncrementalSearchingEnabled = true
-        finder.incrementalSearchingShouldDimContentView = false
+        field.placeholderString = "find in page"
+        field.delegate = self
+        field.sendsSearchStringImmediately = true
+        status.textColor = .secondaryLabelColor
+        let prev = NSButton(title: "‹", target: self, action: #selector(findPrevious))
+        let next = NSButton(title: "›", target: self, action: #selector(findNext))
+        let done = NSButton(title: "Done", target: self, action: #selector(hideFind))
+        prev.toolTip = "previous match (⇧⌘G, ⇧↩)"
+        next.toolTip = "next match (⌘G, ↩)"
+        for b in [prev, next, done] { b.bezelStyle = .rounded; b.controlSize = .small }
+        field.controlSize = .small
+        field.widthAnchor.constraint(greaterThanOrEqualToConstant: 220).isActive = true
+        bar.orientation = .horizontal
+        bar.spacing = 6
+        bar.edgeInsets = NSEdgeInsets(top: 4, left: 8, bottom: 4, right: 8)
+        for v in [field, status, prev, next, done] as [NSView] { bar.addArrangedSubview(v) }
+        bar.setHuggingPriority(.defaultLow, for: .horizontal)
+        bar.isHidden = true
+        addSubview(bar)
     }
 
     required init?(coder: NSCoder) { fatalError("not from a nib") }
 
     override var isFlipped: Bool { true }
 
-    var findBarView: NSView? {
+    var isFindBarVisible = false {
         didSet {
-            oldValue?.removeFromSuperview()
-            if let bar = findBarView { addSubview(bar) }
+            bar.isHidden = !isFindBarVisible
             needsLayout = true
         }
     }
 
-    var isFindBarVisible = false {
-        didSet {
-            findBarView?.isHidden = !isFindBarVisible
-            needsLayout = true
+    override func layout() {
+        super.layout()
+        let top = isFindBarVisible ? Pane.barHeight : 0
+        bar.frame = NSRect(x: 0, y: 0, width: bounds.width, height: Pane.barHeight)
+        web.frame = NSRect(x: 0, y: top, width: bounds.width, height: max(0, bounds.height - top))
+    }
+
+    @objc func showFind() {
+        isFindBarVisible = true
+        window?.makeFirstResponder(field)
+        field.currentEditor()?.selectAll(nil)
+    }
+
+    @objc func hideFind() {
+        isFindBarVisible = false
+        window?.makeFirstResponder(web)
+    }
+
+    @objc func findNext() { search(backwards: false) }
+    @objc func findPrevious() { search(backwards: true) }
+
+    /** the next match of the field's text from the page's selection, wrapping;
+     *  `done` hears whether one was found */
+    func search(backwards: Bool, done: ((Bool) -> Void)? = nil) {
+        let q = field.stringValue
+        if q.isEmpty {
+            status.stringValue = ""
+            done?(false)
+            return
+        }
+        let c = WKFindConfiguration()
+        c.backwards = backwards
+        c.wraps = true
+        c.caseSensitive = false
+        web.find(q, configuration: c) { r in
+            self.status.stringValue = r.matchFound ? "" : "no match"
+            done?(r.matchFound)
         }
     }
 
-    func findBarViewDidChangeHeight() { needsLayout = true }
+    /** typing searches again from the top of the page */
+    func fromTop(done: ((Bool) -> Void)? = nil) {
+        web.evaluateJavaScript("getSelection().removeAllRanges()") { _, _ in self.search(backwards: false, done: done) }
+    }
 
-    func contentView() -> NSView? { web }
+    func controlTextDidChange(_ note: Notification) { fromTop() }
 
-    override func layout() {
-        super.layout()
-        var top: CGFloat = 0
-        if let bar = findBarView, isFindBarVisible {
-            let h = bar.frame.height
-            bar.frame = NSRect(x: 0, y: 0, width: bounds.width, height: h)
-            top = h
+    // in the field: return is the next match, shift return the previous, esc closes
+    func control(_ control: NSControl, textView: NSTextView, doCommandBy sel: Selector) -> Bool {
+        if sel == #selector(NSResponder.insertNewline(_:)) {
+            search(backwards: NSApp.currentEvent?.modifierFlags.contains(.shift) == true)
+            return true
         }
-        web.frame = NSRect(x: 0, y: top, width: bounds.width, height: max(0, bounds.height - top))
+        if sel == #selector(NSResponder.cancelOperation(_:)) {
+            hideFind()
+            return true
+        }
+        return false
     }
 }
 
@@ -74,12 +129,12 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     var opened = false
 
     func applicationDidFinishLaunching(_ note: Notification) {
+        if CommandLine.arguments.contains("--self-test-find") { return selfTestFind() }
         buildMenu()
         // esc closes the find bar of the key window, and reaches the page otherwise
         NSEvent.addLocalMonitorForEvents(matching: .keyDown) { e in
             if e.keyCode == 53, let pane = self.keyPane(), pane.isFindBarVisible {
-                pane.finder.performAction(.hideFindInterface)
-                pane.window?.makeFirstResponder(pane.web)
+                pane.hideFind()
                 return nil
             }
             return e
@@ -128,11 +183,10 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     @objc func zoomOut(_ sender: Any?) { zoom = zoom / 1.1 }
     @objc func zoomReset(_ sender: Any?) { zoom = 1 }
 
-    // the menu item's tag is the NSTextFinder.Action it performs
-    @objc func findAction(_ sender: NSMenuItem) {
-        guard let pane = keyPane(), let action = NSTextFinder.Action(rawValue: sender.tag) else { return }
-        pane.finder.performAction(action)
-    }
+    @objc func showFind(_ sender: Any?) { keyPane()?.showFind() }
+    @objc func hideFind(_ sender: Any?) { keyPane()?.hideFind() }
+    @objc func findNext(_ sender: Any?) { keyPane()?.findNext() }
+    @objc func findPrevious(_ sender: Any?) { keyPane()?.findPrevious() }
 
     // no public api opens the inspector: `_inspector` then `show` is the
     // WebKit call the context menu's Inspect Element makes. Where it is gone,
@@ -151,10 +205,9 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     }
 
     func validateMenuItem(_ item: NSMenuItem) -> Bool {
-        if item.action == #selector(findAction(_:)) {
-            guard let pane = keyPane(), let action = NSTextFinder.Action(rawValue: item.tag) else { return false }
-            return pane.finder.validateAction(action)
-        }
+        if item.action == #selector(hideFind(_:)) { return keyPane()?.isFindBarVisible == true }
+        if item.action == #selector(findNext(_:)) || item.action == #selector(findPrevious(_:)) { return keyPane()?.field.stringValue.isEmpty == false }
+        if item.action == #selector(showFind(_:)) { return keyPane() != nil }
         if item.action == #selector(devTools(_:)) || item.action == #selector(reload(_:)) { return keyPane() != nil }
         return true
     }
@@ -184,12 +237,43 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         NSApp.activate(ignoringOtherApps: true)
     }
 
+    var onLoad: ((WKWebView) -> Void)?
+
+    // `--self-test-find`: an offscreen window on a page holding a word twice,
+    // the find bar opened, a word on the page searched, then one that is not;
+    // what happened printed, exit 0 only when the bar shows and finds
+    func selfTestFind() {
+        let web = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        web.navigationDelegate = self
+        let pane = Pane(web: web)
+        let win = NSWindow(contentRect: NSRect(x: -4000, y: -4000, width: 600, height: 400), styleMask: [.titled], backing: .buffered, defer: false)
+        win.contentView = pane
+        win.orderFrontRegardless()
+        windows.append(win)
+        onLoad = { _ in
+            pane.showFind()
+            pane.field.stringValue = "needle"
+            pane.fromTop { found in
+                pane.field.stringValue = "haystack"
+                pane.fromTop { absent in
+                    print("find-bar-visible=\(pane.isFindBarVisible)")
+                    print("found=\(found)")
+                    print("absent-found=\(absent)")
+                    print("status=\(pane.status.stringValue)")
+                    exit(pane.isFindBarVisible && found && !absent ? 0 : 1)
+                }
+            }
+        }
+        web.loadHTMLString("<p>one needle, two needle</p>", baseURL: nil)
+    }
+
     func windowWillClose(_ note: Notification) {
         windows.removeAll { $0 === note.object as? NSWindow }
     }
 
     // the page title names the window, so cmd-tab and the window menu tell pages apart
     func webView(_ web: WKWebView, didFinish nav: WKNavigation!) {
+        onLoad?(web)
         web.window?.title = (web.title?.isEmpty == false) ? web.title! : appName
     }
 
@@ -242,10 +326,10 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         edit.addItem(.separator())
         let findItem = edit.addItem(withTitle: "Find", action: nil, keyEquivalent: "")
         let find = NSMenu(title: "Find")
-        item(find, "Find…", #selector(findAction(_:)), "f", tag: NSTextFinder.Action.showFindInterface.rawValue)
-        item(find, "Find Next", #selector(findAction(_:)), "g", tag: NSTextFinder.Action.nextMatch.rawValue)
-        item(find, "Find Previous", #selector(findAction(_:)), "g", [.command, .shift], tag: NSTextFinder.Action.previousMatch.rawValue)
-        item(find, "Hide Find Bar", #selector(findAction(_:)), "", [], tag: NSTextFinder.Action.hideFindInterface.rawValue)
+        item(find, "Find…", #selector(showFind(_:)), "f")
+        item(find, "Find Next", #selector(findNext(_:)), "g")
+        item(find, "Find Previous", #selector(findPrevious(_:)), "g", [.command, .shift])
+        item(find, "Hide Find Bar", #selector(hideFind(_:)), "", [])
         edit.setSubmenu(find, for: findItem)
         editItem.submenu = edit
         let viewItem = NSMenuItem()

package/src/home/gui-app.ts

@@ -4,12 +4,15 @@
 // and iconed after it, in its repo's `.shipkit/wrapper/`. The bundle's
 // Info.plist carries what differs (name, bundle id, start url), so a fix to
 // the window (find, the inspector, zoom) lands in every app at its next
-// build. Rebuilt only when the source, the icon or the start url changed (a
-// stamp in the bundle). No compiler, or not macOS: the caller falls back.
+// build. The icon is core/app-icon.ts: the repo's mark, its margin cut, on
+// a plate in the repo's colour. Rebuilt only when the source, the icon, the
+// colours or the start url changed (a stamp in the bundle). No compiler, or not macOS: the caller falls back.
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs'
 import { homedir } from 'os'
 import { dirname, join } from 'path'
 import { fileURLToPath } from 'url'
+import { appIconOf, appIconPngs, identityOfRoot } from '../core/app-icon.ts'
+import { identityOfName, type Identity } from '../core/identity-color.ts'
 import { LAYOUT } from '../core/layout.ts'
 
 const SOURCE = fileURLToPath(new URL('./gui-app/ShipkitGui.swift', import.meta.url))
@@ -17,15 +20,6 @@ const SOURCE = fileURLToPath(new URL('./gui-app/ShipkitGui.swift', import.meta.u
 export const BUNDLE_ID = 'dev.shipkit.gui'
 export const guiAppPath = (): string => process.env.SHIPKIT_GUI_APP ?? join(homedir(), 'Applications', 'Shipkit.app')
 
-/** the icon the app wears: the repo's own mark, largest first. Only a
- *  png can become an icns */
-export const APP_ICON_FILES = [`${LAYOUT.identity}/icon.png`, 'public/logo.png', 'public/favicon.png']
-
-export function appIconOf(root: string): string | null {
-    for (const f of APP_ICON_FILES) if (existsSync(join(root, f))) return join(root, f)
-    return null
-}
-
 /** what one app bundle is: the rest comes from the shared source */
 export type AppSpec = {
     /** CFBundleName: the dock, cmd-tab and the app menu say it */
@@ -34,6 +28,8 @@ export type AppSpec = {
     /** the page a launch with no url opens; null opens the home */
     url: string | null
     icon: string | null
+    /** the repo's colours: the plate behind the icon's mark */
+    identity: Identity
     /** where the bundle lands */
     app: string
     version: string
@@ -52,7 +48,7 @@ function atsOf(url: string | null): string {
     return `<dict><key>NSAllowsLocalNetworking</key><true/>${exception}</dict>`
 }
 
-export function infoPlist(o: Omit<AppSpec, 'app' | 'icon'>): string {
+export function infoPlist(o: Omit<AppSpec, 'app' | 'icon' | 'identity'>): string {
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -79,6 +75,9 @@ const runSync: Run = (cmd) => {
     return { code: p.exitCode ?? 1, err: p.stderr.toString().trim() }
 }
 
+/** bumped when the icon drawing changes, so every built app redraws its icon */
+const ICON_DRAWING = 'plate-1'
+
 /** the stamp a built bundle carries: what it was built from. The version is
  *  left out, so a shipkit release rebuilds nothing */
 export function stampOf(source: string, icon: string | null, identity = ''): string {
@@ -89,11 +88,11 @@ export function stampOf(source: string, icon: string | null, identity = ''): str
 
 /** one app, built or rebuilt when stale. Throws with the step that failed.
  *  `rebuilt` tells the caller a running copy is now the old one */
-export function ensureApp(spec: AppSpec, o: { run?: Run; source?: string } = {}): { app: string; rebuilt: boolean } {
+export async function ensureApp(spec: AppSpec, o: { run?: Run; source?: string } = {}): Promise<{ app: string; rebuilt: boolean }> {
     const { app, icon } = spec
     const run = o.run ?? runSync
     const source = o.source ?? SOURCE
-    const stamp = stampOf(readFileSync(source, 'utf8'), icon, JSON.stringify([spec.name, spec.bundleId, spec.url]))
+    const stamp = stampOf(readFileSync(source, 'utf8'), icon, JSON.stringify([spec.name, spec.bundleId, spec.url, spec.identity, ICON_DRAWING]))
     const stampFile = join(app, 'Contents', 'Resources', 'stamp')
     if (existsSync(stampFile) && readFileSync(stampFile, 'utf8') === stamp) return { app, rebuilt: false }
     const tmp = `${app}.building-${process.pid}`
@@ -108,12 +107,10 @@ export function ensureApp(spec: AppSpec, o: { run?: Run; source?: string } = {})
     if (icon != null) {
         const set = join(res, 'AppIcon.iconset')
         mkdirSync(set, { recursive: true })
-        for (const n of [16, 32, 128, 256, 512]) {
-            for (const [scale, px] of [['', n], ['@2x', n * 2]] as const) {
-                const r = run(['sips', '-s', 'format', 'png', '-z', String(px), String(px), icon, '--out', join(set, `icon_${n}x${n}${scale}.png`)])
-                if (r.code !== 0) fail(`sips could not size the icon ${icon}: ${r.err.slice(0, 200)}`)
-            }
-        }
+        const files = [16, 32, 128, 256, 512].flatMap((n) => [[`icon_${n}x${n}.png`, n], [`icon_${n}x${n}@2x.png`, n * 2]] as const)
+        const pngs = await appIconPngs(readFileSync(icon), spec.identity, files.map(([, px]) => px))
+            .catch((e: Error) => fail(`could not draw the icon from ${icon}: ${e.message}`))
+        files.forEach(([file], i) => writeFileSync(join(set, file), pngs[i]!))
         const r = run(['iconutil', '-c', 'icns', set, '-o', join(res, 'AppIcon.icns')])
         rmSync(set, { recursive: true, force: true })
         if (r.code !== 0) fail(`iconutil could not build the icon: ${r.err.slice(0, 200)}`)
@@ -128,15 +125,15 @@ export function ensureApp(spec: AppSpec, o: { run?: Run; source?: string } = {})
 }
 
 /** the shipkit app: the shared source on the home, the house repo's icon */
-export function ensureGuiApp(o: { root: string | null; version: string; app?: string; run?: Run }): { app: string; rebuilt: boolean } {
-    return ensureApp({ name: 'shipkit', bundleId: BUNDLE_ID, url: null, icon: o.root == null ? null : appIconOf(o.root), app: o.app ?? guiAppPath(), version: o.version }, { run: o.run })
+export function ensureGuiApp(o: { root: string | null; version: string; app?: string; run?: Run }): Promise<{ app: string; rebuilt: boolean }> {
+    return ensureApp({ name: 'shipkit', bundleId: BUNDLE_ID, url: null, icon: o.root == null ? null : appIconOf(o.root), identity: o.root == null ? identityOfName('shipkit') : identityOfRoot(o.root), app: o.app ?? guiAppPath(), version: o.version }, { run: o.run })
 }
 
 /** what a global process gives its app */
 export type WrapperOf = { id: string; label: string; url: string | null; icon: string | null; root: string }
 
-/** the image icons sips reads; an emoji or an svg leaves the repo's mark */
-const RASTER = /\.(png|jpe?g|gif|webp|bmp|tiff?)$/i
+/** the images the icon renderer reads; an emoji or an svg leaves the repo's mark */
+const RASTER = /\.(png|jpe?g|gif|webp)$/i
 
 export const wrapperBundleId = (id: string): string => `dev.shipkit.app.${id.replace(/[^A-Za-z0-9-]+/g, '-')}`
 export const wrapperPath = (root: string, id: string): string => join(root, LAYOUT.wrapper, `${id.replace(/[^A-Za-z0-9._-]+/g, '-')}.app`)
@@ -147,12 +144,12 @@ export const wrapperPath = (root: string, id: string): string => join(root, LAYO
 export function wrapperSpec(d: WrapperOf, version: string): AppSpec {
     if (d.url == null) throw new Error(`${d.id} declares no url: there is no page to open as an app`)
     const declared = d.icon != null && RASTER.test(d.icon) && existsSync(join(d.root, d.icon)) ? join(d.root, d.icon) : null
-    return { name: d.label, bundleId: wrapperBundleId(d.id), url: d.url, icon: declared ?? appIconOf(d.root), app: wrapperPath(d.root, d.id), version }
+    return { name: d.label, bundleId: wrapperBundleId(d.id), url: d.url, icon: declared ?? appIconOf(d.root), identity: identityOfRoot(d.root), app: wrapperPath(d.root, d.id), version }
 }
 
-export const ensureWrapperApp = (d: WrapperOf, o: { version: string; run?: Run }): { app: string; rebuilt: boolean; bundleId: string } => {
+export const ensureWrapperApp = async (d: WrapperOf, o: { version: string; run?: Run }): Promise<{ app: string; rebuilt: boolean; bundleId: string }> => {
     const spec = wrapperSpec(d, o.version)
-    return { ...ensureApp(spec, { run: o.run }), bundleId: spec.bundleId }
+    return { ...(await ensureApp(spec, { run: o.run })), bundleId: spec.bundleId }
 }
 
 /** quits a running copy of an app, and launches nothing when none runs */

package/src/home/home-routes.ts

@@ -17,6 +17,7 @@ import { Hubs, type WorkerView } from './hubs.ts'
 import type { Planner, PlanRow } from '../plan/planner.ts'
 import type { Widgets, WidgetView } from './widgets.ts'
 import { ActivityCache, repoActivity, windowMinutes } from './activity.ts'
+import { devRepos, InsightsCache, type Scope } from './insights.ts'
 import { HouseRuns } from '../serve/house-runs.ts'
 
 /** how far back a repo's git page lists its commits */
@@ -111,6 +112,8 @@ export function homeRoutes(d: HomeDeps) {
     const modernizing = new Map<string, ModernizeView & { log: string }>()
     // read only while the activity page asks, never on the tick
     const activity = new ActivityCache({ declared: (name) => d.plan?.declared(name) ?? null, titles: (name) => d.plan?.titles(name) ?? null })
+    // read only while the insights page asks, one answer per scope
+    const insights = new InsightsCache()
     const modernizeLog = (repo: string): string => join(d.dir, 'modernize', `${repo}.log`)
     // the dock: every loaded repo's recent runs, read only while a page asks
     const house = new HouseRuns(() => repos)
@@ -176,6 +179,12 @@ export function homeRoutes(d: HomeDeps) {
             const q = new URL(req.url).searchParams
             return Response.json(await activity.get(repos, windowMinutes(q.get('m')), { fresh: q.get('fresh') === '1' }))
         }
+        if (path === '/api/home/insights.json') {
+            if (repos.length === 0) await refresh()
+            const q = new URL(req.url).searchParams
+            const scope: Scope = q.get('scope') === 'dev' ? 'dev' : 'house'
+            return Response.json(await insights.get(scope, () => (scope === 'dev' ? devRepos() : repos), { fresh: q.get('fresh') === '1' }))
+        }
         // one repo's git for its git page: a week of commits, and HEAD's last
         // one past that, whatever window the activity page shows
         if (path === '/api/home/git.json') {
@@ -209,6 +218,12 @@ export function homeRoutes(d: HomeDeps) {
             if (b.act === 'restart') return Response.json(await d.hubs.restart(r))
             return new Response(`act must be ensure, stop or restart`, { status: 400 })
         }
+        if (path === '/api/home/widgets/refresh') {
+            const b = await body(req)
+            const v = await d.widgets?.refresh(String(b.repo), String(b.id))
+            if (v == null) return new Response(`no widget ${String(b.id)} in ${String(b.repo)}`, { status: 404 })
+            return Response.json(v)
+        }
         if (path === '/api/home/planned/run') {
             const b = await body(req)
             if (d.plan == null || !d.plan.ask(String(b.repo), String(b.check))) return new Response(`no planned check ${String(b.check)} in ${String(b.repo)}`, { status: 404 })

package/src/home/home-start.ts

@@ -6,7 +6,11 @@ import { homedir } from 'os'
 import { dirname, join, resolve } from 'path'
 import { gitRoot } from '../core/git-root.ts'
 import { homeRepo, houseIndex } from '../serve/project-gutter.ts'
-import { BUNDLE_ID, canBuildGui, ensureGuiApp, ensureWrapperApp, quitCmd, type WrapperOf } from './gui-app.ts'
+import type { WrapperOf } from './gui-app.ts'
+
+// the app builder draws icons with canvas: loaded when a window opens, never
+// at the startup of every command that imports this module
+const gui = (): Promise<typeof import('./gui-app.ts')> => import('./gui-app.ts')
 import { installedHouseRoot, LABEL, plistPath } from './home-launchd.ts'
 import { childLog, daemonPort, daemonUp, homeDir, homePort, homeUp, pmLog } from './home-paths.ts'
 
@@ -88,10 +92,11 @@ export function windowCmd(url: string, o: { chrome?: string; platform?: string }
 /** one more home window: the native app where it can be built (its own
  *  dock icon, the house mark), else a Chrome app window. `warn` hears why the
  *  native one was not used */
-export function openWindow(url: string, o: { root?: string | null; version?: string; warn?: (l: string) => void } = {}): string[] {
+export async function openWindow(url: string, o: { root?: string | null; version?: string; warn?: (l: string) => void } = {}): Promise<string[]> {
+    const { BUNDLE_ID, canBuildGui, ensureGuiApp, quitCmd } = await gui()
     if (canBuildGui()) {
         try {
-            const { app, rebuilt } = ensureGuiApp({ root: o.root ?? guiRoot(process.cwd()),version: o.version ?? '0' })
+            const { app, rebuilt } = await ensureGuiApp({ root: o.root ?? guiRoot(process.cwd()),version: o.version ?? '0' })
             // a running copy is the old build: it quits, and the new one opens the window
             if (rebuilt) Bun.spawnSync(quitCmd(BUNDLE_ID), { stdout: 'ignore', stderr: 'ignore' })
             const cmd = ['open', '-a', app, url]
@@ -108,11 +113,12 @@ export function openWindow(url: string, o: { root?: string | null; version?: str
  *  `.shipkit/wrapper/`, then opened with no url, so a running copy comes to
  *  the front instead of stacking windows. Where no app can be built, a
  *  Chrome app window on its url */
-export function openProcessApp(d: WrapperOf, o: { version: string; warn?: (l: string) => void }): string[] {
+export async function openProcessApp(d: WrapperOf, o: { version: string; warn?: (l: string) => void }): Promise<string[]> {
     if (d.url == null) throw new Error(`${d.id} declares no url: there is no page to open as an app`)
+    const { canBuildGui, ensureWrapperApp, quitCmd } = await gui()
     if (canBuildGui()) {
         try {
-            const { app, rebuilt, bundleId } = ensureWrapperApp(d, { version: o.version })
+            const { app, rebuilt, bundleId } = await ensureWrapperApp(d, { version: o.version })
             if (rebuilt) Bun.spawnSync(quitCmd(bundleId), { stdout: 'ignore', stderr: 'ignore' })
             const cmd = ['open', '-a', app]
             Bun.spawnSync(cmd, { stdout: 'ignore', stderr: 'ignore' })

package/src/home/insights-shape.ts

@@ -0,0 +1,124 @@
+// the insights page's boxes, computed from every package.json a scope of repos
+// tracks. Pure: no disk, so the page, `sk insights` and the tests share it.
+// Every box has one shape (a row per key, the repos using it, one value per
+// use), so a new box is one function in BOXES and the page draws it unchanged.
+
+/** one package.json, read: its repo, its dir inside the repo ('' at the root) */
+export type Manifest = {
+    repo: string
+    where: string
+    json: { dependencies?: Record<string, string>; devDependencies?: Record<string, string>; peerDependencies?: Record<string, string>; scripts?: Record<string, string> }
+}
+
+/** one package.json using the row's key, and what it says for it */
+export type InsightUse = { repo: string; where: string; value: string; dev?: boolean }
+
+export type InsightRow = {
+    key: string
+    /** distinct repos using it: the sort */
+    repos: number
+    /** its distinct values, most used first (the version ranges of a package) */
+    values: string[]
+    uses: InsightUse[]
+}
+
+export type InsightBox = {
+    id: string
+    title: string
+    tags: string[]
+    /** one line on what it lists and how it sorts */
+    hint: string
+    /** what a row's key is, for the filter's placeholder */
+    noun: string
+    /** the filter reads the values too (a script's command), not only the key */
+    searchValues?: boolean
+    rows: InsightRow[]
+}
+
+export const SCOPES = ['house', 'dev'] as const
+export type Scope = (typeof SCOPES)[number]
+
+export type InsightsAnswer = {
+    now: number
+    scope: Scope
+    /** repos read, and package.json files found in them */
+    repos: number
+    files: number
+    boxes: InsightBox[]
+    /** a manifest that would not parse, as `repo/where: why` */
+    errors: string[]
+    ms: number
+}
+
+const byCount = <T>(xs: T[]): T[] => {
+    const n = new Map<T, number>()
+    for (const x of xs) n.set(x, (n.get(x) ?? 0) + 1)
+    return [...n.keys()].sort((a, b) => n.get(b)! - n.get(a)!)
+}
+
+/** one row per key, the uses gathered, sorted by distinct repos then key */
+function rowsOf(uses: [string, InsightUse][]): InsightRow[] {
+    const by = new Map<string, InsightUse[]>()
+    for (const [k, u] of uses) {
+        if (!by.has(k)) by.set(k, [])
+        by.get(k)!.push(u)
+    }
+    return [...by]
+        .map(([key, us]) => ({ key, repos: new Set(us.map((u) => u.repo)).size, values: byCount(us.map((u) => u.value)), uses: us.sort((a, b) => a.repo.localeCompare(b.repo) || a.where.localeCompare(b.where)) }))
+        .sort((a, b) => b.repos - a.repos || a.key.localeCompare(b.key))
+}
+
+/** a range that names no published version: a workspace or local link */
+export const localRange = (v: string): boolean => /^(workspace:|file:|link:|portal:)/.test(v)
+
+function depUses(ms: Manifest[]): [string, InsightUse][] {
+    return ms.flatMap((m) => [
+        ...Object.entries(m.json.dependencies ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v }]),
+        ...Object.entries(m.json.devDependencies ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v, dev: true }]),
+    ])
+}
+
+export const BOXES: ((ms: Manifest[]) => InsightBox)[] = [
+    (ms) => ({
+        id: 'deps',
+        title: 'dependency usage',
+        tags: ['deps'],
+        hint: 'every package in a dependencies or devDependencies, by how many repos use it',
+        noun: 'package',
+        rows: rowsOf(depUses(ms)),
+    }),
+    (ms) => ({
+        id: 'drift',
+        title: 'version drift',
+        tags: ['deps', 'health'],
+        hint: 'packages asked at more than one version range across repos, by how many ranges',
+        noun: 'package',
+        rows: rowsOf(depUses(ms).filter(([, u]) => !localRange(u.value)))
+            .filter((r) => r.values.length > 1)
+            .sort((a, b) => b.values.length - a.values.length || b.repos - a.repos || a.key.localeCompare(b.key)),
+    }),
+    (ms) => ({
+        id: 'scripts',
+        title: 'script names',
+        tags: ['scripts'],
+        hint: 'every package.json script name, by how many repos declare it, each with its command',
+        noun: 'script',
+        searchValues: true,
+        rows: rowsOf(ms.flatMap((m) => Object.entries(m.json.scripts ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v }]))),
+    }),
+]
+
+/** a row matches a query on its key, or on a value when its box searches them */
+export const rowMatches = (b: InsightBox, r: InsightRow, q: string): boolean => {
+    const s = q.trim().toLowerCase()
+    return s === '' || r.key.toLowerCase().includes(s) || (b.searchValues === true && r.values.some((v) => v.toLowerCase().includes(s)))
+}
+
+/** every box over these manifests */
+export const boxesOf = (ms: Manifest[]): InsightBox[] => BOXES.map((b) => b(ms))
+
+/** every tag the boxes carry, in first seen order */
+export const tagsOf = (boxes: InsightBox[]): string[] => [...new Set(boxes.flatMap((b) => b.tags))]
+
+/** a use's place, as the page and the cli print it */
+export const placeWords = (u: InsightUse): string => (u.where === '' ? u.repo : `${u.repo}/${u.where}`)