kira-glasses-bridge 2.6.0 → 2.8.0

package/package.json

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

@@ -133,7 +133,7 @@ function applyAnswer(name, input, request, answer, suggestions) {
 /** "Always allow" answers, kept for the rest of the process per session: sessionId -> Set of rules. */
 const sessionRules = new Map()
 
-export async function run({ prompt, sessionId, cwd, policy, persona }, io) {
+export async function run({ prompt, sessionId, cwd, policy, persona, abort }, io) {
   let session = sessionId ?? null
   let text = ''
   let error = null
@@ -145,8 +145,19 @@ export async function run({ prompt, sessionId, cwd, policy, persona }, io) {
   // and refuses outright what it denies.
   // A member with a restricted shell (a designer, a researcher) runs only what its preset allows.
   const shellAllow = persona?.shellAllow ? new RegExp(persona.shellAllow) : null
+  // A member that only produces artifacts (a designer, a researcher) writes nowhere but its output folders.
+  const within = (persona?.writeWithin ?? []).map(d => resolve(cwd, d))
+  const writeTools = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit'])
   const preToolUse = async input => {
     if (input.hook_event_name !== 'PreToolUse') return {}
+    if (within.length && writeTools.has(input.tool_name)) {
+      const target = resolve(cwd, String(input.tool_input?.file_path ?? input.tool_input?.notebook_path ?? ''))
+      if (!within.some(dir => target === dir || target.startsWith(dir + sep))) {
+        const reason = `${persona.name} only writes under ${persona.writeWithin.join(', ')}; ${displayPath(target, cwd)} is off limits. Describe what an engineer should change in your spec instead.`
+        io.emit({ kind: 'request_resolved', id: `persona-${Date.now().toString(36)}`, answer: { optionIds: ['deny'] }, by: 'policy', tool: input.tool_name, reason })
+        return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason } }
+      }
+    }
     // Every command in a chain ("ls; rm -rf x", "a && b", "a | b") has to be allowed, not only the first.
     const segments = c => String(c ?? '').split(/&&|\|\||;|\|/).map(x => x.trim()).filter(Boolean)
     if (shellAllow && input.tool_name === 'Bash' && !segments(input.tool_input?.command).every(seg => shellAllow.test(seg))) {
@@ -187,6 +198,7 @@ export async function run({ prompt, sessionId, cwd, policy, persona }, io) {
         cwd,
         ...(sessionId ? { resume: sessionId } : {}),
         permissionMode: 'default',
+        ...(abort ? { abortController: abort } : {}),
         // A team member's soul, skills and conventions ride on top of Claude Code's own prompt; its preset says which tools it does without.
         ...(persona?.systemPrompt ? { systemPrompt: { type: 'preset', preset: 'claude_code', append: persona.systemPrompt } } : {}),
         ...(persona?.disallowedTools?.length ? { disallowedTools: persona.disallowedTools } : {}),
@@ -222,7 +234,7 @@ export async function run({ prompt, sessionId, cwd, policy, persona }, io) {
     }
     return { ok: !error, text, error, sessionId: session }
   } catch (err) {
-    const message = `could not run Claude: ${err.message}`
+    const message = abort?.signal.aborted ? 'Stopped by the user.' : `could not run Claude: ${err.message}`
     io.emit({ kind: 'result', ok: false, error: message, sessionId: session })
     return { ok: false, error: message, sessionId: session }
   }

package/src/index.mjs

@@ -9,7 +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 { prepareWorktree, worktreeStatus, pushWorktree, removeWorktree, repoOfFolder, stageFiles } from './worktrees.mjs'
+import { prepareWorktree, worktreeStatus, pushWorktree, removeWorktree, repoOfFolder, stageFiles, listOutputs, uploadOutputs } from './worktrees.mjs'
 
 import { createRequire } from 'node:module'
 const { version: BRIDGE_VERSION } = createRequire(import.meta.url)('../package.json')
@@ -18,6 +18,21 @@ let URL_ = ''
 let TOKEN = ''
 /** Requests waiting on a person: `${jobId}:${requestId}` -> resolve({ answer, by }). */
 const answerWaits = new Map()
+/** Running jobs, by id, so a person can stop one. */
+const running = new Map()
+/**
+ * The live connection, and what could not be sent while there was none. Jobs
+ * outlive connections (every API deploy reconnects us), so their events and
+ * results go through here rather than the socket they were started on.
+ */
+let live = null
+const outbox = []
+const OUTBOX_MAX = 2000
+function sendLive(obj) {
+  if (live && live.readyState === WebSocket.OPEN) return live.send(JSON.stringify(obj))
+  if (outbox.length >= OUTBOX_MAX) outbox.shift()
+  outbox.push(obj)
+}
 const ANSWER_TIMEOUT_MS = 3 * 60 * 1000
 
 /** Start the bridge with resolved settings. Runs until the process exits. */
@@ -89,7 +104,7 @@ const tools = {
     const before = await snapshot(dir).catch(() => null)
     let seq = 0
     const io = {
-      emit: event => send(ws, { type: 'job.event', jobId, seq: ++seq, at: new Date().toISOString(), event }),
+      emit: event => sendLive({ type: 'job.event', jobId, seq: ++seq, at: new Date().toISOString(), event }),
       ask: (request, signal) =>
         new Promise((resolve, reject) => {
           const key = `${jobId}:${request.id}`
@@ -108,16 +123,26 @@ const tools = {
           }, { once: true })
         }),
     }
-    void agent.run({ prompt, sessionId: args.session_id, cwd: dir, policy: args.policy ?? {}, persona: args.persona ?? null }, io).then(async outcome => {
+    const abort = new AbortController()
+    running.set(jobId, abort)
+    void agent.run({ prompt, sessionId: args.session_id, cwd: dir, policy: args.policy ?? {}, persona: args.persona ?? null, abort }, io).then(async outcome => {
+      running.delete(jobId)
       for (const key of [...answerWaits.keys()]) if (key.startsWith(`${jobId}:`)) answerWaits.delete(key)
       let change = null
       if (before) change = await changesSince(before).catch(err => (log(`git after job failed: ${err.message}`), null))
       log(`job ${jobId.slice(0, 8)} ${outcome.ok ? 'done' : 'error'}${change ? ` · ${change.stats.files} files +${change.stats.adds} -${change.stats.dels}, ${change.commits.length} commits` : ''}`)
       const result = { session_id: outcome.sessionId, result: outcome.text ?? '', stats: outcome.stats, cwd: display(dir), change, agent: agent.id }
-      send(ws, { type: 'job', jobId, status: outcome.ok ? 'done' : 'error', result, error: outcome.error })
+      sendLive({ type: 'job', jobId, status: outcome.ok ? 'done' : 'error', result, error: outcome.error })
     })
     return { started: true, agent: agent.id, cwd: display(dir), git: before ? { repo: before.repo, branch: before.branch, head: before.head?.slice(0, 7) ?? null } : null }
   },
+  /** Stop a running job: the agent is cut off; whatever it committed stays. */
+  stop_job(args) {
+    const abort = running.get(String(args.job_id ?? ''))
+    if (!abort) return { stopped: false, note: 'no such job running here' }
+    abort.abort()
+    return { stopped: true }
+  },
   /** Older API builds still call ask_claude. */
   ask_claude(args, ws) {
     return tools.run_agent({ ...args, agent: 'claude' }, ws)
@@ -159,6 +184,13 @@ end tell`
   stage_files(args) {
     return stageFiles(args)
   },
+  /** What a designer or researcher produced under its output folder, and sending it to Kira's storage. */
+  list_outputs(args) {
+    return listOutputs(args)
+  },
+  upload_outputs(args) {
+    return uploadOutputs(args)
+  },
   /** Which GitHub repo a folder's origin points at (project link enrichment). */
   async repo_of_folder(args) {
     return { repo: await repoOfFolder(args.path) }
@@ -213,6 +245,12 @@ function connect() {
       // Tell the API which tools this bridge build implements, so a stale
       // bridge is reported as such instead of "unknown tool".
       send(ws, { type: 'capabilities', tools: Object.keys(tools), version: BRIDGE_VERSION, platform: process.platform, agents: Object.values(AGENTS).map(a => ({ id: a.id, name: a.name, capabilities: a.capabilities })) })
+      live = ws
+      // Job events and results from while we were disconnected, in order.
+      if (outbox.length) {
+        log(`sending ${outbox.length} queued job messages`)
+        for (const o of outbox.splice(0)) ws.send(JSON.stringify(o))
+      }
       return log(`registered as bridge ${msg.bridgeId} (${Object.keys(tools).length} tools)`)
     }
     if (msg.type === 'job.answer') {
@@ -236,6 +274,7 @@ function connect() {
   })
   ws.on('close', (code, reason) => {
     clearInterval(ping)
+    if (live === ws) live = null
     if (code === 4001) {
       log('token rejected; create a new one in the portal')
       process.exit(1)

package/src/worktrees.mjs

@@ -211,3 +211,63 @@ export async function stageFiles({ path: p, files }) {
   }
   return { dir: `${STAGE_DIR}/`, staged, bytes: total }
 }
+
+const OUTPUT_MAX_FILES = 60
+const OUTPUT_MAX_BYTES = 40 * 1024 * 1024
+
+function mimeOf(name) {
+  const ext = name.toLowerCase().split('.').pop()
+  return { html: 'text/html', htm: 'text/html', css: 'text/css', js: 'text/javascript', md: 'text/markdown', txt: 'text/plain', json: 'application/json', svg: 'image/svg+xml', png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp', pdf: 'application/pdf', csv: 'text/csv' }[ext] ?? 'application/octet-stream'
+}
+
+/** Files under an output folder of a worktree (a designer's design/, a researcher's docs/research/), with sizes and types. */
+export async function listOutputs({ path: p, dir }) {
+  const path = resolveUserPath(String(p ?? ''))
+  const base = join(path, String(dir ?? '').replace(/^\/+|\/+$/g, ''))
+  if (!base.startsWith(path + '/')) return { error: 'bad output folder' }
+  const { readdir } = await import('node:fs/promises')
+  const out = []
+  let total = 0
+  const walk = async d => {
+    let entries = []
+    try {
+      entries = await readdir(d, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const e of entries) {
+      if (e.name.startsWith('.') || e.name === 'node_modules') continue
+      const full = join(d, e.name)
+      if (e.isDirectory()) await walk(full)
+      else if (e.isFile() && out.length < OUTPUT_MAX_FILES) {
+        const size = (await stat(full)).size
+        if (total + size > OUTPUT_MAX_BYTES) continue
+        total += size
+        out.push({ rel: full.slice(base.length + 1), bytes: size, mime: mimeOf(e.name) })
+      }
+    }
+  }
+  await walk(base)
+  return { dir, files: out, bytes: total }
+}
+
+/** PUT each output file to the signed URL Kira gave for it. */
+export async function uploadOutputs({ path: p, dir, files }) {
+  const path = resolveUserPath(String(p ?? ''))
+  const base = dir ? join(path, String(dir).replace(/^\/+|\/+$/g, '')) : path
+  const uploaded = []
+  const failed = []
+  for (const f of files ?? []) {
+    try {
+      const full = resolve(base, String(f.rel))
+      if (!full.startsWith(path + '/')) throw new Error('outside the worktree')
+      const body = await readFile(full)
+      const res = await fetch(String(f.url), { method: 'PUT', headers: { 'content-type': String(f.mime ?? 'application/octet-stream') }, body })
+      if (!res.ok) throw new Error(`upload failed (${res.status})`)
+      uploaded.push(f.rel)
+    } catch (err) {
+      failed.push({ rel: f.rel, error: err.message })
+    }
+  }
+  return { uploaded, failed }
+}