rvlib-shipkit 1.3.0 → 1.5.0

package/src/core/wire.ts

@@ -3,22 +3,47 @@
 // exit 0/1. FROZEN: consumers grep startsWith('FAIL'/'WARN'/'skip:') — a
 // prefix change is a breaking change of the whole toolkit.
 
-export type Line = { kind: 'ok' | 'warn' | 'fail' | 'note' | 'fix-warn' | 'fix-fail' | 'skip'; text: string }
+import { CACHED, costShort, RAN, spanShort } from './outcome-words.ts'
+
+export { spanShort }
+
+/** when a remembered world answer was measured, and until when it keeps
+ *  (null: until its declaration changes). Kept as data, never as text, and
+ *  rendered against the reader's clock: a time frozen into the line reads
+ *  as a future expiry long after it passed */
+export type Stamp = { at: number; until: number | null; cached?: boolean; ranMs?: number }
+
+export type Line = { kind: 'ok' | 'warn' | 'fail' | 'note' | 'fix-warn' | 'fix-fail' | 'skip'; text: string; stamp?: Stamp }
+
+/** `cached, 3h old, kept 57m more` for a replay, `ran 0.4s, kept 1h more`
+ *  for an answer this run measured, `ran 1d ago, expired 1d ago` for one
+ *  read back later */
+export function stampWords(s: Stamp, now: number): string {
+    const age = now - s.at
+    const keeps = s.until == null ? 'kept until its declaration changes' : s.until > now ? `kept ${spanShort(s.until - now)} more` : `expired ${spanShort(now - s.until)} ago`
+    if (s.cached === true) return `${CACHED}, ${spanShort(age)} old, ${keeps}`
+    if (s.ranMs != null) return `${RAN} ${costShort(s.ranMs)}, ${keeps}`
+    return `${age < 1000 ? `${RAN} just now` : `${RAN} ${spanShort(age)} ago`}, ${keeps}`
+}
+
+/** a line's text as a reader sees it now, its stamp rendered */
+export const lineText = (l: Line, now: number = Date.now()): string => (l.stamp == null ? l.text : `${l.text} (${stampWords(l.stamp, now)})`)
 
 const green = (s: string): string => `\x1b[32m${s}\x1b[0m`
 const red = (s: string): string => `\x1b[31m${s}\x1b[0m`
 const yellow = (s: string): string => `\x1b[33m${s}\x1b[0m`
 
-export function formatLine(l: Line, color: boolean): string {
+export function formatLine(l: Line, color: boolean, now: number = Date.now()): string {
     const c = (f: (s: string) => string, s: string) => (color ? f(s) : s)
+    const text = lineText(l, now)
     switch (l.kind) {
-        case 'ok': return `${c(green, 'ok:')} ${l.text}`
-        case 'warn': return c(yellow, `WARN ${l.text}`)
-        case 'fail': return c(red, `FAIL: ${l.text}`)
-        case 'fix-warn': return `      ${c(yellow, `fix: ${l.text}`)}`
-        case 'fix-fail': return `      ${c(red, `fix: ${l.text}`)}`
-        case 'skip': return `skip: ${l.text}`
-        case 'note': return l.text
+        case 'ok': return `${c(green, 'ok:')} ${text}`
+        case 'warn': return c(yellow, `WARN ${text}`)
+        case 'fail': return c(red, `FAIL: ${text}`)
+        case 'fix-warn': return `      ${c(yellow, `fix: ${text}`)}`
+        case 'fix-fail': return `      ${c(red, `fix: ${text}`)}`
+        case 'skip': return `skip: ${text}`
+        case 'note': return text
     }
 }
 

package/src/fleet/scan-fleet.ts

@@ -14,7 +14,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { join } from 'path'
 import { isArchived } from '../core/archived.ts'
 import { detectPackageManager, isRefusal } from '../core/package-manager.ts'
-import { isBreaking } from '../core/update-policy.ts'
+import { isBreaking, isLinkedInstall, pinFloor } from '../core/update-policy.ts'
 
 export type Pkg = { name?: string; version?: string; dependencies?: Record<string, string>; devDependencies?: Record<string, string> }
 
@@ -24,6 +24,11 @@ export type FleetDep = {
     pin: string
     /** what node_modules actually carries, null when nothing is installed */
     installed: string | null
+    /** node_modules/<name> is a `bun link` symlink to a source tree */
+    linkedInstall: boolean
+    /** the version freshness is judged by: the pin's floor under a link
+     *  (a fresh clone installs the pin, never the source), else `installed` */
+    at: string | null
     /** npm latest, null when the registry was not consulted or not reachable */
     latest: string | null
 }
@@ -54,6 +59,13 @@ const readPkg = (dir: string): Pkg | null => {
 
 export const installedVersion = (dir: string, name: string): string | null => readPkg(join(dir, 'node_modules', name))?.version ?? null
 
+/** what `FleetDep.at` reads now, for a verdict after an update ran */
+export const judgedVersion = (dir: string, name: string): string | null => {
+    if (!isLinkedInstall(dir, name)) return installedVersion(dir, name)
+    const pkg = readPkg(dir)
+    return pinFloor(pkg?.dependencies?.[name] ?? pkg?.devDependencies?.[name] ?? '')
+}
+
 /** semver-ish compare, enough to answer "is this one behind that one". A
  *  prerelease tag sorts before its release, which is the safe direction: it
  *  reports behind rather than pretending parity. */
@@ -89,7 +101,11 @@ export function scanFleet(root: string, o: { prefix?: string } = {}): FleetRepo[
         const all = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) }
         const names = Object.keys(all).filter((n) => n.startsWith(prefix))
         if (names.length === 0) continue
-        const deps: FleetDep[] = names.sort().map((name) => ({ name, pin: all[name]!, installed: installedVersion(dir, name), latest: null }))
+        const deps: FleetDep[] = names.sort().map((name) => {
+            const installed = installedVersion(dir, name)
+            const linkedInstall = isLinkedInstall(dir, name)
+            return { name, pin: all[name]!, installed, linkedInstall, at: linkedInstall ? pinFloor(all[name]!) : installed, latest: null }
+        })
         out.push({
             name: e,
             dir,
@@ -120,8 +136,8 @@ export async function resolveLatest(repos: FleetRepo[], fetchLatest: (name: stri
     )
     for (const r of repos) {
         for (const d of r.deps) d.latest = latest.get(d.name) ?? null
-        r.behind = r.deps.filter((d) => d.installed != null && d.latest != null && isBehind(d.installed, d.latest))
-        r.breaking = r.behind.filter((d) => isBreaking(d.installed!, d.latest!))
+        r.behind = r.deps.filter((d) => d.at != null && d.latest != null && isBehind(d.at, d.latest))
+        r.breaking = r.behind.filter((d) => isBreaking(d.at!, d.latest!))
     }
     return latest
 }

package/src/fleet/update-fleet.ts

@@ -7,7 +7,7 @@ import { join } from 'path'
 import { spawnWithTimeout } from '../core/spawn-timeout.ts'
 import { detectPackageManager, isRefusal } from '../core/package-manager.ts'
 import { ALLOW_MAJOR_ENV, breakingAdvice } from '../core/update-policy.ts'
-import { installedVersion, isBehind, updateRefusal, type FleetRepo } from './scan-fleet.ts'
+import { isBehind, judgedVersion, updateRefusal, type FleetRepo } from './scan-fleet.ts'
 
 
 export const short = (name: string): string => name.replace(/^rvlib-/, '')
@@ -64,15 +64,15 @@ export async function updateFleet(behind: FleetRepo[], o: FleetUpdateOpts): Prom
         const env: Record<string, string> = Object.fromEntries(Object.entries(process.env).filter((e): e is [string, string] => e[1] != null && e[0] !== 'SHIPKIT_SELF_UPDATED' && e[0] !== ALLOW_MAJOR_ENV))
         if (o.major) env[ALLOW_MAJOR_ENV] = '1'
         const res = await spawnWithTimeout(['bun', cli, 'check', '--fresh'], { cwd: r.dir, env, timeoutMs: o.timeoutMs ?? 600_000 })
-        // judge by what node_modules carries now, never by the exit code or a
-        // printed line: the code covers every rule in that repo, and the line
-        // format belongs to whatever version that repo runs
+        // judge by what node_modules carries now (the pin, for a linked dep),
+        // never by the exit code or a printed line: the code covers every rule
+        // in that repo, and the line format belongs to whatever version that repo runs
         const stuck = wanted.filter((d) => {
-            const now = installedVersion(r.dir, d.name)
+            const now = judgedVersion(r.dir, d.name)
             return now == null || isBehind(now, d.latest!)
         })
         if (stuck.length === 0) {
-            w(`ok: ${r.name} — ${wanted.map((d) => `${short(d.name)} ${d.installed} → ${installedVersion(r.dir, d.name)}`).join(', ')}`)
+            w(`ok: ${r.name} — ${wanted.map((d) => `${short(d.name)}${d.linkedInstall ? ' pin' : ''} ${d.at} → ${judgedVersion(r.dir, d.name)}`).join(', ')}`)
             continue
         }
         failed++

package/src/home/activity-shape.ts

@@ -64,8 +64,11 @@ export type StatusCheck = {
     status: 'fail' | 'warn'
     /** when that outcome was recorded, epoch ms */
     at: number | null
-    /** the first line it printed about the problem, '' when it printed none */
+    /** the worst line it printed about the problem, '' when it printed none */
     line: string
+    /** every fail and warn line it printed, the worst weight first: a check
+     *  reporting three findings lists three */
+    lines: string[]
 }
 
 export type ActivityAnswer = { now: number; minutes: number; rows: ActivityRow[]; ms: number }

package/src/home/activity.ts

@@ -11,7 +11,7 @@
 import { gitBin } from '../core/git-bin.ts'
 import { readLastStatusReadonly } from '../ledger/run-log.ts'
 import { checkStateOf, recordOf } from '../serve/project-gutter.ts'
-import type { Line } from '../core/wire.ts'
+import { lineText, type Line } from '../core/wire.ts'
 import { MAX_COMMITS, MAX_FILES, type ActivityAnswer, type ActivityCommit, type ActivityRepo, type ActivityRow, type FileKind, type StatusCheck } from './activity-shape.ts'
 
 export * from './activity-shape.ts'
@@ -93,26 +93,32 @@ export type Declared = (name: string) => ReadonlySet<string> | null
 /** each declared check's title by id; null = not known, the id stands in */
 export type Titles = (name: string) => ReadonlyMap<string, string> | null
 
-/** the line a check printed about its problem: its first line of the same
- *  weight (a fail for a failure, a warning for a warning), else its first
- *  line that is not a pass, without the id its line leads with */
-export function findingOf(lines: string, status: 'fail' | 'warn', id: string): string {
+/** every line a check printed about its problems: its fail and warn lines,
+ *  those of its own weight first (a fail for a failure, a warning for a
+ *  warning), else its first line that is not a pass, each without the id it
+ *  leads with */
+export function findingsOf(lines: string, status: 'fail' | 'warn', id: string): string[] {
     let parsed: Line[]
     try {
         parsed = JSON.parse(lines) as Line[]
     } catch {
-        return ''
+        return []
     }
-    if (!Array.isArray(parsed)) return ''
-    const kinds = status === 'fail' ? ['fail', 'fix-fail'] : ['warn', 'fix-warn']
-    const hit = parsed.find((l) => kinds.includes(l.kind)) ?? parsed.find((l) => l.kind !== 'ok' && l.kind !== 'skip')
-    if (hit == null) return ''
-    const t = hit.text.trim()
-    // `[ID] text`, and a runner line's `ID — text`: the list names the id already
-    for (const lead of [`[${id}]`, `${id} —`]) if (t.startsWith(lead)) return t.slice(lead.length).trim()
-    return t
+    if (!Array.isArray(parsed)) return []
+    const of = (k: Line['kind']): Line[] => parsed.filter((l) => l.kind === k)
+    let hits = status === 'fail' ? [...of('fail'), ...of('warn')] : [...of('warn'), ...of('fail')]
+    if (hits.length === 0) hits = parsed.filter((l) => l.kind !== 'ok' && l.kind !== 'skip').slice(0, 1)
+    return hits.map((l) => {
+        const t = lineText(l).trim()
+        // `[ID] text`, and a runner line's `ID — text`: the list names the id already
+        for (const lead of [`[${id}]`, `${id} —`]) if (t.startsWith(lead)) return t.slice(lead.length).trim()
+        return t
+    })
 }
 
+/** the worst of them, '' when it printed none */
+export const findingOf = (lines: string, status: 'fail' | 'warn', id: string): string => findingsOf(lines, status, id)[0] ?? ''
+
 /** a repo's checks as its run record last saw them, counted over what it
  *  declares, and the failing and warning ones with what each said */
 export function statusOf(repo: ActivityRepo, declared: Declared | null = null, titles: Titles | null = null): Pick<ActivityRow, 'status' | 'failing'> {
@@ -125,7 +131,8 @@ export function statusOf(repo: ActivityRepo, declared: Declared | null = null, t
     const named = titles?.(repo.name) ?? null
     const one = (id: string, st: 'fail' | 'warn'): StatusCheck => {
         const r = byId.get(id)
-        return { id, title: named?.get(id) ?? id, status: st, at: status.since[id] ?? null, line: r == null ? '' : findingOf(r.lines, st, id) }
+        const lines = r == null ? [] : findingsOf(r.lines, st, id)
+        return { id, title: named?.get(id) ?? id, status: st, at: status.since[id] ?? null, line: lines[0] ?? '', lines }
     }
     return { status, failing: [...status.reds.map((id) => one(id, 'fail')), ...status.warns.map((id) => one(id, 'warn'))] }
 }

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

@@ -1,24 +1,94 @@
-// the shipkit window on macOS: its own app, so the dock and cmd-tab show the
-// house icon, never a second browser. One WKWebView per window on the home's
-// page; every `open -a <app> <url>` opens one more window, cmd-n too. A link
-// to another site opens in the default browser. Built once by `shipkit gui`
-// (home/gui-app.ts) with swiftc, no Xcode project.
+// one web app window on macOS: its own app, so the dock and cmd-tab show its
+// own icon, never a second browser. The same source is the shipkit window and
+// every per-process app (home/gui-app.ts builds both with swiftc, no Xcode
+// project): the bundle's Info.plist names the app (CFBundleName) and the url
+// a bare launch opens (ShipkitStartURL). One WKWebView per window; every
+// `open -a <app> <url>` opens one more window, cmd-n too. A link to another
+// site opens in the default browser.
 import AppKit
 import WebKit
 
-let homeFallback = "http://127.0.0.1:4799/"
+let info = Bundle.main.infoDictionary ?? [:]
+let appName = (info["CFBundleName"] as? String) ?? "shipkit"
+let startURL = URL(string: (info["ShipkitStartURL"] as? String) ?? "") ?? URL(string: "http://127.0.0.1:4799/")!
 
-final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKUIDelegate, NSWindowDelegate {
+/** a url that stays in the app: the machine itself, or the host the app is for */
+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 {
+    let web: WKWebView
+    let finder = NSTextFinder()
+
+    init(web: WKWebView) {
+        self.web = web
+        super.init(frame: .zero)
+        addSubview(web)
+        finder.client = web
+        finder.findBarContainer = self
+        finder.isIncrementalSearchingEnabled = true
+        finder.incrementalSearchingShouldDimContentView = false
+    }
+
+    required init?(coder: NSCoder) { fatalError("not from a nib") }
+
+    override var isFlipped: Bool { true }
+
+    var findBarView: NSView? {
+        didSet {
+            oldValue?.removeFromSuperview()
+            if let bar = findBarView { addSubview(bar) }
+            needsLayout = true
+        }
+    }
+
+    var isFindBarVisible = false {
+        didSet {
+            findBarView?.isHidden = !isFindBarVisible
+            needsLayout = true
+        }
+    }
+
+    func findBarViewDidChangeHeight() { needsLayout = true }
+
+    func contentView() -> NSView? { web }
+
+    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
+        }
+        web.frame = NSRect(x: 0, y: top, width: bounds.width, height: max(0, bounds.height - top))
+    }
+}
+
+final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKUIDelegate, NSWindowDelegate, NSMenuItemValidation {
     var windows: [NSWindow] = []
     var opened = false
 
     func applicationDidFinishLaunching(_ note: Notification) {
         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)
+                return nil
+            }
+            return e
+        }
         // an open event may deliver the url right after launch: wait for it
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
             if !self.opened {
                 let arg = CommandLine.arguments.dropFirst().first { $0.hasPrefix("http") }
-                self.open(URL(string: arg ?? homeFallback)!)
+                self.open(arg.flatMap { URL(string: $0) } ?? startURL)
             }
         }
     }
@@ -30,26 +100,27 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     func applicationShouldTerminateAfterLastWindowClosed(_ app: NSApplication) -> Bool { true }
 
     func applicationShouldHandleReopen(_ app: NSApplication, hasVisibleWindows: Bool) -> Bool {
-        if !hasVisibleWindows { open(URL(string: homeFallback)!) }
+        if !hasVisibleWindows { open(startURL) }
         return true
     }
 
+    func keyPane() -> Pane? { NSApp.keyWindow?.contentView as? Pane }
+
     @objc func newWindow(_ sender: Any?) {
-        let current = (NSApp.keyWindow?.contentView as? WKWebView)?.url
-        open(current ?? URL(string: homeFallback)!)
+        open(keyPane()?.web.url ?? startURL)
     }
 
     @objc func reload(_ sender: Any?) {
-        (NSApp.keyWindow?.contentView as? WKWebView)?.reload()
+        keyPane()?.web.reload()
     }
 
-    // the zoom is one value for every window, kept across restarts
+    // the zoom is one value for every window of the app, kept across restarts
     var zoom: CGFloat {
         get { let z = UserDefaults.standard.double(forKey: "pageZoom"); return z > 0 ? CGFloat(z) : 1 }
         set {
             let z = min(3, max(0.3, newValue))
             UserDefaults.standard.set(Double(z), forKey: "pageZoom")
-            for w in windows { (w.contentView as? WKWebView)?.pageZoom = z }
+            for w in windows { (w.contentView as? Pane)?.web.pageZoom = z }
         }
     }
 
@@ -57,19 +128,51 @@ 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)
+    }
+
+    // no public api opens the inspector: `_inspector` then `show` is the
+    // WebKit call the context menu's Inspect Element makes. Where it is gone,
+    // say where the inspector still is
+    @objc func devTools(_ sender: Any?) {
+        guard let web = keyPane()?.web else { return }
+        let get = NSSelectorFromString("_inspector"), show = NSSelectorFromString("show")
+        if web.responds(to: get), let inspector = web.perform(get)?.takeUnretainedValue() as? NSObject, inspector.responds(to: show) {
+            inspector.perform(show)
+            return
+        }
+        let alert = NSAlert()
+        alert.messageText = "This WebKit has no way to open the inspector from a menu"
+        alert.informativeText = "Right click the page and pick Inspect Element."
+        alert.runModal()
+    }
+
+    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(devTools(_:)) || item.action == #selector(reload(_:)) { return keyPane() != nil }
+        return true
+    }
+
     func open(_ url: URL) {
         opened = true
         let config = WKWebViewConfiguration()
         config.preferences.setValue(true, forKey: "developerExtrasEnabled")
         let web = WKWebView(frame: .zero, configuration: config)
+        if #available(macOS 13.3, *) { web.isInspectable = true }
         web.navigationDelegate = self
         web.uiDelegate = self
         web.allowsBackForwardNavigationGestures = true
         web.pageZoom = zoom
         let frame = NSRect(x: 0, y: 0, width: 1400, height: 900)
         let win = NSWindow(contentRect: frame, styleMask: [.titled, .closable, .miniaturizable, .resizable], backing: .buffered, defer: false)
-        win.contentView = web
-        win.title = "shipkit"
+        win.contentView = Pane(web: web)
+        win.title = appName
         win.delegate = self
         win.isReleasedWhenClosed = false
         win.setFrameAutosaveName("shipkit-window")
@@ -77,6 +180,7 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         windows.append(win)
         web.load(URLRequest(url: url))
         win.makeKeyAndOrderFront(nil)
+        win.makeFirstResponder(web)
         NSApp.activate(ignoringOtherApps: true)
     }
 
@@ -84,35 +188,40 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         windows.removeAll { $0 === note.object as? NSWindow }
     }
 
-    // the page title names the window, so cmd-tab and the window menu tell repos apart
+    // the page title names the window, so cmd-tab and the window menu tell pages apart
     func webView(_ web: WKWebView, didFinish nav: WKNavigation!) {
-        web.window?.title = (web.title?.isEmpty == false) ? web.title! : "shipkit"
+        web.window?.title = (web.title?.isEmpty == false) ? web.title! : appName
     }
 
-    // same host: stay in the window; anything else: the default browser
+    // the app's own host: stay in the window; anything else: the default browser
     func webView(_ web: WKWebView, decidePolicyFor action: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
         guard let url = action.request.url, action.navigationType == .linkActivated else { return decisionHandler(.allow) }
-        let local = url.host == "127.0.0.1" || url.host == "localhost"
-        if local { return decisionHandler(.allow) }
+        if stays(url) { return decisionHandler(.allow) }
         NSWorkspace.shared.open(url)
         decisionHandler(.cancel)
     }
 
-    // window.open and target=_blank: one more shipkit window for a local page
+    // window.open and target=_blank: one more window of this app for its own pages
     func webView(_ web: WKWebView, createWebViewWith config: WKWebViewConfiguration, for action: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView? {
         if let url = action.request.url {
-            if url.host == "127.0.0.1" || url.host == "localhost" { open(url) } else { NSWorkspace.shared.open(url) }
+            if stays(url) { open(url) } else { NSWorkspace.shared.open(url) }
         }
         return nil
     }
 
+    func item(_ menu: NSMenu, _ title: String, _ action: Selector, _ key: String, _ mods: NSEvent.ModifierFlags = [.command], tag: Int = 0) {
+        let i = menu.addItem(withTitle: title, action: action, keyEquivalent: key)
+        i.keyEquivalentModifierMask = mods
+        i.tag = tag
+    }
+
     func buildMenu() {
         let main = NSMenu()
         let appItem = NSMenuItem()
         main.addItem(appItem)
         let appMenu = NSMenu()
-        appMenu.addItem(withTitle: "Hide shipkit", action: #selector(NSApplication.hide(_:)), keyEquivalent: "h")
-        appMenu.addItem(withTitle: "Quit shipkit", action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q")
+        appMenu.addItem(withTitle: "Hide \(appName)", action: #selector(NSApplication.hide(_:)), keyEquivalent: "h")
+        appMenu.addItem(withTitle: "Quit \(appName)", action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q")
         appItem.submenu = appMenu
         let fileItem = NSMenuItem()
         main.addItem(fileItem)
@@ -130,6 +239,14 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         edit.addItem(withTitle: "Copy", action: #selector(NSText.copy(_:)), keyEquivalent: "c")
         edit.addItem(withTitle: "Paste", action: #selector(NSText.paste(_:)), keyEquivalent: "v")
         edit.addItem(withTitle: "Select All", action: #selector(NSText.selectAll(_:)), keyEquivalent: "a")
+        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)
+        edit.setSubmenu(find, for: findItem)
         editItem.submenu = edit
         let viewItem = NSMenuItem()
         main.addItem(viewItem)
@@ -141,6 +258,8 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         alsoIn.isAlternate = true
         alsoIn.keyEquivalentModifierMask = [.command]
         view.addItem(withTitle: "Zoom Out", action: #selector(zoomOut(_:)), keyEquivalent: "-")
+        view.addItem(.separator())
+        item(view, "Developer Tools", #selector(devTools(_:)), "i", [.command, .option])
         viewItem.submenu = view
         let winItem = NSMenuItem()
         main.addItem(winItem)