kira-glasses-bridge 2.10.0 → 2.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "description": "Connects your Mac to Kira, the assistant for Even G2 glasses: Claude Code sessions, files, folders and apps, by voice.",
   "type": "module",
   "bin": {
@@ -28,5 +28,5 @@
     "kira"
   ],
   "license": "MIT",
-  "homepage": "https://hackchild.xyz/kira"
+  "homepage": "https://kira.glass"
 }

package/src/claude-sessions.mjs

@@ -1,42 +1,13 @@
-// Reads Claude Code's own session transcripts under ~/.claude/projects.
-// Each session is a .jsonl file; the entries we care about are user and
-// assistant messages, the ai-title entries, and cwd.
-import { readdir, readFile, stat } from 'node:fs/promises'
+// Claude Code's sessions on this Mac, read through the Agent SDK (listSessions, getSessionInfo,
+// getSessionMessages) rather than by parsing ~/.claude/projects ourselves: the transcript format
+// is Claude Code's own and changes between releases, and the SDK changes with it.
+import { getSessionInfo, getSessionMessages, listSessions as sdkListSessions } from '@anthropic-ai/claude-agent-sdk'
+import { open, readdir, stat } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { basename, join } from 'node:path'
 
-const PROJECTS = join(homedir(), '.claude', 'projects')
 const ACTIVE_WINDOW_MS = 3 * 60 * 1000
 
-async function sessionFiles() {
-  const out = []
-  let dirs = []
-  try {
-    dirs = await readdir(PROJECTS)
-  } catch {
-    return out
-  }
-  for (const d of dirs) {
-    let files = []
-    try {
-      files = await readdir(join(PROJECTS, d))
-    } catch {
-      continue
-    }
-    for (const f of files) {
-      if (!f.endsWith('.jsonl')) continue
-      const path = join(PROJECTS, d, f)
-      try {
-        const st = await stat(path)
-        if (st.size > 0) out.push({ path, mtime: st.mtimeMs, size: st.size })
-      } catch {
-        /* skip */
-      }
-    }
-  }
-  return out.sort((a, b) => b.mtime - a.mtime)
-}
-
 function textOf(message) {
   const c = message?.content
   if (typeof c === 'string') return c
@@ -44,52 +15,60 @@ function textOf(message) {
   return ''
 }
 
-/** Parse a transcript; only the last `tailBytes` are read for speed. */
-async function summarize(file, tailBytes = 400_000) {
-  const st = await stat(file.path)
-  const buf = await readFile(file.path)
-  const slice = buf.length > tailBytes ? buf.subarray(buf.length - tailBytes) : buf
-  const lines = slice.toString('utf8').split('\n')
-  if (buf.length > tailBytes) lines.shift() // drop a partial first line
-  let sessionId = file.path.split('/').pop().replace(/\.jsonl$/, '')
-  let cwd = null
-  let title = null
+/** The conversation as said: user and Claude text, without tool results, system blocks or subagents. */
+async function turnsOf(sessionId, dir) {
+  const messages = await getSessionMessages(sessionId, dir ? { dir } : undefined)
   const turns = []
-  for (const line of lines) {
-    if (!line) continue
-    let d
+  for (const m of messages) {
+    if (m.parent_tool_use_id) continue
+    const text = textOf(m.message).trim()
+    if (!text || text.startsWith('<')) continue // tool results / system blocks
+    turns.push({ role: m.type === 'user' ? 'user' : 'claude', text, at: m.timestamp ?? null })
+  }
+  return turns
+}
+
+/**
+ * The SDK reads a session's folder from the start of its transcript, and misses it when the
+ * transcript opens with large snapshot entries. Then: the first "cwd" in the first MB of the file.
+ */
+async function cwdOf(s) {
+  if (s.cwd) return s.cwd
+  const projects = join(homedir(), '.claude', 'projects')
+  for (const d of await readdir(projects).catch(() => [])) {
+    const fh = await open(join(projects, d, `${s.sessionId}.jsonl`)).catch(() => null)
+    if (!fh) continue
     try {
-      d = JSON.parse(line)
-    } catch {
-      continue
-    }
-    if (d.sessionId) sessionId = d.sessionId
-    if (d.cwd) cwd = d.cwd
-    if (d.type === 'ai-title' && typeof d.aiTitle === 'string') title = d.aiTitle
-    if ((d.type === 'user' || d.type === 'assistant') && d.message) {
-      const text = textOf(d.message).trim()
-      if (!text || text.startsWith('<') ) continue // skip tool results / system blocks
-      turns.push({ role: d.type === 'user' ? 'user' : 'claude', text, at: d.timestamp ?? null })
+      const buf = Buffer.alloc(1 << 20)
+      const { bytesRead } = await fh.read(buf, 0, buf.length, 0)
+      const m = /"cwd":"((?:[^"\\]|\\.)*)"/.exec(buf.subarray(0, bytesRead).toString('utf8'))
+      return m ? JSON.parse(`"${m[1]}"`) : null
+    } finally {
+      await fh.close()
     }
   }
-  return { sessionId, cwd, title, turns, lastActiveAt: new Date(st.mtimeMs).toISOString(), active: Date.now() - st.mtimeMs < ACTIVE_WINDOW_MS }
+  return null
 }
 
+const titleOf = s => s.customTitle || s.summary || s.firstPrompt || null
+const activeOf = s => Date.now() - s.lastModified < ACTIVE_WINDOW_MS
+
 export async function listSessions(max = 10) {
-  const files = (await sessionFiles()).slice(0, Math.min(Math.max(Number(max) || 10, 1), 20))
+  const n = Math.min(Math.max(Number(max) || 10, 1), 20)
   const sessions = []
-  for (const f of files) {
+  for (const s of await sdkListSessions({ limit: n })) {
     try {
-      const s = await summarize(f, 120_000)
-      const lastUser = [...s.turns].reverse().find(t => t.role === 'user')
-      const lastClaude = [...s.turns].reverse().find(t => t.role === 'claude')
+      const cwd = await cwdOf(s)
+      const turns = await turnsOf(s.sessionId, cwd)
+      const lastUser = [...turns].reverse().find(t => t.role === 'user')
+      const lastClaude = [...turns].reverse().find(t => t.role === 'claude')
       sessions.push({
         session_id: s.sessionId,
-        title: s.title ?? (lastUser ? lastUser.text.slice(0, 60) : '(untitled)'),
-        project: s.cwd ? s.cwd.split('/').slice(-2).join('/') : null,
-        cwd: s.cwd,
-        active: s.active,
-        last_active_at: s.lastActiveAt,
+        title: titleOf(s) ?? (lastUser ? lastUser.text.slice(0, 60) : '(untitled)'),
+        project: cwd ? cwd.split('/').slice(-2).join('/') : null,
+        cwd,
+        active: activeOf(s),
+        last_active_at: new Date(s.lastModified).toISOString(),
         last_user_message: lastUser ? lastUser.text.slice(0, 200) : null,
         last_claude_message: lastClaude ? lastClaude.text.slice(0, 200) : null,
       })
@@ -101,49 +80,31 @@ export async function listSessions(max = 10) {
 }
 
 export async function readSession(sessionId, turns = 6) {
-  const files = await sessionFiles()
-  const file = files.find(f => f.path.endsWith(`/${sessionId}.jsonl`))
-  if (!file) return { error: `No session ${sessionId} on this machine` }
-  const s = await summarize(file)
+  const info = await getSessionInfo(sessionId).catch(() => undefined)
+  if (!info) return { error: `No session ${sessionId} on this machine` }
+  const cwd = await cwdOf(info)
+  const all = await turnsOf(sessionId, cwd)
   const n = Math.min(Math.max(Number(turns) || 6, 1), 30)
-  return { session_id: s.sessionId, title: s.title, cwd: s.cwd, active: s.active, last_active_at: s.lastActiveAt, turns: s.turns.slice(-n).map(t => ({ ...t, text: t.text.slice(0, 2000) })) }
+  return { session_id: info.sessionId, title: titleOf(info), cwd, active: activeOf(info), last_active_at: new Date(info.lastModified).toISOString(), turns: all.slice(-n).map(t => ({ ...t, text: t.text.slice(0, 2000) })) }
 }
 
-/**
- * Project folders Claude Code has been used in, newest first. One cheap read
- * per project: the head of its newest transcript carries the cwd.
- */
+/** Project folders Claude Code has been used in (that still exist), newest first. */
 export async function listProjects(max = 20) {
   const n = Math.min(Math.max(Number(max) || 20, 1), 50)
-  let dirs = []
-  try {
-    dirs = await readdir(PROJECTS)
-  } catch {
-    return { count: 0, projects: [] }
+  const byCwd = new Map()
+  for (const s of await sdkListSessions()) {
+    if (!s.cwd) continue
+    const p = byCwd.get(s.cwd) ?? { sessions: 0, last: 0 }
+    p.sessions++
+    p.last = Math.max(p.last, s.lastModified)
+    byCwd.set(s.cwd, p)
   }
   const projects = []
-  for (const d of dirs) {
-    const dir = join(PROJECTS, d)
-    let files = []
-    try {
-      files = (await readdir(dir)).filter(f => f.endsWith('.jsonl'))
-    } catch {
-      continue
-    }
-    let newest = null
-    for (const f of files) {
-      const st = await stat(join(dir, f)).catch(() => null)
-      if (st && st.size > 0 && (!newest || st.mtimeMs > newest.mtime)) newest = { path: join(dir, f), mtime: st.mtimeMs }
-    }
-    if (!newest) continue
-    const head = (await readFile(newest.path)).subarray(0, 65536).toString('utf8')
-    const m = /"cwd":"((?:[^"\\]|\\.)*)"/.exec(head)
-    if (!m) continue
-    const cwd = JSON.parse(`"${m[1]}"`)
+  for (const [cwd, p] of [...byCwd].sort((a, b) => b[1].last - a[1].last)) {
+    if (projects.length >= n) break
     const exists = await stat(cwd).then(st => st.isDirectory()).catch(() => false)
     if (!exists) continue
-    projects.push({ cwd, name: basename(cwd), parent: basename(join(cwd, '..')), sessions: files.length, last_active_at: new Date(newest.mtime).toISOString(), _mtime: newest.mtime })
+    projects.push({ cwd, name: basename(cwd), parent: basename(join(cwd, '..')), sessions: p.sessions, last_active_at: new Date(p.last).toISOString() })
   }
-  projects.sort((a, b) => b._mtime - a._mtime)
-  return { count: Math.min(projects.length, n), projects: projects.slice(0, n).map(({ _mtime, ...p }) => p) }
+  return { count: projects.length, projects }
 }

package/src/index.mjs

@@ -9,6 +9,7 @@ import { agentById, AGENTS } from './agents/index.mjs'
 import { normalizeAnswer } from './agents/protocol.mjs'
 import { openApp, installedApps } from './apps.mjs'
 import { listFiles, readUserFile, createFolder, writeUserFile, trashPath, resolveUserPath } from './files.mjs'
+import { initTerminals, terminalCall, terminalMessage, terminalsOffline } from './terminals.mjs'
 import { prepareWorktree, worktreeStatus, pushWorktree, removeWorktree, repoOfFolder, stageFiles, listOutputs, uploadOutputs } from './worktrees.mjs'
 
 import { createRequire } from 'node:module'
@@ -40,6 +41,9 @@ const ANSWER_TIMEOUT_MS = 3 * 60 * 1000
  * token is rejected); an app embedding it (the Kira desktop app) passes its own:
  *   log(line)               every log line
  *   onStatus(status)        'connecting' | 'connected' | 'disconnected' | 'rejected'
+ *   openTerminal({ cwd, command })   open_terminal in the app's own terminal (a Kira tab), not
+ *                           Terminal.app; resolves to what to report, or null to fall back
+ *   terminals               the app's shells, for remote devices (terminals.mjs)
  */
 let hooks = {}
 let stopped = false
@@ -55,6 +59,8 @@ export function startBridge(config, hostHooks = {}) {
     throw new Error('No token. Run: npx kira-glasses-bridge --token <token>  (from the Kira portal → Connections → Claude Code)')
   }
   stopped = false
+  // Terminal output is live or nothing: never queued for later like job events.
+  initTerminals(() => hooks.terminals ?? null, obj => live?.readyState === WebSocket.OPEN && live.send(JSON.stringify(obj)))
   log(`kira-bridge ${BRIDGE_VERSION} · agents: ${Object.keys(AGENTS).join(', ')}`)
   connect()
 }
@@ -185,10 +191,18 @@ const tools = {
     return setupProjectFolder({ dir, name: args.name, description: args.description, sshUrl: args.ssh_url, httpsUrl: args.https_url })
   },
 
-  /** Open Terminal on this Mac in a folder and run a command there (used to hand a Claude session to the person). */
+  /** This Mac's shells for a browser elsewhere (only inside the Mac app, only when switched on there). */
+  terminal: args => terminalCall(args),
+
+  /** Open a terminal on this Mac in a folder and run a command there (used to hand a Claude session
+   *  to the person): a Kira tab when the bridge runs inside the Mac app, else Terminal.app. */
   async open_terminal(args) {
     const dir = resolveUserPath(String(args.cwd ?? ''))
     const command = String(args.command ?? '').replace(/[^\w\s./:@=-]/g, '')
+    if (hooks.openTerminal) {
+      const r = await Promise.resolve(hooks.openTerminal({ cwd: dir, command })).catch(err => ({ error: err?.message ?? String(err) }))
+      if (r) return { ...r, cwd: display(dir), command }
+    }
     if (process.platform !== 'darwin') return { error: 'opening a terminal is only supported on macOS' }
     const { execFile } = await import('node:child_process')
     const script = `tell application "Terminal"
@@ -313,6 +327,7 @@ function connect() {
       }
       return
     }
+    if (terminalMessage(msg)) return
     if (msg.type !== 'call') return
     const fn = tools[msg.tool]
     if (!fn) return send(ws, { type: 'error', id: msg.id, error: `unknown tool ${msg.tool}` })
@@ -325,6 +340,7 @@ function connect() {
   ws.on('close', (code, reason) => {
     clearInterval(ping)
     if (live === ws) live = null
+    terminalsOffline()
     if (code === 4001) {
       log('token rejected; create a new one in the portal')
       status('rejected')

package/src/terminals.mjs

@@ -0,0 +1,157 @@
+// Remote terminals: this Mac's shells for a browser at kira.glass, relayed by the API. Only when
+// the bridge runs inside the Kira Mac app (it passes a `terminals` hook: the app's own shells) and
+// only while the person has switched "terminals from other devices" on there. The npm bridge has no
+// shells to offer.
+//
+// From the API:  a `terminal` call { op, … } (list, open, attach, …), and messages
+//                term.watch { conn, on, who }   a device connected / went
+//                term.in { id, data }           keystrokes
+//                term.resize { id, cols, rows }
+//                term.layout { layout }        a browser rearranged the tabs/splits
+// To the API:    term.data { id, data, end } · term.title { id, title } · term.exit { id, code }
+//                term.layout { layout } (rearranged on any screen, the Mac's included)
+//                term.commands (the quick lists changed) · term.off / term.on (switched on the Mac)
+// Output flows only while at least one device is connected.
+
+let getHost = () => null
+let sendNow = () => {}
+/** Connected devices (conn id -> who), kept while switched off too, so switching on reaches them. */
+const conns = new Map()
+let unfollow = null
+let watchingAllowed = null
+
+/** `host()` gives the app's terminals hook (or null); `send(obj)` sends now, or drops it while offline. */
+export function initTerminals(host, send) {
+  getHost = host
+  sendNow = send
+}
+
+const ready = () => {
+  const h = getHost()
+  return h && h.allowed() ? h : null
+}
+
+function follow(h) {
+  if (unfollow) return
+  const offEvents = h.onEvents((kind, id, a, b) => {
+    if (kind === 'data') sendNow({ type: 'term.data', id, data: a, end: b })
+    else if (kind === 'title') sendNow({ type: 'term.title', id, title: a })
+    else if (kind === 'exit') sendNow({ type: 'term.exit', id, code: a })
+  })
+  const offCommands = h.onCommands?.(() => sendNow({ type: 'term.commands' })) ?? (() => {})
+  const offLayout = h.onLayout?.(layout => sendNow({ type: 'term.layout', layout })) ?? (() => {})
+  unfollow = () => {
+    offEvents()
+    offCommands()
+    offLayout()
+    unfollow = null
+  }
+}
+
+/** Switched on or off in the Mac app: tell the devices, and start or stop following the shells. */
+function watchAllowed(h) {
+  if (watchingAllowed || !h.onAllowed) return
+  watchingAllowed = h.onAllowed(on => {
+    if (on) {
+      for (const [conn, who] of conns) h.viewer?.(conn, true, who)
+      if (conns.size) follow(h)
+      sendNow({ type: 'term.on' })
+    } else {
+      unfollow?.()
+      h.viewersGone?.()
+      sendNow({ type: 'term.off' })
+    }
+  })
+}
+
+/** The connection to the API dropped: its devices are gone with it (it tells us again on reconnect). */
+export function terminalsOffline() {
+  conns.clear()
+  unfollow?.()
+  getHost()?.viewersGone?.()
+}
+
+/** Messages from the API about terminals. True when it was one. */
+export function terminalMessage(msg) {
+  if (!msg.type?.startsWith('term.')) return false
+  const h = ready()
+  if (msg.type === 'term.watch') {
+    const conn = String(msg.conn ?? '')
+    const host = getHost()
+    if (host) watchAllowed(host)
+    if (msg.on) {
+      conns.set(conn, String(msg.who ?? ''))
+      if (h) {
+        h.viewer?.(conn, true, String(msg.who ?? ''))
+        follow(h)
+      } else sendNow({ type: 'term.off' })
+    } else {
+      conns.delete(conn)
+      host?.viewer?.(conn, false)
+      if (!conns.size) unfollow?.()
+    }
+    return true
+  }
+  if (!h || !conns.size) return true
+  if (msg.type === 'term.in' && typeof msg.data === 'string' && msg.data.length <= 1_000_000) h.write(String(msg.id), msg.data)
+  else if (msg.type === 'term.resize') h.resize(String(msg.id), Number(msg.cols), Number(msg.rows))
+  else if (msg.type === 'term.layout') h.setLayout?.(msg.layout)
+  return true
+}
+
+/** The `terminal` call: one op at a time. Refused unless switched on in the Mac app. */
+export async function terminalCall(args) {
+  const h = getHost()
+  if (args.op === 'status') return { available: !!h, allowed: !!h?.allowed() }
+  if (!h) return { error: 'terminals need the Kira Mac app (this bridge has none)', reason: 'unavailable' }
+  if (!h.allowed()) return { error: 'terminals from other devices are off on this Mac (Kira for Mac → This Mac)', reason: 'off' }
+  const id = String(args.id ?? '')
+  const str = v => (typeof v === 'string' && v.length < 4096 ? v : undefined)
+  switch (args.op) {
+    case 'list':
+      return { terminals: h.list() }
+    case 'layout':
+      return { layout: h.getLayout?.() ?? null }
+    case 'open':
+      return h.open({ cwd: str(args.cwd), command: str(args.command), cols: Number(args.cols) || undefined, rows: Number(args.rows) || undefined })
+    case 'attach':
+      return h.attach(id)
+    case 'close':
+      h.close(id)
+      return { closed: true }
+    case 'busy':
+      return { program: h.busy(id) }
+    // Kira's own: typing into a shell and showing a shell she opened, without a device connected.
+    case 'write':
+      if (typeof args.data !== 'string' || args.data.length > 100_000) return { error: 'nothing to type' }
+      h.write(id, args.data)
+      return { written: true }
+    case 'place': {
+      // A new tab at the end of the shared layout, so every screen (the Mac's window too) shows it.
+      const layout = h.getLayout?.() ?? { tabs: [] }
+      const tabs = (layout.tabs ?? []).filter(t => !JSON.stringify(t.root).includes(`"${id}"`))
+      h.setLayout?.({ tabs: [...tabs, { key: Math.random().toString(36).slice(2, 10), root: { kind: 'term', id } }], from: 'kira' })
+      return { placed: true }
+    }
+    case 'cwd':
+      return { cwd: await h.cwd(id) }
+    case 'commands':
+      return { rows: h.commands({ cwd: str(args.cwd), query: str(args.query), limit: Number(args.limit) || undefined }) }
+    case 'folders':
+      return { rows: h.folders({ query: str(args.query), limit: Number(args.limit) || undefined }) }
+    case 'pinCommand':
+      h.pinCommand(String(args.cmd), !!args.on)
+      return { ok: true }
+    case 'forgetCommand':
+      h.forgetCommand(String(args.cmd))
+      return { ok: true }
+    case 'pinFolder':
+      h.pinFolder(String(args.path), !!args.on)
+      return { ok: true }
+    case 'forgetFolder':
+      h.forgetFolder(String(args.path))
+      return { ok: true }
+    default:
+      return { error: `unknown terminal op ${args.op}` }
+  }
+}

package/src/worktrees.mjs

@@ -173,15 +173,27 @@ const STAGE_MAX_BYTES = 200 * 1024 * 1024
  * Put a task's reference files into the worktree under .kira/files (excluded
  * from git through .git/info/exclude, never committed), so the agent can open
  * them like anything else on disk. Downloads from short-lived signed URLs.
+ *
+ * Handing a task to Claude in a terminal (the portal's "From Kira") uses it too, with `dir`: the
+ * files go to .kira/<dir> (e.g. tasks/52) and are kept, not wiped, and `path` needn't be a git
+ * checkout (`create` makes it, for ~/Kira/tasks/...). A file can be `text` instead of a `url` (the
+ * task's brief.md).
  */
-export async function stageFiles({ path: p, files }) {
+export async function stageFiles({ path: p, files, dir: sub, create }) {
   const path = resolveUserPath(String(p ?? ''))
-  if (!(await exists(join(path, '.git')))) return { error: 'no worktree at that path', path: display(path) }
-  const dir = join(path, STAGE_DIR)
-  await rm(dir, { recursive: true, force: true })
+  const handover = typeof sub === 'string' && sub.length > 0
+  const isGit = await exists(join(path, '.git'))
+  if (!isGit && !handover) return { error: 'no worktree at that path', path: display(path) }
+  if (!(await exists(path))) {
+    if (!create) return { error: 'that folder isn’t on this Mac', path: display(path) }
+    await mkdir(path, { recursive: true })
+  }
+  const rel = handover ? `.kira/${String(sub).replace(/\.\.+/g, '').replace(/^\/+|\/+$/g, '')}` : STAGE_DIR
+  const dir = join(path, rel)
+  if (!handover) await rm(dir, { recursive: true, force: true })
   await mkdir(dir, { recursive: true })
   // A worktree's .git is a file pointing at the real gitdir; git tells us where its exclude file lives.
-  const excl = await git(path, ['rev-parse', '--git-path', 'info/exclude'])
+  const excl = isGit ? await git(path, ['rev-parse', '--git-path', 'info/exclude']) : { ok: false }
   if (excl.ok) {
     const file = isAbsolute(excl.out) ? excl.out : join(path, excl.out)
     await mkdir(join(file, '..'), { recursive: true })
@@ -196,20 +208,24 @@ export async function stageFiles({ path: p, files }) {
     if (seen.has(name)) name = `${name.replace(/(\.[^.]+)?$/, '')}-${seen.size}${/\.[^.]+$/.exec(name)?.[0] ?? ''}`
     seen.add(name)
     try {
-      const res = await fetch(String(f.url))
-      if (!res.ok || !res.body) throw new Error(`download failed (${res.status})`)
-      const len = Number(res.headers.get('content-length') ?? 0)
-      if (total + len > STAGE_MAX_BYTES) throw new Error('over the staging size limit')
       const dest = join(dir, name)
-      await pipeline(Readable.fromWeb(res.body), createWriteStream(dest))
+      if (typeof f.text === 'string') {
+        await writeFile(dest, f.text, 'utf8')
+      } else {
+        const res = await fetch(String(f.url))
+        if (!res.ok || !res.body) throw new Error(`download failed (${res.status})`)
+        const len = Number(res.headers.get('content-length') ?? 0)
+        if (total + len > STAGE_MAX_BYTES) throw new Error('over the staging size limit')
+        await pipeline(Readable.fromWeb(res.body), createWriteStream(dest))
+      }
       const size = (await stat(dest)).size
       total += size
-      staged.push({ name, path: `${STAGE_DIR}/${name}`, bytes: size, description: f.description || undefined })
+      staged.push({ name, path: `${rel}/${name}`, abs: dest, bytes: size, description: f.description || undefined })
     } catch (err) {
       staged.push({ name, error: err.message })
     }
   }
-  return { dir: `${STAGE_DIR}/`, staged, bytes: total }
+  return { dir: `${rel}/`, abs: dir, staged, bytes: total }
 }
 
 const OUTPUT_MAX_FILES = 60