kira-glasses-bridge 2.5.0 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.5.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 }, io) {
+export async function run({ prompt, sessionId, cwd, policy, persona, abort }, io) {
   let session = sessionId ?? null
   let text = ''
   let error = null
@@ -143,8 +143,28 @@ export async function run({ prompt, sessionId, cwd, policy }, io) {
   // Pre-tool hook: the policy is authoritative. It forces the prompt for what
   // it does not allow (so a permissive local config cannot bypass the person)
   // 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))) {
+      const reason = `${persona.name} uses the shell only for git and for reading files; run that another way or leave it.`
+      io.emit({ kind: 'request_resolved', id: `persona-${Date.now().toString(36)}`, answer: { optionIds: ['deny'] }, by: 'policy', tool: 'Bash', reason })
+      return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason } }
+    }
     const { decision, reason } = judge(input.tool_name, input.tool_input)
     if (decision === 'deny') io.emit({ kind: 'request_resolved', id: `policy-${Date.now().toString(36)}`, answer: { optionIds: ['deny'] }, by: 'policy', tool: input.tool_name, reason })
     return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: decision, permissionDecisionReason: `Kira: ${reason}` } }
@@ -178,6 +198,10 @@ export async function run({ prompt, sessionId, cwd, policy }, 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 } : {}),
         canUseTool,
         hooks: { PreToolUse: [{ hooks: [preToolUse] }] },
         ...(process.env.KIRA_CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.KIRA_CLAUDE_BIN } : {}),
@@ -210,7 +234,7 @@ export async function run({ prompt, sessionId, cwd, policy }, 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

@@ -4,12 +4,12 @@
 import WebSocket from 'ws'
 import { listProjects, listSessions, readSession } from './claude-sessions.mjs'
 import { snapshot, changesSince, display, setupProjectFolder } from './git.mjs'
-import { resolveCwd } from './claude-run.mjs'
+import { resolveCwd, folderExists } from './claude-run.mjs'
 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. */
@@ -81,11 +96,15 @@ const tools = {
       if (s?.cwd) cwd = s.cwd
     }
     const dir = resolveCwd(cwd)
-    log(`${agent.id} job=${jobId.slice(0, 8)} session=${args.session_id ?? 'new'} in ${display(dir)}: ${prompt.slice(0, 80)}`)
+    if (!folderExists(dir)) {
+      // The SDK would report a spawn failure as a broken binary; the folder is simply not there.
+      return { error: `The folder ${display(dir)} does not exist on this Mac. Link the project's real folder in the portal, or clone its repository there first (setup_project_folder); never guess a path.` }
+    }
+    log(`${agent.id} job=${jobId.slice(0, 8)}${args.persona?.name ? ` as ${args.persona.name}` : ''} session=${args.session_id ?? 'new'} in ${display(dir)}: ${prompt.slice(0, 80)}`)
     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}`
@@ -104,16 +123,26 @@ const tools = {
           }, { once: true })
         }),
     }
-    void agent.run({ prompt, sessionId: args.session_id, cwd: dir, policy: args.policy ?? {} }, 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)
@@ -155,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) }
@@ -209,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') {
@@ -232,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 }
+}