kira-glasses-bridge 2.35.0 → 2.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.35.0",
+  "version": "2.37.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/chrome.mjs

@@ -0,0 +1,104 @@
+// Chrome on this Mac, for Links: each profile's bookmarks, read from the Bookmarks file Chrome keeps
+// synced with the Google account signed in to it, and the tabs open right now. Read only: Chrome
+// rewrites that file from its own copy while it runs, so Kira never writes to it.
+import { execFile } from 'node:child_process'
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const CHROME_DIR = join(homedir(), 'Library', 'Application Support', 'Google', 'Chrome')
+const SEP = ' › '
+
+/** Chrome's times are microseconds since 1601; an ISO date, or null when there's none. */
+export function chromeTime(raw) {
+  const micros = Number(raw)
+  if (!Number.isFinite(micros) || micros <= 0) return null
+  return new Date(micros / 1000 - 11_644_473_600_000).toISOString()
+}
+
+/** The profiles in Chrome's Local State: folder, the name Chrome shows, and the Google account. */
+export function profilesOf(localState) {
+  const cache = localState?.profile?.info_cache ?? {}
+  return Object.entries(cache).map(([profile, info]) => ({
+    profile,
+    name: String(info?.name || profile),
+    account: info?.user_name ? String(info.user_name) : null,
+  }))
+}
+
+/** Every bookmark in a Bookmarks file, flat, each with its folders from the root ("Bookmarks bar › Dev"). */
+export function flattenBookmarks(file) {
+  const out = []
+  const walk = (node, path) => {
+    if (node?.type === 'url' && /^https?:/i.test(node.url ?? '')) {
+      out.push({
+        chromeId: String(node.guid || node.id),
+        url: node.url,
+        title: String(node.name ?? ''),
+        folder: path.join(SEP),
+        addedAt: chromeTime(node.date_added),
+      })
+    }
+    for (const child of node?.children ?? []) walk(child, node.type === 'folder' ? [...path, node.name] : path)
+  }
+  for (const root of Object.values(file?.roots ?? {})) {
+    if (root && typeof root === 'object' && root.type === 'folder') {
+      for (const child of root.children ?? []) walk(child, [root.name])
+    }
+  }
+  return out
+}
+
+const readJson = async path => JSON.parse(await readFile(path, 'utf8'))
+
+/** Each profile with its bookmarks; none when Chrome isn't installed. */
+async function bookmarks() {
+  let state
+  try {
+    state = await readJson(join(CHROME_DIR, 'Local State'))
+  } catch {
+    return { profiles: [] }
+  }
+  const profiles = await Promise.all(
+    profilesOf(state).map(async p => {
+      const file = await readJson(join(CHROME_DIR, p.profile, 'Bookmarks')).catch(() => null)
+      return { ...p, bookmarks: file ? flattenBookmarks(file) : [] }
+    }),
+  )
+  return { profiles }
+}
+
+// Asks Chrome only when it's already running (running() doesn't start it).
+const TABS_SCRIPT = `
+const chrome = Application('Google Chrome')
+chrome.running()
+  ? JSON.stringify(chrome.windows().flatMap(w => w.tabs().map(t => ({ url: t.url(), title: t.title() }))))
+  : '[]'`
+
+/** The tabs open in Chrome now. The first time, macOS asks whether Kira may control Chrome. */
+function tabs() {
+  return new Promise(resolve => {
+    execFile('osascript', ['-l', 'JavaScript', '-e', TABS_SCRIPT], { timeout: 10_000 }, (err, stdout) => {
+      if (err) {
+        const denied = /-1743|not allowed/i.test(String(err.message))
+        const error = denied
+          ? 'Kira isn’t allowed to read Chrome’s tabs (System Settings › Privacy › Automation).'
+          : 'Chrome’s tabs couldn’t be read.'
+        return resolve({ tabs: [], error })
+      }
+      try {
+        const list = JSON.parse(stdout.trim() || '[]').filter(t => /^https?:/i.test(t.url ?? ''))
+        resolve({ tabs: list })
+      } catch {
+        resolve({ tabs: [] })
+      }
+    })
+  })
+}
+
+/** The bridge's `chrome` tool: { op: 'bookmarks' } or { op: 'tabs' }. */
+export function chromeCall(args) {
+  if (args?.op === 'bookmarks') return bookmarks()
+  if (args?.op === 'tabs') return tabs()
+  return Promise.resolve({ error: `unknown op ${args?.op}` })
+}

package/src/claude-sessions.mjs

@@ -5,29 +5,22 @@ import { getSessionInfo, getSessionMessages, listSessions as sdkListSessions } f
 import { open, readdir, stat } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { basename, join } from 'node:path'
+import { doingOf, itemsOf, lastTurns, turnsOf } from './claude-transcript.mjs'
 
 const ACTIVE_WINDOW_MS = 3 * 60 * 1000
+const TEXT_CAP = 2000
 
-function textOf(message) {
-  const c = message?.content
-  if (typeof c === 'string') return c
-  if (Array.isArray(c)) return c.filter(b => b?.type === 'text').map(b => b.text).join('\n')
-  return ''
-}
-
-/** The conversation as said: user and Claude text, without tool results, system blocks or subagents. */
-async function turnsOf(sessionId, dir) {
+/** The session as it happened: its turns and the tool calls between them (claude-transcript.mjs). */
+async function itemsFor(sessionId, dir) {
   const messages = await getSessionMessages(sessionId, dir ? { dir } : undefined)
-  const turns = []
-  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
+  return itemsOf(messages, dir ?? homedir())
 }
 
+/** The branch, unless the checkout is detached ("HEAD"). */
+const branchOf = s => (s.gitBranch && s.gitBranch !== 'HEAD' ? s.gitBranch : null)
+
+const capText = item => (item.kind === 'turn' ? { ...item, text: item.text.slice(0, TEXT_CAP) } : item)
+
 /**
  * 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.
@@ -59,18 +52,22 @@ export async function listSessions(max = 10) {
   for (const s of await sdkListSessions({ limit: n })) {
     try {
       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')
+      const items = await itemsFor(s.sessionId, cwd)
+      const turns = turnsOf(items)
+      const lastUser = turns.findLast(t => t.role === 'user')
+      const lastClaude = turns.findLast(t => t.role === 'claude')
+      const active = activeOf(s)
       sessions.push({
         session_id: s.sessionId,
         title: titleOf(s) ?? (lastUser ? lastUser.text.slice(0, 60) : '(untitled)'),
         project: cwd ? cwd.split('/').slice(-2).join('/') : null,
         cwd,
-        active: activeOf(s),
+        active,
         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,
+        branch: branchOf(s),
+        doing: active ? doingOf(items) : null,
       })
     } catch {
       /* unreadable transcript */
@@ -79,13 +76,28 @@ export async function listSessions(max = 10) {
   return { count: sessions.length, sessions }
 }
 
-export async function readSession(sessionId, turns = 6) {
+/**
+ * A session's last `turns` turns; with `items`, the tool calls between them too (the phone asks for
+ * them; Kira's own reads don't, to keep them short).
+ */
+export async function readSession(sessionId, turns = 6, { items: withItems = false } = {}) {
   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 items = await itemsFor(sessionId, cwd)
   const n = Math.min(Math.max(Number(turns) || 6, 1), 30)
-  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) })) }
+  const recent = lastTurns(items, n).map(capText)
+  return {
+    session_id: info.sessionId,
+    title: titleOf(info),
+    cwd,
+    active: activeOf(info),
+    last_active_at: new Date(info.lastModified).toISOString(),
+    turns: turnsOf(recent),
+    ...(withItems ? { items: recent } : {}),
+    branch: branchOf(info),
+    doing: activeOf(info) ? doingOf(items) : null,
+  }
 }
 
 /** Project folders Claude Code has been used in (that still exist), newest first. */

package/src/claude-transcript.mjs

@@ -0,0 +1,114 @@
+// A Claude Code transcript (the Agent SDK's session messages) as the conversation shows it: what was
+// said and, between the turns, the tool calls Claude made, described the way its jobs describe them
+// (agents/claude-calls.mjs). The shape is @kira/genui's claudeSessionItems.ts.
+import { describeAction, short } from './agents/claude-calls.mjs'
+
+/** How much of an edit, a write or a command a call carries for its detail. */
+const DETAIL_CAP = 1500
+
+function textOf(message) {
+  const c = message?.content
+  if (typeof c === 'string') return c
+  if (Array.isArray(c)) return c.filter(b => b?.type === 'text').map(b => b.text).join('\n')
+  return ''
+}
+
+/** An edit's lines: the old and new text without the lines they share at the start and the end. */
+function diffCounts(old, now) {
+  const a = String(old ?? '').split('\n')
+  const b = String(now ?? '').split('\n')
+  let start = 0
+  while (start < a.length && start < b.length && a[start] === b[start]) start++
+  let end = 0
+  while (end < a.length - start && end < b.length - start && a[a.length - 1 - end] === b[b.length - 1 - end]) end++
+  return { adds: b.length - start - end, dels: a.length - start - end }
+}
+
+/** Lines an edit or a write adds and takes out; null for any other call. */
+export function lineCounts(name, input) {
+  const i = input ?? {}
+  if (name === 'Write') return { adds: i.content ? String(i.content).split('\n').length : 0, dels: 0 }
+  if (name === 'Edit') return diffCounts(i.old_string, i.new_string)
+  if (name !== 'MultiEdit') return null
+  const each = (i.edits ?? []).map(e => diffCounts(e.old_string, e.new_string))
+  return { adds: each.reduce((n, c) => n + c.adds, 0), dels: each.reduce((n, c) => n + c.dels, 0) }
+}
+
+/**
+ * A change's detail, shorter than a job's: the conversation polls it every few seconds. A command
+ * has none (its target is the command).
+ */
+function shortDetail(d) {
+  const cut = e => ({ ...e, old: short(e.old, DETAIL_CAP), new: short(e.new, DETAIL_CAP) })
+  if (d.edit) return { edit: cut(d.edit) }
+  if (d.edits) return { edits: d.edits.slice(0, 5).map(cut) }
+  return d.content !== undefined ? { content: short(d.content, DETAIL_CAP) } : undefined
+}
+
+/** One tool_use block as a call. */
+function toolCall(block, cwd) {
+  const act = describeAction(block.name, block.input, cwd)
+  const detail = act.detail ? shortDetail(act.detail) : undefined
+  return {
+    id: block.id,
+    type: act.type,
+    label: act.label,
+    target: act.target,
+    ...(lineCounts(block.name, block.input) ?? {}),
+    ...(detail ? { detail } : {}),
+  }
+}
+
+/**
+ * Everything said and done, in order: the user's and Claude's turns, and each run of tool calls
+ * between them as one item. Subagents' own messages and system blocks (text starting "<") are left out.
+ */
+export function itemsOf(messages, cwd) {
+  const items = []
+  const calls = new Map()
+  let group = null
+  const say = (role, text, at) => {
+    group = null
+    if (text && !text.startsWith('<')) items.push({ kind: 'turn', role, text, at })
+  }
+  for (const m of messages) {
+    if (m.parent_tool_use_id) continue
+    const at = m.timestamp ?? null
+    const content = Array.isArray(m.message?.content) ? m.message.content : []
+    if (m.type === 'assistant') {
+      for (const b of content) {
+        if (b?.type === 'text') say('claude', String(b.text ?? '').trim(), at)
+        if (b?.type !== 'tool_use') continue
+        if (!group) items.push((group = { kind: 'tools', at, calls: [] }))
+        const call = toolCall(b, cwd)
+        calls.set(call.id, call)
+        group.calls.push(call)
+      }
+    } else if (m.type === 'user') {
+      for (const b of content) {
+        if (b?.type === 'tool_result' && b.is_error && calls.has(b.tool_use_id)) calls.get(b.tool_use_id).failed = true
+      }
+      const text = textOf(m.message).trim()
+      if (text) say('user', text, at)
+    }
+  }
+  return items
+}
+
+/** Just the turns (what read_claude_session has always returned). */
+export const turnsOf = items => items.filter(i => i.kind === 'turn').map(({ kind, ...turn }) => turn)
+
+/** The last `n` turns and the tool calls among and after them. */
+export function lastTurns(items, n) {
+  let seen = 0
+  for (let i = items.length - 1; i >= 0; i--) if (items[i].kind === 'turn' && ++seen === n) return items.slice(i)
+  return items
+}
+
+/** The last call when nothing was said after it: what the session is doing (or did last). */
+export function doingOf(items) {
+  const last = items.at(-1)
+  if (last?.kind !== 'tools') return null
+  const { detail, ...call } = last.calls.at(-1)
+  return call
+}

package/src/mac-tools.mjs

@@ -1,5 +1,5 @@
 // The bridge's tools for this Mac itself: its apps, a terminal, a project's folder (found or new), and
-// (inside the Mac app only) its shells for other devices and its browser dock.
+// (inside the Mac app only) its shells for other devices and its browser dock, and Chrome's bookmarks and tabs.
 import { execFile } from 'node:child_process'
 import { openApp, installedApps } from './apps.mjs'
 import { resolveUserPath } from './files.mjs'
@@ -8,6 +8,7 @@ import { findCheckouts } from './checkouts.mjs'
 import { terminalCall } from './terminals.mjs'
 import { safeCommand, terminalScript } from './terminal-command.mjs'
 import { host } from './host.mjs'
+import { chromeCall } from './chrome.mjs'
 
 export const macTools = {
   async open_app(args) {
@@ -39,6 +40,9 @@ export const macTools = {
   /** This Mac's shells for a browser elsewhere (only inside the Mac app, only when switched on there). */
   terminal: args => terminalCall(args),
 
+  /** Chrome's bookmarks (every profile) and open tabs, for Links. */
+  chrome: args => chromeCall(args),
+
   /** Kira in the Mac app's browser dock: open a page, read it, click and type in it. */
   async browser(args) {
     const hooks = host()

package/src/session-tools.mjs

@@ -15,6 +15,6 @@ export const sessionTools = {
     return listSessions(args.max)
   },
   async read_claude_session(args) {
-    return readSession(String(args.session_id ?? ''), args.turns)
+    return readSession(String(args.session_id ?? ''), args.turns, { items: args.items === true })
   },
 }