heyquilt 0.0.1 → 0.3.90

package/src/ai-vm.js

@@ -0,0 +1,380 @@
+// `quilt ai-vm`: the one process on a person's cloud AI machine (docs/superpowers/specs/
+// 2026-10-17-ai-vm.md). It signs in to Quilt as the person's agent with the one-time link the
+// machine was started with (its keys are made and kept here only), takes its settings and what
+// waits for it from the accounts API (routes/ai-vm.js), signs the person's AI tool in with the
+// tool's own login (ai-vm-signin.js), joins the sessions the person joins, and runs "Work on its
+// own" (autowork.js) there as "<person>'s AI". With nothing to do for a while it asks to be
+// suspended; anything for it resumes the machine where it was.
+import fs from 'node:fs'
+import path from 'node:path'
+import http from 'node:http'
+import { spawn as spawnChild, execFile } from 'node:child_process'
+import { quiltHome } from './legacy.js'
+import { saveSettings, relayUrl } from './settings.js'
+import { parseInvite } from './ui/invite.js'
+import { SIGN_IN, readSignIn, keepToken, keptToken, statusSaysSignedIn } from './ai-vm-signin.js'
+import { tokensOn } from './autowork.js'
+import { writePrivateJson } from './private-file.js'
+
+export const AGENT_NAME = 'cloud-ai'
+export const IDLE_MS = 10 * 60 * 1000
+const REPORT_MS = 60 * 1000
+const RETRY_MS = 5 * 1000
+const SIGN_IN_MS = 15 * 60 * 1000 // a sign-in nobody finishes is stopped
+const ROOM = /^[A-Za-z0-9_-]{1,64}$/
+
+/**
+ * Runs a tool's login in a terminal (the tools draw their sign-in for one), so on Linux under
+ * `script`; elsewhere (tests, a computer) with plain pipes. Returns { onData, write, kill, exited }.
+ */
+export function spawnLogin (exe, args, { env = {}, useScript = process.platform === 'linux' } = {}) {
+  const quote = (s) => `'${String(s).replace(/'/g, "'\\''")}'`
+  // A wide terminal, so a long link is printed on one line.
+  const [cmd, argv] = useScript
+    ? ['script', ['-q', '-f', '-e', '-c', `stty cols 2000 rows 50 2>/dev/null; exec ${[exe, ...args].map(quote).join(' ')}`, '/dev/null']]
+    : [exe, args]
+  const child = spawnChild(cmd, argv, { env: { ...process.env, ...env, TERM: 'xterm-256color', BROWSER: 'echo' }, stdio: ['pipe', 'pipe', 'pipe'] })
+  const listeners = []
+  const onChunk = (d) => { for (const l of listeners) l(String(d)) }
+  child.stdout.on('data', onChunk)
+  child.stderr.on('data', onChunk)
+  const exited = new Promise((resolve) => { child.on('error', () => resolve(-1)); child.on('close', (code) => resolve(code ?? -1)) })
+  return {
+    onData: (fn) => listeners.push(fn),
+    write: (text) => { try { child.stdin.write(text) } catch {} },
+    kill: () => { try { child.kill() } catch {} },
+    exited
+  }
+}
+
+/** A command's exit code and output (for the tools' status commands); -1 when it can't run. */
+function runQuiet (exe, args) {
+  return new Promise((resolve) => {
+    execFile(exe, args, { timeout: 30_000, env: process.env }, (err, stdout, stderr) => resolve({ code: err ? (typeof err.code === 'number' ? err.code : -1) : 0, output: `${stdout || ''}${stderr || ''}` }))
+  })
+}
+
+export class AiVm {
+  /**
+   * `api`: the accounts API. `home`: the machine's home folder (on its volume). Everything that
+   * reaches outside is injectable for tests: `fetch`, `login` (spawnLogin), `status` (runQuiet),
+   * `join` (runSession), `agentJoin`/`agentAccess` (agent-join.js), `autowork`, `which`.
+   */
+  constructor ({ api, joinLink = '', home = process.env.HOME, fetch: fetchImpl = globalThis.fetch, login = spawnLogin, status = runQuiet, join = null, agent = null, autowork = null, which = null, now = Date.now, log = console.log, idleMs = IDLE_MS, reportMs = REPORT_MS, port = 8080, waitParam = '1' }) {
+    this.api = String(api || '').replace(/\/+$/, '')
+    this.joinLink = joinLink
+    this.home = home
+    this.fetch = fetchImpl
+    this.login = login
+    this.status = status
+    this.joinImpl = join
+    this.agentImpl = agent
+    this.autoworkImpl = autowork
+    this.which = which || ((names) => names[0])
+    this.now = now
+    this.log = log
+    this.idleMs = idleMs
+    this.reportMs = reportMs
+    this.port = port
+    this.waitParam = waitParam
+    this.config = null
+    this.signedIn = false
+    this.signIn = null // the step the person sees
+    this.signing = null // the login running now
+    this.runs = new Map() // room -> { run, link }
+    this.lastActivity = now()
+    this.stopped = false
+    this.timers = []
+    this.dir = path.join(quiltHome(), 'ai-vm')
+  }
+
+  // ------------------------------------------------------------ the API --
+
+  async agent () {
+    if (!this.agentImpl) {
+      const m = await import('./agent-join.js')
+      this.agentImpl = { join: (o) => m.agentJoin({ ...o, fetch: this.fetch }), access: (o) => m.agentAccess({ ...o, fetch: this.fetch }), readAgent: m.readAgent }
+    }
+    return this.agentImpl
+  }
+
+  /** Joins Quilt as the person's agent with the machine's one-time link, unless it already has. */
+  async ensureAgent () {
+    const a = await this.agent()
+    try { a.readAgent({ name: AGENT_NAME }); return } catch {}
+    if (!this.joinLink) throw new Error('This machine has no Quilt agent and no link to join with (QUILT_AI_VM_JOIN).')
+    await a.join({ link: this.joinLink, name: AGENT_NAME, provider: 'Quilt cloud AI', type: 'cloud AI', description: "A person's AI on its own cloud machine", log: (l) => this.log(l) })
+  }
+
+  async call (method, route, body) {
+    const a = await this.agent()
+    const saved = await a.access({ name: AGENT_NAME })
+    const res = await this.fetch(`${this.api}${route}`, {
+      method,
+      headers: { authorization: `Bearer ${saved.accessKey}`, ...(body ? { 'content-type': 'application/json' } : {}) },
+      body: body ? JSON.stringify(body) : undefined
+    })
+    const data = await res.json().catch(() => null)
+    if (!res.ok) throw Object.assign(new Error((data && data.error) || `the API answered ${res.status}`), { status: res.status })
+    return data
+  }
+
+  // ------------------------------------------------------------- startup --
+
+  async start () {
+    fs.mkdirSync(this.dir, { recursive: true })
+    await this.ensureAgent()
+    // A kept Claude token signs Claude's runs in (it never leaves this machine).
+    const token = keptToken(this.home, 'Claude Code')
+    if (token) process.env.CLAUDE_CODE_OAUTH_TOKEN = token
+    if (this.port !== null) await this.serveHealth()
+    await this.takeNext(false)
+    for (const [room, link] of Object.entries(this.followed())) await this.follow(link).catch((err) => this.log(`could not rejoin ${room}: ${err.message}`))
+    await this.report().catch(() => {})
+    this.loop()
+    this.timers.push(setInterval(() => { this.report().catch(() => {}) }, this.reportMs))
+    this.timers.push(setInterval(() => { this.idleCheck().catch(() => {}) }, Math.min(30_000, Math.max(50, this.idleMs / 4))))
+    for (const t of this.timers) t.unref?.()
+  }
+
+  async stop () {
+    this.stopped = true
+    for (const t of this.timers) clearInterval(t)
+    if (this.signing) this.signing.kill()
+    for (const { run } of this.runs.values()) await run.stop().catch(() => {})
+    this.runs.clear()
+    if (this.health) await new Promise((resolve) => this.health.close(resolve))
+  }
+
+  /** Asks the API for what waits, over and over; a failure waits a moment and asks again. */
+  async loop () {
+    while (!this.stopped) {
+      try { await this.takeNext(true) } catch (err) {
+        if (this.stopped) return
+        this.log(`could not reach Quilt: ${err.message}`)
+        await new Promise((resolve) => setTimeout(resolve, RETRY_MS))
+      }
+    }
+  }
+
+  /** One look at what waits: settings, a sign-in to start, a code, sessions to join or leave. */
+  async takeNext (wait) {
+    const n = await this.call('GET', `/v1/ai-vm/next${wait ? `?wait=${this.waitParam}` : ''}`)
+    if (this.stopped) return n
+    const changedTool = !this.config || this.config.tool !== n.config.tool
+    this.applyConfig(n.config)
+    const busy = n.signIn || n.code || n.follow.length || n.leave.length
+    if (busy) this.lastActivity = this.now()
+    if (changedTool) {
+      this.signedIn = await this.checkSignedIn()
+      this.signIn = null
+      // A machine that isn't signed in starts the sign-in by itself, so the app has a link to show.
+      if (!this.signedIn && !n.signIn) await this.startSignIn()
+    }
+    if (n.signIn) await this.startSignIn()
+    if (n.code) this.giveCode(n.code)
+    for (const link of n.follow) await this.follow(link).catch((err) => this.log(`could not join: ${err.message}`))
+    for (const room of n.leave) await this.leave(room).catch((err) => this.log(`could not leave ${room}: ${err.message}`))
+    if (busy || changedTool) await this.report().catch(() => {})
+    return n
+  }
+
+  /** The person's settings, as this machine's own "Work on its own" settings. */
+  applyConfig (c) {
+    this.config = c
+    saveSettings({ tool: c.tool, autoWork: 'auto', autoFiles: true, autoModel: c.model || undefined, autoCap: c.cap || undefined, autoPrompt: c.prompt || undefined })
+  }
+
+  // ------------------------------------------------------------- sign-in --
+
+  async checkSignedIn () {
+    const tool = this.config && this.config.tool
+    const t = SIGN_IN[tool]
+    if (!t) return false
+    if (t.status.file) return !!keptToken(this.home, tool)
+    const exe = this.which(t.exe)
+    if (!exe) return false
+    const r = await this.status(exe, t.status.args)
+    return statusSaysSignedIn(tool, r.code, r.output)
+  }
+
+  /** Runs the tool's own login; what the person must see goes to the app through the API. */
+  async startSignIn () {
+    const tool = this.config && this.config.tool
+    const t = SIGN_IN[tool]
+    if (!t) return
+    if (this.signing) this.signing.kill()
+    const exe = this.which(t.exe)
+    if (!exe) { this.setStep({ step: 'failed', error: `${tool} isn't installed on this machine` }); return }
+    let out = ''
+    let shown = ''
+    const proc = this.login(exe, t.args, { env: t.env })
+    this.signing = proc
+    this.lastActivity = this.now()
+    this.setStep({ step: 'starting' })
+    const timer = setTimeout(() => proc.kill(), SIGN_IN_MS)
+    timer.unref?.()
+    proc.onData((d) => {
+      out = (out + d).slice(-64 * 1024)
+      const r = readSignIn(tool, out)
+      if (r.token) {
+        keepToken(this.home, tool, r.token)
+        process.env.CLAUDE_CODE_OAUTH_TOKEN = r.token
+      }
+      const key = `${r.url}\n${r.code}`
+      if (r.url && key !== shown && this.signIn?.step !== 'waiting') {
+        shown = key
+        this.setStep({ step: r.code ? 'code' : 'link', url: r.url, code: r.code, needsCode: r.needsCode })
+      }
+    })
+    proc.exited.then(async (code) => {
+      clearTimeout(timer)
+      if (this.signing !== proc) return
+      this.signing = null
+      this.signedIn = await this.checkSignedIn()
+      this.lastActivity = this.now()
+      this.setStep(this.signedIn ? { step: 'done' } : { step: 'failed', error: `${tool}'s sign-in stopped (exit ${code}); start it again` })
+    })
+  }
+
+  /** The code the person pasted, typed into the tool's login. */
+  giveCode (code) {
+    if (!this.signing) { this.log('a sign-in code came with no sign-in running'); return }
+    this.signing.write(`${code}\r`)
+    this.setStep({ ...(this.signIn || {}), step: 'waiting', needsCode: false })
+  }
+
+  setStep (step) {
+    this.signIn = { url: '', code: '', needsCode: false, error: '', ...step }
+    this.report().catch(() => {})
+  }
+
+  // ------------------------------------------------------------ sessions --
+
+  followedFile () { return path.join(this.dir, 'sessions.json') }
+  /** The sessions this machine follows: room -> link (kept on its own disk, never by the API). */
+  followed () { try { return JSON.parse(fs.readFileSync(this.followedFile(), 'utf8')) || {} } catch { return {} } }
+  saveFollowed (map) { writePrivateJson(this.followedFile(), map) }
+
+  async join (opts) {
+    if (this.joinImpl) return this.joinImpl(opts)
+    const { runSession } = await import('./runner.js')
+    return runSession(opts)
+  }
+
+  async autowork () {
+    if (this.autoworkImpl) return this.autoworkImpl
+    const { autowork } = await import('./autowork.js')
+    this.autoworkImpl = autowork()
+    return this.autoworkImpl
+  }
+
+  /** Joins a session the person joined (again, after a restart), as their cloud AI. */
+  async follow (link) {
+    const invite = parseInvite(link, { allowRelay: () => true })
+    const room = invite.room
+    if (this.runs.has(room)) return
+    const { sessionPasses } = await import('./pass-source.js')
+    const auth = sessionPasses({ agent: AGENT_NAME })
+    const dir = path.join(this.home, 'projects', room)
+    const run = await this.join({
+      dir,
+      conn: { server: invite.relay || relayUrl(), room, secret: invite.secret },
+      name: auth.name,
+      tool: (this.config && this.config.tool) || 'Quilt cloud AI',
+      kind: 'agent',
+      passes: auth.passes,
+      identity: auth.identity,
+      agentFeed: false,
+      onLog: (line) => this.log(`[${room}] ${line}`),
+      onFatal: (err) => { this.log(`[${room}] stopped: ${err.message}`); this.runs.delete(room) }
+    })
+    this.runs.set(room, { run, link })
+    // What reaches it in the session counts as activity: the machine stays up while there is work.
+    if (run.session && run.session.on) {
+      run.session.on('inbox', () => { this.lastActivity = this.now() })
+      run.session.on('message', () => { this.lastActivity = this.now() })
+    }
+    this.saveFollowed({ ...this.followed(), [room]: link })
+    this.lastActivity = this.now()
+    this.log(`joined ${room}`)
+  }
+
+  /** Leaves a session the person left for good, and frees its folder. */
+  async leave (room) {
+    if (!ROOM.test(String(room))) return
+    const r = this.runs.get(room)
+    this.runs.delete(room)
+    if (r) await r.run.stop().catch(() => {})
+    const kept = this.followed()
+    delete kept[room]
+    this.saveFollowed(kept)
+    fs.rmSync(path.join(this.home, 'projects', room), { recursive: true, force: true })
+    this.log(`left ${room}`)
+  }
+
+  // --------------------------------------------------- reports and idle --
+
+  async report () {
+    const work = await this.autowork()
+    const log = work.log ? work.log() : []
+    const today = log.filter((e) => new Date(e.ts).toISOString().slice(0, 10) === new Date(this.now()).toISOString().slice(0, 10))
+    const sessions = [...this.runs.entries()].map(([room, { run }]) => ({ room, name: (run.session && run.session.sessionName) || '' }))
+    return this.call('POST', '/v1/ai-vm/report', {
+      signedIn: this.signedIn,
+      ...(this.signIn ? { signIn: this.signIn } : {}),
+      sessions,
+      usageToday: { tokens: tokensOn(log, this.now()), runs: today.length }
+    })
+  }
+
+  /** Whether anything runs or waits here now. */
+  async busy () {
+    if (this.signing) return true
+    const work = await this.autowork()
+    return !!(work.running || (work.queue && work.queue.length))
+  }
+
+  /** Nothing to do for a while: ask to be suspended. The machine resumes here when woken. */
+  async idleCheck () {
+    if (this.stopped) return false
+    if (await this.busy()) { this.lastActivity = this.now(); return false }
+    if (this.now() - this.lastActivity < this.idleMs) return false
+    this.lastActivity = this.now()
+    try {
+      await this.call('POST', '/v1/ai-vm/idle', {})
+      this.log('idle: suspending')
+      return true
+    } catch (err) {
+      if (err.status !== 409) this.log(`could not suspend: ${err.message}`)
+      return false
+    }
+  }
+
+  serveHealth () {
+    this.health = http.createServer((req, res) => {
+      if (req.url !== '/healthz') { res.writeHead(404); return res.end() }
+      res.writeHead(200, { 'content-type': 'application/json' })
+      res.end(JSON.stringify({ ok: true, tool: this.config?.tool || '', signedIn: this.signedIn, sessions: [...this.runs.keys()] }))
+    })
+    return new Promise((resolve) => this.health.listen(this.port, '0.0.0.0', resolve))
+  }
+}
+
+/** Finds the first of `names` on PATH. */
+export function onPath (names, { env = process.env } = {}) {
+  for (const n of names) for (const d of String(env.PATH || '').split(path.delimiter)) if (d && fs.existsSync(path.join(d, n))) return path.join(d, n)
+  return null
+}
+
+/** `quilt ai-vm`, from the machine's environment. */
+export async function runAiVm (env = process.env) {
+  if (!env.QUILT_API) throw new Error('QUILT_API is not set: this command runs on a cloud AI machine Quilt started.')
+  const vm = new AiVm({ api: env.QUILT_API, joinLink: env.QUILT_AI_VM_JOIN || '', home: env.HOME, which: (names) => onPath(names), port: Number(env.PORT || 8080) })
+  const shutdown = async () => { await vm.stop(); process.exit(0) }
+  process.on('SIGINT', shutdown)
+  process.on('SIGTERM', shutdown)
+  await vm.start()
+  console.log('quilt ai-vm: running')
+  return vm
+}

package/src/api/access.js

@@ -0,0 +1,75 @@
+// Access types and grants for the API's routes: finding a type (a built-in, or one of
+// the owner's own) and what a grant comes to.
+import { UUID } from './http.js'
+import { builtinType, effectiveAccess, FALLBACK_TYPE } from '../session-access.js'
+import { workspaceAccess } from './workspace-access.js'
+import { orgGrantsFor } from './org-access.js'
+
+// The owner's access, as a pass carries it. The relay keeps its own record of who owns a
+// room; this only says the API agrees.
+export const OWNER_ACCESS = Object.freeze({ owner: true, files: 'edit', folders: Object.freeze([]), foldersExcept: Object.freeze([]), talk: true })
+
+/** A built-in, or one of `ownerAccount`'s own types; null otherwise (someone else's, or none). */
+export async function ownType (store, ownerAccount, typeId) {
+  const id = String(typeId || '')
+  const b = builtinType(id)
+  if (b) return b
+  if (!UUID.test(id)) return null
+  const t = await store.accessTypeById(id)
+  return t && t.ownerAccount === ownerAccount ? t : null
+}
+
+/** A grant's type: View only when its own is gone (deleted while this was read). */
+export async function typeOfGrant (store, grant) {
+  return builtinType(grant.typeId) || (UUID.test(grant.typeId) && await store.accessTypeById(grant.typeId)) || builtinType(FALLBACK_TYPE)
+}
+
+/** A grant as the owner sees it: its type's name and what it comes to. */
+export async function grantView (store, grant) {
+  const type = await typeOfGrant(store, grant)
+  return { account: grant.account, typeId: type.id, typeName: type.name, tighten: grant.tighten || {}, access: effectiveAccess(type, grant.tighten), updatedAt: grant.updatedAt }
+}
+
+/**
+ * What `account` may do in `room`, for its pass: the owner's access, its grant's, or null
+ * (no grant: the owner lets them in, or not). `email` is a person's confirmed sign-in
+ * address: an open invite to it becomes their grant now, and the invite is used.
+ */
+export async function roomAccess (store, room, account, email = '') {
+  return (await roomAccessFrom(store, room, account, email)).access
+}
+
+/**
+ * roomAccess, and where it comes from, for the session's member list: { kind: 'owner' },
+ * { kind: 'grant' } (let in here), { kind: 'workspace', via, workspace } or { kind: 'org',
+ * workspace, org }. { access: null, from: null } when there's none.
+ */
+export async function roomAccessFrom (store, room, account, email = '') {
+  const none = { access: null, from: null }
+  const session = await store.sessionByRoom(room)
+  if (!session) return none
+  if (session.ownerAccount === account) return { access: OWNER_ACCESS, from: { kind: 'owner' } }
+  if (email) await store.claimEmailInvites(room, email.toLowerCase(), account)
+  const grant = await store.grantFor(room, account)
+  if (grant) {
+    await store.useAccountInvites(room, account)
+    return { access: effectiveAccess(await typeOfGrant(store, grant), grant.tighten), from: { kind: 'grant' } }
+  }
+  // No grant of its own: a session inside a workspace admits the workspace's people, but
+  // only when its owner (as the relay reports it) put it there. Anyone else's link, or one
+  // made before the relay has named an owner, lets nobody in.
+  if (!session.workspaceId || !session.ownerAccount || session.ownerAccount !== session.workspaceLinkedBy) return none
+  // A workspace's agents are invited to its sessions (sent the link), never let in by it:
+  // like anyone with a link they wait, and the session owner lets them in (a grant, above).
+  if (account.startsWith('agent:')) return none
+  const ws = await store.workspaceById(session.workspaceId)
+  if (!ws) return none
+  const wa = await workspaceAccess(store, ws, account, { orgGrants: ws.orgId ? await orgGrantsFor(store, ws.orgId, account) : null })
+  if (!wa) return none
+  const access = effectiveAccess(builtinType(wa.access === 'edit' ? 'builtin:edit' : 'builtin:view'), {})
+  if (wa.via === 'org') {
+    const org = ws.orgId ? await store.orgById(ws.orgId) : null
+    return { access, from: { kind: 'org', workspace: ws.name || '', org: org?.name || '' } }
+  }
+  return { access, from: { kind: 'workspace', via: wa.via, workspace: ws.name || '' } }
+}

package/src/api/activity.js

@@ -0,0 +1,181 @@
+// Time spent in sessions, from the visits the relay reports (see routes/relay.js).
+// Pure: the API's routes hand it rows from the store and the time now. Times are
+// epoch ms; an interval is [start, end) and a list of them is kept sorted and merged.
+
+export const DAY_MS = 24 * 60 * 60 * 1000
+export const MAX_SESSIONS = 100
+export const MAX_PEOPLE_TOP = 3
+export const MAX_COLLABORATORS = 30
+export const MAX_VISITS = 20
+
+/** Sorted, overlapping and touching intervals joined, empty ones dropped. */
+export function merge (intervals) {
+  const sorted = intervals.filter(([s, e]) => e > s).sort((a, b) => a[0] - b[0])
+  const out = []
+  for (const [s, e] of sorted) {
+    const last = out[out.length - 1]
+    if (last && s <= last[1]) last[1] = Math.max(last[1], e)
+    else out.push([s, e])
+  }
+  return out
+}
+
+/** Where two merged lists overlap, as a merged list. */
+export function intersect (a, b) {
+  const out = []
+  let i = 0
+  let j = 0
+  while (i < a.length && j < b.length) {
+    const s = Math.max(a[i][0], b[j][0])
+    const e = Math.min(a[i][1], b[j][1])
+    if (e > s) out.push([s, e])
+    if (a[i][1] < b[j][1]) i++
+    else j++
+  }
+  return out
+}
+
+/** A merged list cut to [from, to). */
+export function clip (list, from, to) {
+  return list.map(([s, e]) => [Math.max(s, from), Math.min(e, to)]).filter(([s, e]) => e > s)
+}
+
+export const total = (list) => list.reduce((n, [s, e]) => n + (e - s), 0)
+
+/** A visit as an interval: an open visit runs until now. */
+const span = (v, now) => [v.startedAt, v.endedAt == null ? now : Math.min(v.endedAt, now)]
+
+const formatters = new Map()
+function partsIn (t, tz) {
+  let f = formatters.get(tz)
+  if (!f) {
+    f = new Intl.DateTimeFormat('en-US', { timeZone: tz, hourCycle: 'h23', weekday: 'short', year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric' })
+    formatters.set(tz, f)
+  }
+  const p = Object.fromEntries(f.formatToParts(new Date(t)).map((x) => [x.type, x.value]))
+  return { year: +p.year, month: +p.month, day: +p.day, hour: +p.hour, minute: +p.minute, second: +p.second, weekday: p.weekday }
+}
+
+/** Whether `tz` is an IANA time zone this runtime knows ("Europe/Paris", "UTC"). */
+export function isTimeZone (tz) {
+  if (typeof tz !== 'string' || !tz || tz.length > 64) return false
+  try { new Intl.DateTimeFormat('en-US', { timeZone: tz }).format(0); return true } catch { return false }
+}
+
+/** How far `tz` is ahead of UTC at `t`, in ms. */
+export function zoneOffset (t, tz) {
+  const p = partsIn(t, tz)
+  return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second) - Math.floor(t / 1000) * 1000
+}
+
+/** 00:00 on a calendar day in `tz` (month 1-12; days past the month's end roll over). */
+export function midnightIn (year, month, day, tz) {
+  const guess = Date.UTC(year, month - 1, day)
+  const first = guess - zoneOffset(guess, tz)
+  return guess - zoneOffset(first, tz)
+}
+
+const WEEKDAYS = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+/** Monday 00:00 of the week `now` falls in, in `tz`. */
+export function weekStart (now, tz) {
+  const p = partsIn(now, tz)
+  return midnightIn(p.year, p.month, p.day - WEEKDAYS.indexOf(p.weekday), tz)
+}
+
+/** The 1st of the month `now` falls in, 00:00 in `tz`. */
+export function monthStart (now, tz) {
+  const p = partsIn(now, tz)
+  return midnightIn(p.year, p.month, 1, tz)
+}
+
+/** The newest name an account went by in these rows. */
+function latest (rows) {
+  return rows.reduce((a, b) => (b.startedAt > a.startedAt ? b : a))
+}
+
+/**
+ * The dashboard: for `me` ('person:<id>'), each session in `sessions` I was in, my
+ * time there and the people and agents whose visits overlapped mine; plus my time
+ * collaborating this week and who I worked with most this month (both in `tz`).
+ * `visits` are every visit in those sessions. Nobody I never overlapped with appears.
+ */
+export function summarize ({ me, sessions, visits, now, tz = 'UTC' }) {
+  const byRoom = new Map()
+  for (const v of visits) {
+    if (!byRoom.has(v.room)) byRoom.set(v.room, [])
+    byRoom.get(v.room).push(v)
+  }
+  const collab = [] // time I overlapped anyone, across every session
+  const together = new Map() // account -> { name, kind, spans } across every session
+  const rows = []
+  for (const s of sessions) {
+    const inRoom = byRoom.get(s.room) || []
+    const mineRows = inRoom.filter((v) => v.account === me)
+    if (!mineRows.length) continue
+    const mine = merge(mineRows.map((v) => span(v, now)))
+    const others = new Map()
+    for (const v of inRoom) {
+      if (v.account === me) continue
+      if (!others.has(v.account)) others.set(v.account, [])
+      others.get(v.account).push(v)
+    }
+    collab.push(...intersect(mine, merge(inRoom.filter((v) => v.account !== me).map((v) => span(v, now)))))
+    const people = []
+    for (const [account, theirs] of others) {
+      const both = intersect(mine, merge(theirs.map((v) => span(v, now))))
+      const ms = total(both)
+      if (ms <= 0) continue
+      const last = latest(theirs)
+      people.push({ account, name: last.accountName, kind: last.kind, togetherMs: ms, lastTogetherAt: both[both.length - 1][1] })
+      const t = together.get(account) || { name: last.accountName, kind: last.kind, at: 0, spans: [] }
+      if (last.startedAt >= t.at) Object.assign(t, { name: last.accountName, kind: last.kind, at: last.startedAt })
+      t.spans.push(...both)
+      together.set(account, t)
+    }
+    people.sort((a, b) => b.togetherMs - a.togetherMs || a.name.localeCompare(b.name))
+    const ownerRows = s.ownerAccount ? inRoom.filter((v) => v.account === s.ownerAccount) : []
+    const open = inRoom.some((v) => v.endedAt == null)
+    rows.push({
+      room: s.room,
+      name: s.name || '',
+      owner: { name: ownerRows.length ? latest(ownerRows).accountName : '' },
+      mine: !!s.ownerAccount && s.ownerAccount === me,
+      createdAt: s.createdAt,
+      lastActiveAt: open ? now : s.lastActiveAt,
+      myTotalMs: total(mine),
+      people
+    })
+  }
+  rows.sort((a, b) => b.lastActiveAt - a.lastActiveAt || a.room.localeCompare(b.room))
+  const week = weekStart(now, tz)
+  const month = monthStart(now, tz)
+  const topCollaborators = [...together].map(([account, t]) => ({ account, name: t.name, kind: t.kind, ms: total(clip(merge(t.spans), month, now)) }))
+    .filter((c) => c.ms > 0)
+    .sort((a, b) => b.ms - a.ms || a.name.localeCompare(b.name))
+    .slice(0, MAX_PEOPLE_TOP)
+  return {
+    totals: { collaboratingThisWeek: total(clip(merge(collab), week, now)), topCollaborators },
+    sessions: rows.slice(0, MAX_SESSIONS)
+  }
+}
+
+/** Everyone I've overlapped with in these sessions, most recent first (for invites). */
+export function collaborators (sessions) {
+  const seen = new Map()
+  for (const s of sessions) {
+    for (const p of s.people) {
+      const was = seen.get(p.account)
+      if (!was || p.lastTogetherAt > was.lastTogetherAt) seen.set(p.account, { account: p.account, name: p.name, kind: p.kind, lastTogetherAt: p.lastTogetherAt })
+    }
+  }
+  return [...seen.values()].sort((a, b) => b.lastTogetherAt - a.lastTogetherAt).slice(0, MAX_COLLABORATORS)
+}
+
+/** My last visits to one session, newest first. */
+export function myVisits ({ me, visits }) {
+  return visits.filter((v) => v.account === me)
+    .sort((a, b) => b.startedAt - a.startedAt)
+    .slice(0, MAX_VISITS)
+    .map((v) => ({ startedAt: v.startedAt, endedAt: v.endedAt ?? null }))
+}