kira-glasses-bridge 2.13.0 → 2.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.13.0",
+  "version": "2.15.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": {

package/src/agents/claude.mjs

@@ -191,11 +191,24 @@ export async function run({ prompt, sessionId, cwd, policy, persona, abort }, io
     return applyAnswer(toolName, input, request, resolved.answer, suggestions)
   }
 
+  // Background work (subagents, `run_in_background` shell commands, monitors)
+  // started by the model would outlive the turn: this is a one-shot run, so the
+  // moment the main thread stops the result is released, the process ends and
+  // that work is killed, never having reported. Claude's parting words ("the
+  // agents are still running; I'll compile the report when they finish") then
+  // became the job's final report, and Kira told the user it was still going.
+  // With this set, the tool has no background option: subagents run inline and
+  // their findings are in the answer.
+  const env = { ...process.env, CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: '1' }
+  /** Background tasks the model still managed to start (an older CLI ignoring the flag): tool_use id -> description. */
+  const orphans = new Map()
+
   try {
     const q = query({
       prompt,
       options: {
         cwd,
+        env,
         ...(sessionId ? { resume: sessionId } : {}),
         permissionMode: 'default',
         ...(abort ? { abortController: abort } : {}),
@@ -211,18 +224,26 @@ export async function run({ prompt, sessionId, cwd, policy, persona, abort }, io
       },
     })
     for await (const m of q) {
+      // Messages from inside a subagent carry the id of the Subtask call that started it.
+      const nested = !!m.parent_tool_use_id
       if (m.type === 'system' && m.subtype === 'init') {
         session = m.session_id ?? session
         io.emit({ kind: 'session', sessionId: session, model: m.model ?? null })
+      } else if (m.type === 'system' && m.subtype === 'task_started') {
+        if (m.is_backgrounded && m.tool_use_id) orphans.set(m.tool_use_id, m.description ?? m.subagent_type ?? 'task')
+      } else if (m.type === 'system' && m.subtype === 'task_notification') {
+        if (m.tool_use_id) orphans.delete(m.tool_use_id)
       } else if (m.type === 'assistant') {
         for (const b of m.message?.content ?? []) {
-          if (b.type === 'text' && b.text?.trim()) io.emit({ kind: 'message', text: short(b.text, TEXT_CAP) })
+          // A subagent's narration is for its parent, not the user; its actions still show what is going on while the Subtask runs.
+          if (b.type === 'text' && b.text?.trim() && !nested) io.emit({ kind: 'message', text: short(b.text, TEXT_CAP) })
           else if (b.type === 'tool_use') io.emit({ kind: 'action', id: b.id, tool: b.name, ...describeAction(b.name, b.input, cwd) })
         }
       } else if (m.type === 'user') {
         for (const b of m.message?.content ?? []) {
           if (b?.type === 'tool_result') {
             const t = typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.map(c => (c.type === 'text' ? c.text : '')).join('\n') : ''
+            if (/^Async agent launched successfully/.test(t.trim()) && !orphans.has(b.tool_use_id)) orphans.set(b.tool_use_id, 'subagent')
             io.emit({ kind: 'action_result', id: b.tool_use_id, ok: !b.is_error, preview: short(t.trim(), 240) })
           }
         }
@@ -230,6 +251,11 @@ export async function run({ prompt, sessionId, cwd, policy, persona, abort }, io
         session = m.session_id ?? session
         if (m.subtype === 'success') text = String(m.result ?? '')
         else error = `Claude stopped: ${m.subtype}${Array.isArray(m.errors) && m.errors.length ? ` (${m.errors.join('; ').slice(0, 300)})` : ''}`
+        // Work left running in the background dies with this process; say so rather than let "still running" stand as the outcome.
+        if (orphans.size) {
+          const note = `${orphans.size} background ${orphans.size === 1 ? 'task was' : 'tasks were'} still running when Claude ended its turn (${[...orphans.values()].slice(0, 5).join(', ')}); they were stopped with the session and their findings are not in this report. Send a follow-up to have that work done inline.`
+          text = text ? `${text}\n\n(${note})` : `(${note})`
+        }
         const stats = { durationMs: m.duration_ms, turns: m.num_turns, costUsd: m.total_cost_usd }
         io.emit({ kind: 'result', ok: !error, text: short(text, TEXT_CAP), error, sessionId: session, stats })
         return { ok: !error, text, error, sessionId: session, stats }

package/src/claude-designs.mjs

@@ -0,0 +1,182 @@
+// Designs Claude Code made on this Mac: artifacts it published to claude.ai, and the HTML/SVG
+// mockups it wrote (design/ folders, Claude Design projects, scratchpad pages). Read through the
+// Agent SDK like claude-sessions.mjs. A design's HTML comes from the file when it's still on disk,
+// and otherwise from the transcript itself (its Write, then its Edits replayed), since most were
+// written to a scratchpad that macOS has since cleared.
+import { getSessionMessages, getSubagentMessages, listSessions as sdkListSessions, listSubagents } from '@anthropic-ai/claude-agent-sdk'
+import { createHash } from 'node:crypto'
+import { readFile, stat } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, dirname, extname, relative } from 'node:path'
+
+const MAX_BYTES = 2 * 1024 * 1024
+const DESIGN_DIR = /^(design|designs|mock|mocks|mockups?|prototypes?|wireframes?)$/i
+const DESIGN_NAME = /(mock|design|prototype|wireframe|preview)/i
+const NEVER = /^(node_modules|dist|build|out|\.git|\.next|coverage)$/
+
+const sha = s => createHash('sha256').update(s).digest('hex')
+
+/** Whether a file Claude wrote is a design rather than app source. */
+function isDesignPath(path) {
+  const ext = extname(path).toLowerCase()
+  if (ext !== '.html' && ext !== '.svg') return false
+  const parts = path.split('/')
+  if (parts.some(p => NEVER.test(p))) return false
+  if (path.includes('/scratchpad/') || path.endsWith('.dc.html')) return true
+  return parts.slice(0, -1).some(p => DESIGN_DIR.test(p)) || DESIGN_NAME.test(basename(path))
+}
+
+/** The folder a design sits in, as a short label that groups a set of screens ("kira-cards", "design/assignee-menu"). */
+function collectionOf(path, cwd) {
+  const pad = path.indexOf('/scratchpad/')
+  let dir = pad >= 0 ? dirname(path.slice(pad + '/scratchpad/'.length)) : cwd && path.startsWith(cwd + '/') ? dirname(relative(cwd, path)) : basename(dirname(path))
+  dir = dir.replace(/\/project$/, '')
+  return dir && dir !== '.' ? dir : null
+}
+
+/** The repo a session worked in: Kira task worktrees are ~/.kira/worktrees/<owner>/<repo>/<task>. */
+function repoOf(cwd) {
+  if (!cwd) return null
+  if (cwd === homedir()) return 'Home'
+  const m = /\/\.kira\/worktrees\/[^/]+\/([^/]+)\//.exec(cwd + '/')
+  return m ? m[1] : basename(cwd)
+}
+
+function titleOf(path, html) {
+  const t = /<title[^>]*>([^<]{1,120})<\/title>/i.exec(html ?? '')?.[1]?.trim()
+  if (t) return t.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'")
+  return basename(path).replace(/(\.dc)?\.(html|svg)$/i, '').replace(/^\d+[-_]/, '').replace(/[-_]+/g, ' ').replace(/\b\w/g, c => c.toUpperCase())
+}
+
+function applyEdit(text, e) {
+  if (text == null || typeof e?.old_string !== 'string' || !text.includes(e.old_string)) return null
+  return e.replace_all ? text.split(e.old_string).join(e.new_string ?? '') : text.replace(e.old_string, () => e.new_string ?? '')
+}
+
+const resultText = c => (typeof c === 'string' ? c : Array.isArray(c) ? c.map(b => b?.text ?? '').join('\n') : '')
+
+/** Every design one session made, with its latest HTML as of the end of the transcript. */
+async function designsOf(s) {
+  const opts = s.cwd ? { dir: s.cwd } : undefined
+  // Subagents write designs too (a design pass is often delegated), so read their transcripts after the session's own.
+  const messages = await getSessionMessages(s.sessionId, opts)
+  for (const agent of await listSubagents(s.sessionId, opts).catch(() => [])) messages.push(...(await getSubagentMessages(s.sessionId, agent, opts).catch(() => [])))
+  const files = new Map() // path -> { content, created, updated }
+  const publishes = new Map() // tool_use id -> Artifact publish input
+  const artifacts = new Map() // url -> { path, description, icon, title, version, created, updated }
+  for (const m of messages) {
+    const at = m.timestamp ?? null
+    const content = m.message?.content
+    if (!Array.isArray(content)) continue
+    for (const b of content) {
+      if (b?.type === 'tool_use') {
+        const i = b.input ?? {}
+        const path = typeof i.file_path === 'string' ? i.file_path : null
+        if (b.name === 'Write' && path) {
+          const f = files.get(path)
+          files.set(path, { content: typeof i.content === 'string' ? i.content : null, created: f?.created ?? at, updated: at })
+        } else if ((b.name === 'Edit' || b.name === 'MultiEdit') && path && files.has(path)) {
+          const f = files.get(path)
+          for (const e of b.name === 'Edit' ? [i] : (i.edits ?? [])) f.content = applyEdit(f.content, e)
+          f.updated = at
+        } else if (b.name === 'Artifact' && (i.action ?? 'publish') === 'publish' && !i.asset) {
+          publishes.set(b.id, i)
+        }
+      } else if (b?.type === 'tool_result' && publishes.has(b.tool_use_id)) {
+        const i = publishes.get(b.tool_use_id)
+        const m2 = /at (https:\/\/claude\.ai\/\S*artifact\/[\w-]+)(?: \(Version (\d+)\))?/.exec(resultText(b.content))
+        if (!m2 || b.is_error) continue
+        const prev = artifacts.get(m2[1])
+        artifacts.set(m2[1], {
+          path: i.file_path ?? prev?.path ?? null,
+          description: i.description ?? prev?.description ?? null,
+          icon: i.icon ?? prev?.icon ?? null,
+          title: i.title ?? prev?.title ?? null,
+          version: Number(m2[2]) || prev?.version || 1,
+          created: prev?.created ?? at,
+          updated: at,
+        })
+      }
+    }
+  }
+
+  const out = []
+  const published = new Map([...artifacts].filter(([, a]) => a.path).map(([url, a]) => [a.path, { url, ...a }]))
+  const base = { session_id: s.sessionId, session_title: s.customTitle || s.summary || s.firstPrompt?.slice(0, 80) || null, cwd: s.cwd ?? null, repo: repoOf(s.cwd) }
+  for (const [path, f] of files) {
+    const art = published.get(path)
+    if (!art && !isDesignPath(path)) continue
+    const onDisk = await stat(path).then(st => st.isFile() && st.size <= MAX_BYTES, () => false)
+    const html = onDisk ? await readFile(path, 'utf8').catch(() => f.content) : f.content
+    if (!html || Buffer.byteLength(html) > MAX_BYTES) continue
+    out.push({
+      ...base,
+      key: sha(`${s.sessionId}:${path}`).slice(0, 32),
+      kind: art ? 'artifact' : path.endsWith('.dc.html') ? 'claude_design' : extname(path).slice(1).toLowerCase(),
+      title: art?.title || titleOf(path, html),
+      description: art?.description ?? null,
+      icon: art?.icon ?? null,
+      path: path.replace(homedir(), '~'),
+      collection: collectionOf(path, s.cwd),
+      artifact_url: art?.url ?? null,
+      artifact_version: art?.version ?? null,
+      on_disk: onDisk,
+      created_at: art?.created ?? f.created,
+      updated_at: art?.updated && art.updated > f.updated ? art.updated : f.updated,
+      content_hash: sha(html),
+      bytes: Buffer.byteLength(html),
+      html,
+    })
+  }
+  // Published without a file Claude wrote in this session (a deck, a doc, or a page from an earlier one).
+  for (const [url, a] of artifacts) {
+    if (a.path && files.has(a.path)) continue
+    const html = a.path ? await readFile(a.path, 'utf8').catch(() => null) : null
+    out.push({
+      ...base,
+      key: sha(url).slice(0, 32),
+      kind: 'artifact',
+      title: a.title || (a.path ? titleOf(a.path, html) : 'Untitled artifact'),
+      description: a.description,
+      icon: a.icon,
+      path: a.path ? a.path.replace(homedir(), '~') : null,
+      collection: a.path ? collectionOf(a.path, s.cwd) : null,
+      artifact_url: url,
+      artifact_version: a.version,
+      on_disk: !!html,
+      created_at: a.created,
+      updated_at: a.updated,
+      content_hash: html ? sha(html) : null,
+      bytes: html ? Buffer.byteLength(html) : 0,
+      html,
+    })
+  }
+  return out
+}
+
+/**
+ * Scan every session changed since `since` (ISO time; all of them when omitted), or only the
+ * sessions named in `sessions` (a Claude job just finished in one). Returns the designs without
+ * their HTML, plus the HTML of those whose hash isn't in `known` (hashes the API already holds),
+ * so a rescan sends only what changed.
+ */
+export async function scanDesigns({ since, known = [], sessions: only } = {}) {
+  const after = since ? Date.parse(since) || 0 : 0
+  const have = new Set(known)
+  const pick = Array.isArray(only) && only.length ? new Set(only) : null
+  const sessions = (await sdkListSessions()).filter(s => (pick ? pick.has(s.sessionId) : s.lastModified > after))
+  const designs = []
+  let failed = 0
+  for (const s of sessions) {
+    try {
+      designs.push(...(await designsOf(s)))
+    } catch {
+      failed++
+    }
+  }
+  return {
+    scanned: sessions.length,
+    failed,
+    designs: designs.map(({ html, ...d }) => ({ ...d, html: html && !have.has(d.content_hash) ? html : undefined })),
+  }
+}

package/src/index.mjs

@@ -3,6 +3,7 @@
 // machine on the user's behalf. Env: KIRA_BRIDGE_URL, KIRA_BRIDGE_TOKEN.
 import WebSocket from 'ws'
 import { listProjects, listSessions, readSession } from './claude-sessions.mjs'
+import { scanDesigns } from './claude-designs.mjs'
 import { snapshot, changesSince, display, setupProjectFolder } from './git.mjs'
 import { resolveCwd, folderExists } from './claude-run.mjs'
 import { agentById, AGENTS } from './agents/index.mjs'
@@ -44,6 +45,7 @@ const ANSWER_TIMEOUT_MS = 3 * 60 * 1000
  *   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)
+ *   browser({ op, … })      Kira in the app's browser dock: open, read, click, type (browser-kira.mjs)
  */
 let hooks = {}
 let stopped = false
@@ -110,6 +112,9 @@ const tools = {
   async list_claude_projects(args) {
     return listProjects(args.max)
   },
+  async scan_claude_designs(args) {
+    return scanDesigns({ since: args.since, known: Array.isArray(args.known) ? args.known : [], sessions: args.sessions })
+  },
   async list_claude_sessions(args) {
     return listSessions(args.max)
   },
@@ -194,6 +199,12 @@ const tools = {
   /** This Mac's shells for a browser elsewhere (only inside the Mac app, only when switched on there). */
   terminal: args => terminalCall(args),
 
+  /** Kira in the Mac app's browser dock: open a page, read it, click and type in it. */
+  async browser(args) {
+    if (!hooks.browser) return { error: 'the browser needs the Kira Mac app (this bridge has none)', reason: 'unavailable' }
+    return hooks.browser(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) {