kira-glasses-bridge 2.28.0 → 2.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.28.0",
+  "version": "2.29.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/appollo/asc-launch.mjs

@@ -0,0 +1,90 @@
+// Appollo (POC): getting an app in App Store Connect to Apple's review. Reads asc's release
+// dashboard and its submission readiness report; the only writes are three fixed fixes the person
+// starts from the page (price Free, every country, the reviewer's sign-in). Also finds the app's
+// code on this Mac by its bundle id.
+import { execFile } from 'node:child_process'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { run } from './asc-run.mjs'
+
+const APP_ID = /^\d{6,12}$/
+const UUID = /^[0-9a-f-]{36}$/i
+const BUNDLE_ID = /^[A-Za-z0-9.-]{3,155}$/
+const FIND_MS = 20_000
+const FIND_ROOT = join(homedir(), 'Developer')
+
+/** The project files that name an app's bundle id: Xcode, XcodeGen, Expo. */
+const PROJECT_FILES = ['project.pbxproj', 'project.yml', 'app.json', 'app.config.ts', 'app.config.js']
+const SKIP_DIRS = ['node_modules', 'Pods', 'DerivedData', '.git', 'build', 'dist', '.expo']
+
+function appId(args) {
+  const id = String(args.app_id ?? '')
+  if (!APP_ID.test(id)) throw new Error('not an App Store Connect app id')
+  return id
+}
+
+/** The project folder a project file belongs to (the folder holding the .xcodeproj, or app.json's). */
+function projectFolder(file) {
+  const parts = file.split('/')
+  const xcodeproj = parts.findIndex(p => p.endsWith('.xcodeproj'))
+  return (xcodeproj > 0 ? parts.slice(0, xcodeproj) : parts.slice(0, -1)).join('/')
+}
+
+export const ascLaunchTools = {
+  /** asc's release dashboard and readiness report for one app, as they come. */
+  async asc_launch_readiness(args) {
+    const id = appId(args)
+    const [status, report] = await Promise.all([
+      run(['status', '--app', id, '--output', 'json']),
+      run(['validate', '--app', id, '--deep', '--output', 'json'], { timeout: 120_000 }),
+    ])
+    return { status: status.data ?? null, report: report.data ?? null, error: status.error ?? report.error ?? null }
+  },
+
+  /** One of the fixes the person starts: price Free, every country, or the reviewer's sign-in. */
+  async asc_launch_fix(args) {
+    const id = appId(args)
+    const write = argv => run([...argv, '--output', 'json'], { readOnly: false })
+    if (args.action === 'free')
+      return write(['pricing', 'schedule', 'create', '--app', id, '--free', '--base-territory', 'US'])
+    if (args.action === 'everywhere')
+      return write([
+        'pricing', 'availability', 'create', '--app', id, '--all-territories', '--available', 'true',
+        '--available-in-new-territories', 'true', '--if-exists', 'update',
+      ])
+    if (args.action === 'reviewer') {
+      const detail = String(args.detail_id ?? '')
+      const name = String(args.name ?? '').trim()
+      const password = String(args.password ?? '')
+      if (!UUID.test(detail) || !name || !password || password.length > 100)
+        return { error: 'the reviewer needs a username and a password (100 characters or fewer)' }
+      // The password goes to asc through its environment (@env:), never on a command line.
+      return run(
+        [
+          'review', 'details-update', '--id', detail, '--demo-account-required', 'true',
+          '--demo-account-name', name, '--demo-account-password', '@env:APPOLLO_REVIEWER_PASSWORD', '--output', 'json',
+        ],
+        { readOnly: false, extraEnv: { APPOLLO_REVIEWER_PASSWORD: password } },
+      )
+    }
+    return { error: 'not a fix Appollo knows' }
+  },
+
+  /** Folders under ~/Developer whose project names this bundle id. */
+  appollo_find_project(args) {
+    const bundleId = String(args.bundle_id ?? '')
+    if (!BUNDLE_ID.test(bundleId)) return Promise.resolve({ error: 'not a bundle id' })
+    const grep = [
+      '-rlF', ...PROJECT_FILES.map(f => `--include=${f}`), ...SKIP_DIRS.map(d => `--exclude-dir=${d}`),
+      '-e', `"${bundleId}"`, '-e', `= ${bundleId};`, '-e', `: ${bundleId}`, FIND_ROOT,
+    ]
+    return new Promise(resolve => {
+      execFile('grep', grep, { timeout: FIND_MS, maxBuffer: 1024 * 1024 }, (_err, stdout) => {
+        const all = [...new Set(String(stdout ?? '').split('\n').filter(Boolean).map(projectFolder))]
+        // An Expo app's ios/ folder names the bundle id too: keep only the outermost project.
+        const folders = all.filter(f => !all.some(o => o !== f && f.startsWith(`${o}/`)))
+        resolve({ folders: folders.slice(0, 5).map(f => f.replace(homedir(), '~')) })
+      })
+    })
+  },
+}

package/src/appollo/asc-run.mjs

@@ -1,5 +1,6 @@
 // Running the asc CLI on this Mac (Appollo's way to App Store Connect): reads with ASC_READ_ONLY=1
-// unless told otherwise, answered as JSON.
+// unless told otherwise, answered as JSON. A report that fails on purpose (asc validate exits 1 when
+// something blocks submission) still answers with its JSON.
 import { execFile } from 'node:child_process'
 import { existsSync } from 'node:fs'
 
@@ -23,12 +24,15 @@ export function run(args, { readOnly = true, extraEnv = {}, timeout = READ_TIMEO
         const out = String(stdout ?? '').trim()
         if (err && err.code === 'ENOENT')
           return resolve({ error: 'asc is not installed on this Mac (brew install asc)', missing: true })
-        if (err) return resolve({ error: (String(stderr ?? '').trim() || err.message).slice(0, 2000) })
+        let data = out
         try {
-          resolve({ data: out ? JSON.parse(out) : null })
+          data = out ? JSON.parse(out) : null
         } catch {
-          resolve({ data: out })
+          // Not JSON: asc's text.
         }
+        if (err && !(data && typeof data === 'object'))
+          return resolve({ error: (String(stderr ?? '').trim() || err.message).slice(0, 2000) })
+        resolve({ data })
       },
     )
   })

package/src/appollo/index.mjs

@@ -1,7 +1,8 @@
 // Appollo (POC) on this Mac: App Store Connect through asc, each app's workspace in ~/Appollo, and
 // the Doctor's checks. One export, so the bridge registers Appollo in one line (and drops it in one).
 import { ascTools } from './asc.mjs'
+import { ascLaunchTools } from './asc-launch.mjs'
 import { doctorTools } from './doctor.mjs'
 import { appolloTools } from './workspace.mjs'
 
-export const appolloBridgeTools = { ...ascTools, ...appolloTools, ...doctorTools }
+export const appolloBridgeTools = { ...ascTools, ...ascLaunchTools, ...appolloTools, ...doctorTools }

package/src/checkouts.mjs

@@ -0,0 +1,74 @@
+// Where a GitHub repo is already checked out on this Mac, so Kira links that folder instead of guessing a
+// path or cloning another copy: the folders Claude Code has worked in (and the checkouts they sit in),
+// then a shallow look through the usual places people keep code. Reads .git/config, runs nothing.
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { listProjects } from './claude-sessions.mjs'
+import { display, remoteToRepo } from './git.mjs'
+
+const ROOTS = ['Developer', 'code', 'src', 'Projects', 'dev', 'repos', 'work']
+const DEPTH = 3
+const BUDGET_MS = 4000
+const SKIP = new Set(['node_modules', 'Library', 'Applications', 'Pictures', 'Music', 'Movies'])
+
+/** The origin's URL in a .git/config's text, or null. */
+export function originOf(config) {
+  let inOrigin = false
+  for (const raw of String(config ?? '').split('\n')) {
+    const line = raw.trim()
+    if (line.startsWith('[')) inOrigin = /^\[remote\s+"origin"\]$/.test(line)
+    else if (inOrigin) {
+      const m = /^url\s*=\s*(.+)$/.exec(line)
+      if (m) return m[1].trim()
+    }
+  }
+  return null
+}
+
+const sameRepo = (a, b) => !!a && !!b && a.toLowerCase() === b.toLowerCase()
+const isDir = p => stat(p).then(s => s.isDirectory()).catch(() => false)
+
+/** The repo a checkout's origin points at (a main checkout: .git is a folder, not a worktree's file). */
+async function repoAt(dir) {
+  if (!(await isDir(join(dir, '.git')))) return null
+  return remoteToRepo(originOf(await readFile(join(dir, '.git', 'config'), 'utf8').catch(() => '')))
+}
+
+/** The checkout a folder sits in (itself or a parent), or null. */
+async function checkoutAround(dir) {
+  for (let d = dir; d && d !== dirname(d); d = dirname(d)) {
+    if (await isDir(join(d, '.git'))) return d
+  }
+  return null
+}
+
+/** Checkouts under a folder, a few levels down; a checkout isn't looked inside. */
+async function scan(dir, depth, until, found) {
+  if (depth < 0 || Date.now() > until) return
+  if (await isDir(join(dir, '.git'))) return found.add(dir)
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+  for (const e of entries) {
+    if (!e.isDirectory() || e.name.startsWith('.') || SKIP.has(e.name)) continue
+    await scan(join(dir, e.name), depth - 1, until, found)
+  }
+}
+
+/** Every checkout of `repo` ("owner/name") on this Mac, as ~ paths; Kira's own worktrees aren't. */
+export async function findCheckouts(repo, { home = homedir(), known = null } = {}) {
+  const candidates = new Set()
+  const worked = known ?? ((await listProjects(50).catch(() => ({ projects: [] }))).projects ?? []).map(p => p.cwd)
+  for (const cwd of worked) {
+    const top = await checkoutAround(cwd)
+    if (top) candidates.add(top)
+  }
+  const until = Date.now() + BUDGET_MS
+  for (const root of ROOTS) await scan(join(home, root), DEPTH, until, candidates)
+  const kira = join(home, '.kira')
+  const matches = []
+  for (const dir of candidates) {
+    if (dir.startsWith(kira)) continue
+    if (sameRepo(await repoAt(dir), repo)) matches.push(dir)
+  }
+  return { repo, checkouts: [...new Set(matches)].sort().map(display) }
+}

package/src/git.mjs

@@ -65,9 +65,9 @@ export async function snapshot(dir) {
   }
 }
 
-function remoteToRepo(url) {
-  if (!url) return null
-  const m = /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?$/.exec(url)
+/** "owner/name" from a GitHub remote URL (ssh or https), or null. */
+export function remoteToRepo(url) {
+  const m = /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?\/?$/.exec(String(url ?? '').trim())
   return m ? m[1] : null
 }
 

package/src/mac-tools.mjs

@@ -1,9 +1,10 @@
-// The bridge's tools for this Mac itself: its apps, a terminal, a new project's folder, and
+// The bridge's tools for this Mac itself: its apps, a terminal, a project's folder (found or new), and
 // (inside the Mac app only) its shells for other devices and its browser dock.
 import { execFile } from 'node:child_process'
 import { openApp, installedApps } from './apps.mjs'
 import { resolveUserPath } from './files.mjs'
 import { display, setupProjectFolder } from './git.mjs'
+import { findCheckouts } from './checkouts.mjs'
 import { terminalCall } from './terminals.mjs'
 import { safeCommand, terminalScript } from './terminal-command.mjs'
 import { host } from './host.mjs'
@@ -28,6 +29,13 @@ export const macTools = {
     })
   },
 
+  /** Where a repo ("owner/name") is already checked out here, so a project links it instead of cloning. */
+  async find_checkouts(args) {
+    const repo = String(args.repo ?? '').trim()
+    if (!/^[^/\s]+\/[^/\s]+$/.test(repo)) return { error: 'repo must be "owner/name"' }
+    return findCheckouts(repo)
+  },
+
   /** This Mac's shells for a browser elsewhere (only inside the Mac app, only when switched on there). */
   terminal: args => terminalCall(args),
 

package/src/worktrees.mjs

@@ -9,7 +9,7 @@ import { mkdir, stat, readFile, writeFile, appendFile, rm } from 'node:fs/promis
 import { pipeline } from 'node:stream/promises'
 import { createWriteStream } from 'node:fs'
 import { Readable } from 'node:stream'
-import { display } from './git.mjs'
+import { display, remoteToRepo } from './git.mjs'
 import { resolveUserPath } from './files.mjs'
 
 const ROOT = join(homedir(), '.kira', 'worktrees')
@@ -24,11 +24,6 @@ function git(cwd, args, { timeout = 60_000 } = {}) {
   })
 }
 
-function remoteToRepo(url) {
-  const m = /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?$/.exec(url ?? '')
-  return m ? m[1] : null
-}
-
 const sameRepo = (a, b) => !!a && !!b && a.toLowerCase() === b.toLowerCase()
 
 /** The GitHub repo a folder's origin points at, or null. */