kira-glasses-bridge 2.40.0 → 2.41.0

package/package.json

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

@@ -0,0 +1,36 @@
+// Auto mode: the person is not asked anything, ever. Every request a job's agent would put to them
+// (a permission, a plan to approve, a question, an MCP server's form) is answered here at once, for
+// Claude Code and Codex alike (job-tools.mjs wraps io.ask and io.emit with autoIo). Kira's deny rules
+// still refuse before anything is asked (checks.mjs): a refusal is not a question.
+import { modeOf } from './settings.mjs'
+
+/** What a question gets in Auto mode, as its answer. */
+export const AUTO_WORDS =
+  'Auto mode: the person is not taking questions. ' +
+  'Go with the sensible default, say your assumption in one line, and carry on.'
+
+/** Whether the person chose Auto mode for this job. */
+export const isAuto = settings => modeOf(settings) === 'auto'
+
+/** Auto mode's answer to a request: go ahead; a question gets AUTO_WORDS. Never "always" (that writes a rule). */
+export function autoAnswer(request) {
+  if (request?.type === 'plan') return { optionIds: ['approve'] }
+  if (request?.type === 'choice' || request?.type === 'text') return { optionIds: [], text: AUTO_WORDS }
+  return { optionIds: ['allow', 'accept'] }
+}
+
+/** A request, or its answer by Auto mode: neither leaves the Mac, so no card and nothing for the API to file. */
+const unseen = event => event?.kind === 'request' || (event?.kind === 'request_resolved' && event.by === 'auto')
+
+/**
+ * The job's io for Auto mode: a request is never shown (no card, no push to the phone or glasses)
+ * and is answered at once, by 'auto'. Other modes get io back as it is.
+ */
+export function autoIo(io, settings) {
+  if (!isAuto(settings)) return io
+  return {
+    ...io,
+    emit: event => (unseen(event) ? undefined : io.emit(event)),
+    ask: async request => ({ answer: autoAnswer(request), by: 'auto' }),
+  }
+}

package/src/agents/claude-calls.mjs

@@ -3,7 +3,7 @@
 // SDK expects.
 import { homedir } from 'node:os'
 import { relative, resolve, sep } from 'node:path'
-import { PLAN_OPTIONS, permissionOptions, requestId } from './protocol.mjs'
+import { PLAN_OPTIONS, permissionOptions, requestId, unanswered } from './protocol.mjs'
 
 /** What an agent is told when it may not do something. */
 export const NOT_ANOTHER_WAY =
@@ -122,8 +122,23 @@ export function toRequest(name, input, cwd, verdict) {
   }
 }
 
-/** Turn a protocol answer back into what the SDK expects. */
-export function applyAnswer(name, input, request, answer) {
+/**
+ * What the agent is told when nobody answered a card in time, by the card's type. Said as no refusal,
+ * so it neither gives up on the task nor reads the timeout's words as the person's.
+ */
+const UNANSWERED = {
+  permission: 'Nobody answered the permission card in time. This was not a refusal: ' +
+    'carry on without this step, or try again later.',
+  choice: 'Nobody answered the question in time. This was not a refusal: ' +
+    'carry on with your best judgment and say what you assumed.',
+  plan: 'Nobody answered about the plan in time. This was not a refusal: ' +
+    'stay in plan mode and say the plan is waiting for their go-ahead.',
+}
+
+/** Turn a protocol answer (`{ answer, by }`) back into what the SDK expects. */
+export function applyAnswer(name, input, request, resolved) {
+  if (unanswered(resolved)) return { behavior: 'deny', message: UNANSWERED[request.type] ?? UNANSWERED.permission }
+  const answer = resolved.answer ?? {}
   const chosen = answer.optionIds ?? []
   if (request.type === 'choice') {
     const answers = {}

package/src/agents/claude.mjs

@@ -86,7 +86,7 @@ async function run({ prompt, sessionId, cwd, persona, settings, abort }, io) {
       resolved = { answer: { optionIds: [], text: err.message }, by: 'timeout' }
     }
     io.emit({ kind: 'request_resolved', id: request.id, answer: resolved.answer, by: resolved.by })
-    return applyAnswer(toolName, input, request, resolved.answer)
+    return applyAnswer(toolName, input, request, resolved)
   }
 
   // Background work (subagents, `run_in_background` shell commands, monitors)

package/src/agents/codex-forms.mjs

@@ -3,7 +3,7 @@
 // a link to open or a plain yes/no as a choice; and the answer back as MCP's accept, decline or cancel
 // with the form's content. Pure.
 import { short } from './claude-calls.mjs'
-import { requestId } from './protocol.mjs'
+import { requestId, unanswered } from './protocol.mjs'
 
 const ACCEPT = [
   { id: 'accept', label: 'Accept' },
@@ -93,7 +93,7 @@ function valueOf(f, a) {
  */
 export function formResponse(params, request, resolved) {
   if (!request) return { action: 'decline' }
-  if (resolved?.by === 'timeout') return { action: 'cancel' }
+  if (unanswered(resolved)) return { action: 'cancel' }
   const answer = resolved?.answer ?? {}
   if (!request.questions) return { action: (answer.optionIds ?? []).includes('accept') ? 'accept' : 'decline' }
   const content = {}

package/src/agents/codex-requests.mjs

@@ -3,7 +3,7 @@
 // and an MCP server's form (mcpServer/elicitation/request), each as a request card; and the person's
 // answer back in Codex's own response shape (an MCP server's form: codex-forms.mjs). Pure; codex-ask.mjs asks.
 import { displayPath, short } from './claude-calls.mjs'
-import { permissionOptions, requestId } from './protocol.mjs'
+import { permissionOptions, requestId, unanswered } from './protocol.mjs'
 
 const options = list => list.map((o, k) => ({ id: `o${k + 1}`, ...o }))
 /** A question's answer: per question, else (the first one) the answer's own options and words. */
@@ -37,7 +37,7 @@ export function userInputRequest(params) {
 
 /** The answers as Codex takes them, by its question ids; unanswered (timed out, secret) ones are empty. */
 export function userInputResponse(params, request, resolved) {
-  const answer = resolved?.by === 'timeout' ? undefined : resolved?.answer
+  const answer = unanswered(resolved) ? undefined : resolved?.answer
   const asked = (params.questions ?? []).filter(q => !q.isSecret)
   const answers = Object.fromEntries((params.questions ?? []).map(q => [q.id, { answers: [] }]))
   asked.forEach((codexQ, n) => {

package/src/agents/protocol.mjs

@@ -58,6 +58,9 @@ export const PLAN_OPTIONS = [
   { id: 'revise', label: 'Revise', description: 'Change the plan first; say what to change' },
 ]
 
+/** Nobody answered in time (or the job stopped first): not a refusal, so never reported as one. */
+export const unanswered = resolved => resolved?.by === 'timeout'
+
 /** Normalize the many ways an answer can arrive into option ids and text. */
 export function normalizeAnswer(answer) {
   const a = answer ?? {}

package/src/agents/settings.mjs

@@ -10,14 +10,19 @@ const MODES = new Set(['acceptEdits', 'default', 'plan', 'auto'])
 /** The id an older Kira API sent for ask before edits. */
 const OLD = { ask: 'default' }
 
+/** The mode the person chose, by Claude Code's id; accept edits when it names none. */
+export function modeOf(settings) {
+  const said = Object.hasOwn(OLD, settings?.mode ?? '') ? OLD[settings.mode] : settings?.mode
+  return MODES.has(said) ? said : 'acceptEdits'
+}
+
 /**
  * The SDK's query options for these settings (left out when unset, so Claude Code's defaults stand).
  * `kiraDecides`: Kira's rules check each call (checks.mjs); without them, edits are asked about.
  */
 export function sdkOptionsFor(settings, kiraDecides = true) {
   const s = settings ?? {}
-  const said = Object.hasOwn(OLD, s.mode) ? OLD[s.mode] : s.mode
-  const mode = MODES.has(said) ? said : 'acceptEdits'
+  const mode = modeOf(s)
   return {
     permissionMode: kiraDecides ? mode : mode === 'plan' ? 'plan' : 'default',
     ...(typeof s.model === 'string' && MODEL.test(s.model) ? { model: s.model } : {}),

package/src/job-tools.mjs

@@ -2,6 +2,7 @@
 // reported when done), stopping one, and steering one (words into its turn at work).
 import { agentById } from './agents/index.mjs'
 import { awaitAnswer, forgetJob } from './agents/answers.mjs'
+import { autoIo } from './agents/auto.mjs'
 import { resolveCwd, folderExists } from './claude-run.mjs'
 import { readSession } from './claude-sessions.mjs'
 import { changesSince, display, snapshot } from './git.mjs'
@@ -44,18 +45,19 @@ export const jobTools = {
     const abort = new AbortController()
     const live = { abort, steer: null }
     let seq = 0
-    const io = {
+    const settings = args.settings ?? null
+    // Auto mode answers every request itself: nothing waits on the person (auto.mjs).
+    const io = autoIo({
       emit: event => sendLive({ type: 'job.event', jobId, seq: ++seq, at: new Date().toISOString(), event }),
       ask: (request, signal) => awaitAnswer(jobId, request, signal),
       check: call => checkCall(jobId, call, sendIfLive),
       steerable: steer => (live.steer = steer),
-    }
+    }, settings)
     running.set(jobId, live)
     // Started is said at once. The git snapshot (what changed, reported at the end) is taken first but
     // in the background: in a big repository it takes longer than the API waits for this answer.
     const before = snapshot(dir).catch(() => null)
     const persona = args.persona ?? null
-    const settings = args.settings ?? null
     // What came with it from Kira, already copied here (the prompt names their paths): codex-input.mjs.
     const attachments = Array.isArray(args.attachments) ? args.attachments : []
     const job = { prompt, attachments, sessionId, cwd: dir, persona, settings, abort }