kira-glasses-bridge 2.4.0 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.4.0",
+  "version": "2.6.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 }, io) {
   let session = sessionId ?? null
   let text = ''
   let error = null
@@ -143,8 +143,17 @@ 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
   const preToolUse = async input => {
     if (input.hook_event_name !== 'PreToolUse') return {}
+    // 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 +187,9 @@ export async function run({ prompt, sessionId, cwd, policy }, io) {
         cwd,
         ...(sessionId ? { resume: sessionId } : {}),
         permissionMode: 'default',
+        // 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 } : {}),

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 } from './worktrees.mjs'
+import { prepareWorktree, worktreeStatus, pushWorktree, removeWorktree, repoOfFolder, stageFiles } from './worktrees.mjs'
 
 import { createRequire } from 'node:module'
 const { version: BRIDGE_VERSION } = createRequire(import.meta.url)('../package.json')
@@ -81,7 +81,11 @@ 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 = {
@@ -104,7 +108,7 @@ const tools = {
           }, { once: true })
         }),
     }
-    void agent.run({ prompt, sessionId: args.session_id, cwd: dir, policy: args.policy ?? {} }, io).then(async outcome => {
+    void agent.run({ prompt, sessionId: args.session_id, cwd: dir, policy: args.policy ?? {}, persona: args.persona ?? null }, io).then(async outcome => {
       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))
@@ -151,6 +155,10 @@ end tell`
   remove_worktree(args) {
     return removeWorktree(args)
   },
+  /** A task's reference files, downloaded into the worktree's .kira/files for the agent. */
+  stage_files(args) {
+    return stageFiles(args)
+  },
   /** Which GitHub repo a folder's origin points at (project link enrichment). */
   async repo_of_folder(args) {
     return { repo: await repoOfFolder(args.path) }

package/src/worktrees.mjs

@@ -5,7 +5,10 @@
 import { execFile } from 'node:child_process'
 import { homedir } from 'node:os'
 import { isAbsolute, join, resolve } from 'node:path'
-import { mkdir, stat } from 'node:fs/promises'
+import { mkdir, stat, readFile, writeFile, appendFile, rm } from 'node:fs/promises'
+import { pipeline } from 'node:stream/promises'
+import { createWriteStream } from 'node:fs'
+import { Readable } from 'node:stream'
 import { display } from './git.mjs'
 import { resolveUserPath } from './files.mjs'
 
@@ -162,3 +165,49 @@ export async function removeWorktree({ path: p, delete_branch: deleteBranch }) {
   if (deleteBranch && main && branch && branch !== 'HEAD') branchDeleted = (await git(main, ['branch', '-D', branch])).ok
   return { removed: true, branch, branch_deleted: branchDeleted }
 }
+
+const STAGE_DIR = '.kira/files'
+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.
+ */
+export async function stageFiles({ path: p, files }) {
+  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 })
+  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'])
+  if (excl.ok) {
+    const file = isAbsolute(excl.out) ? excl.out : join(path, excl.out)
+    await mkdir(join(file, '..'), { recursive: true })
+    const current = await readFile(file, 'utf8').catch(() => '')
+    if (!current.split('\n').includes('/.kira/')) await appendFile(file, `${current && !current.endsWith('\n') ? '\n' : ''}/.kira/\n`)
+  }
+  const staged = []
+  let total = 0
+  const seen = new Set()
+  for (const f of files ?? []) {
+    let name = String(f.name ?? 'file').replace(/[\/\\]/g, '_')
+    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))
+      const size = (await stat(dest)).size
+      total += size
+      staged.push({ name, path: `${STAGE_DIR}/${name}`, bytes: size, description: f.description || undefined })
+    } catch (err) {
+      staged.push({ name, error: err.message })
+    }
+  }
+  return { dir: `${STAGE_DIR}/`, staged, bytes: total }
+}