kira-glasses-bridge 2.24.0 → 2.25.0

package/README.md

@@ -4,7 +4,7 @@ Connects your Mac to **Kira**, the assistant for Even Realities G2 glasses. With
 
 ## Setup
 
-1. In the Kira portal, open **Connections → Claude Code → Set up** and copy the command it shows.
+1. In the Kira portal, open **Settings → Devices** and choose **Set up with Terminal**, then copy the command it shows.
 2. Paste it into Terminal:
 
    ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.24.0",
+  "version": "2.25.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/agent-files.mjs

@@ -12,6 +12,7 @@ import {
   exists,
   field,
   inside,
+  oneAtATime,
   readSmall,
   refuseLinks,
   splitFront,
@@ -19,8 +20,13 @@ import {
 } from './config-folders.mjs'
 
 const MAX_MD = 256 * 1024
-/** Claude Code loads the first 200 lines or 25KB of MEMORY.md; Kira keeps it to this. */
+/** A MEMORY.md Kira reads or replaces whole (from the agent's editor) is at most this. */
 const MAX_MEMORY = 64 * 1024
+/** Claude Code loads the first 200 lines or 25KB of MEMORY.md: what Kira adds stays inside that. */
+const LOAD_LINES = 200
+const LOAD_BYTES = 25 * 1024
+/** A line Kira added after a task (rememberAgent): "- 2026-10-12: …". The only lines she ever drops. */
+const KIRAS_LINE = /^- \d{4}-\d{2}-\d{2}: /
 const WHAT = 'a subagent'
 const NAMED = { loose: true }
 const claudeRoot = () => agentFolders()[0].root
@@ -113,19 +119,45 @@ export async function removeAgent({ slug } = {}, root = claudeRoot()) {
 /** Replace a subagent's MEMORY.md, whole (`name` is its front-matter name). */
 export async function writeAgentMemory({ name, md } = {}, root = FOLDERS.claude.agentMemory()) {
   const file = memoryFile(name, root)
-  const text = String(md ?? '')
+  return oneAtATime(file, () => writeMemoryFile(name, file, String(md ?? ''), root))
+}
+
+async function writeMemoryFile(name, file, text, root) {
   if (Buffer.byteLength(text) > MAX_MEMORY) throw new Error('That memory is too large')
   await refuseLinks([root, join(file, '..'), file], 'edit')
   await writeWhole(file, text)
   return { name, path: display(file), memory: text }
 }
 
-/** Add a line to a subagent's MEMORY.md (what Kira keeps after a task); the oldest go when it's full. */
+/**
+ * MEMORY.md with `entry` added at the end, kept inside what Claude Code loads (200 lines, 25KB) by
+ * dropping Kira's own oldest dated lines, never the person's. Null when it can't fit without
+ * dropping theirs (then it isn't added: past the window Claude Code wouldn't read it anyway).
+ */
+export function withEntry(text, entry) {
+  const lines = text.trimEnd() ? text.trimEnd().split('\n') : []
+  lines.push(entry)
+  const fits = () => lines.length <= LOAD_LINES && Buffer.byteLength(`${lines.join('\n')}\n`) <= LOAD_BYTES
+  while (!fits()) {
+    const oldest = lines.findIndex((l, i) => i < lines.length - 1 && KIRAS_LINE.test(l))
+    if (oldest < 0) return null
+    lines.splice(oldest, 1)
+  }
+  return `${lines.join('\n')}\n`
+}
+
+/** Add a line to a subagent's MEMORY.md (what Kira keeps after a task); see withEntry. */
 export async function rememberAgent({ name, line } = {}, root = FOLDERS.claude.agentMemory()) {
+  const file = memoryFile(name, root)
   const entry = `- ${String(line ?? '').replace(/\s+/g, ' ').trim().slice(0, 400)}`
-  let text = `${(await readMemory(name, root)).trimEnd()}\n${entry}`.trim() + '\n'
-  while (Buffer.byteLength(text) > MAX_MEMORY && text.includes('\n')) text = text.slice(text.indexOf('\n') + 1)
-  return writeAgentMemory({ name, md: text }, root)
+  return oneAtATime(file, async () => {
+    const was = await readSmall(file, MAX_MEMORY)
+    // One there that's too big to read is theirs, whole: left as it is.
+    if (was === null && (await exists(file))) return { name, path: display(file), memory: null, full: true }
+    const text = withEntry(was ?? '', entry)
+    if (text === null) return { name, path: display(file), memory: was, full: true }
+    return writeMemoryFile(name, file, text, root)
+  })
 }
 
 /** The bridge tools (index.mjs). */

package/src/cli.mjs

@@ -42,7 +42,7 @@ folders and apps, by voice.
   kira-bridge logs                          follow the service log
   kira-bridge install | uninstall           manage the background service
 
-Get a token from the Kira portal: Connections -> Claude Code -> Set up.
+Get a token from the Kira portal: Settings -> Devices -> Set up with Terminal.
 Settings are kept in ~/.kira/bridge.json.`
 
 async function main() {

package/src/config-folders.mjs

@@ -10,6 +10,7 @@
 //   Codex (developers.openai.com/codex: skills, subagents): ~/.agents/skills/<name>/SKILL.md (the
 //     shared Agent Skills folder) and ~/.codex/agents/<name>.toml. ~/.codex/skills isn't in its docs,
 //     but the Codex app keeps its own skills there, so Kira lists them as Codex's.
+import { randomBytes } from 'node:crypto'
 import { lstat, mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join, relative } from 'node:path'
@@ -90,15 +91,34 @@ export const exists = p => stat(p).then(
   () => false,
 )
 
-/** Write `text` to `file` whole: its folder made, through a temporary file renamed over the old one. */
+/**
+ * Write `text` to `file` whole: its folder made, through a temporary file renamed over the old one
+ * (named for this write alone, so two writes never share one).
+ */
 export async function writeWhole(file, text) {
   const dir = join(file, '..')
   await mkdir(dir, { recursive: true })
-  const tmp = join(dir, `.${file.slice(dir.length + 1)}.${process.pid}.tmp`)
+  const tmp = join(dir, `.${file.slice(dir.length + 1)}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`)
   await writeFile(tmp, text, 'utf8')
   await rename(tmp, file)
 }
 
+/** Per file: the change running on it, so a read-modify-write never interleaves with another. */
+const queues = new Map()
+
+/** Run `fn` once every change queued before it on `key` (a file's path) is done. */
+export function oneAtATime(key, fn) {
+  const before = queues.get(key) ?? Promise.resolve()
+  const run = before.then(fn, fn)
+  const settled = run.then(
+    () => {},
+    () => {},
+  )
+  queues.set(key, settled)
+  settled.then(() => queues.get(key) === settled && queues.delete(key))
+  return run
+}
+
 /** Front matter between --- lines, and the rest. */
 export function splitFront(md) {
   const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(md)

package/src/index.mjs

@@ -43,7 +43,8 @@ export function startBridge(config, hostHooks = {}) {
   if (config.claudeBin) process.env.KIRA_CLAUDE_BIN = config.claudeBin
   if (!config.url || !config.token) {
     throw new Error(
-      'No token. Run: npx kira-glasses-bridge --token <token>  (from the Kira portal → Connections → Claude Code)',
+      'No token. Run: npx kira-glasses-bridge --token <token>  ' +
+        '(from the Kira portal → Settings → Devices → Set up with Terminal)',
     )
   }
   // Terminal output is live or nothing: never queued for later like job events.

package/src/skill-files.mjs

@@ -2,7 +2,7 @@
 // in Codex's (config-folders.mjs says which loads which). Kira lists all of them, each with the
 // tools that load it (a skill linked into both folders is both's), and writes and removes the ones
 // a person makes in Kira, in Claude Code's folder.
-import { readdir, realpath, rmdir, unlink } from 'node:fs/promises'
+import { readdir, realpath, rename, rmdir, unlink } from 'node:fs/promises'
 import { join } from 'node:path'
 import {
   display,
@@ -110,10 +110,29 @@ export async function removeSkill({ slug } = {}, root = writeRoot()) {
   return { slug, removed: gone, path: display(dir), kept: left.length ? left : undefined }
 }
 
+/**
+ * Rename a skill: its folder moved whole (scripts, references and all) from `from` to `to`, then its
+ * SKILL.md rewritten there. Both names stay inside the folder, neither may be a link, and a skill
+ * already called `to` is never replaced.
+ */
+export async function renameSkill({ from, to, md } = {}, root = writeRoot()) {
+  const [was, dir] = [inside(root, from, WHAT), inside(root, to, WHAT)]
+  const text = String(md ?? '')
+  if (!/^---\r?\n/.test(text)) throw new Error('A SKILL.md starts with front matter between --- lines')
+  if (Buffer.byteLength(text) > MAX_MD) throw new Error('That SKILL.md is too large')
+  await refuseLinks([root, was, dir], 'rename')
+  if (!(await exists(join(was, 'SKILL.md')))) throw new Error(`No skill in ${display(was)}`)
+  if (await exists(dir)) throw new Error(`A skill named ${to} is already on your Mac`)
+  await rename(was, dir)
+  await writeWhole(join(dir, 'SKILL.md'), text)
+  return { slug: to, ...skillSummary(text, to), path: display(dir), providers: ['claude'], from: display(was) }
+}
+
 /** The bridge tools (index.mjs). */
 export const skillTools = {
   list_skills: () => listSkills(),
   read_skill: args => readSkill(args),
   write_skill: args => writeSkill(args),
   remove_skill: args => removeSkill(args),
+  rename_skill: args => renameSkill(args),
 }