@ucsandman/legcli 0.7.0 → 0.8.0

package/src/launcher.mjs

@@ -46,6 +46,7 @@ const INSTALL_HINT = {
   claude: 'https://claude.com/claude-code (then `claude` to log in)',
   codex: 'npm i -g @openai/codex (then `codex login`)',
   agy: 'Antigravity CLI (`agy`), log in once interactively',
+  grok: 'xAI Grok CLI (`grok`), log in once via `grok login`',
 }
 
 // Rows: [name, status, detail]. Nothing here is fatal except "no adapter at all".
@@ -62,7 +63,7 @@ export async function preflight() {
     const v = viaNode ? version(process.execPath, [entry, '--version']) : version(bin)
     if (v) { present += 1; rows.push([name, 'ok', `${v} (${viaNode ? entry : bin})`]) } else rows.push([name, 'missing', INSTALL_HINT[name] ?? 'not on PATH'])
   }
-  rows.push(['fake adapters', 'ok', 'fake, fake-claude, fake-codex, fake-agy (tests and demo)'])
+  rows.push(['fake adapters', 'ok', 'fake, fake-claude, fake-codex, fake-agy, fake-grok (tests and demo)'])
   return { rows, adapters_present: present }
 }
 

package/src/mergequeue.mjs

@@ -82,7 +82,7 @@ export function resolveTestCommand(card, worktree) {
   return { command: null, source: 'none' }
 }
 
-function runTests(command, worktree) {
+export function runTests(command, worktree) {
   return runCommandAsync(command, worktree, { timeoutMs: TEST_TIMEOUT_MS, tailLines: 40 })
 }
 

package/src/preferences.mjs

@@ -7,11 +7,15 @@ import { home } from './store.mjs'
 import { writeJsonAtomic, withFileLock } from './fsx.mjs'
 
 export const HANDOFF_AGENTS = ['claude', 'codex', 'agy']
+export const ALL_HANDOFF_AGENTS = ['claude', 'codex', 'agy', 'grok']
 
 export function validHandoffOrder(value) {
-  return Array.isArray(value) && value.length === HANDOFF_AGENTS.length &&
-    new Set(value).size === HANDOFF_AGENTS.length &&
-    value.every((agent) => HANDOFF_AGENTS.includes(agent))
+  if (!Array.isArray(value)) return false
+  const set = new Set(value)
+  if (set.size !== value.length) return false
+  if (value.length === 3 && ['claude', 'codex', 'agy'].every((a) => set.has(a))) return true
+  if (value.length === 4 && ['claude', 'codex', 'agy', 'grok'].every((a) => set.has(a))) return true
+  return false
 }
 
 export function normalizeHandoffOrder(value) {
@@ -25,22 +29,38 @@ export function requireHandoffOrder(value) {
 
 export function preferencesFile() { return join(home(), 'preferences.json') }
 
+export function resolveAutoApprove({ env = process.env, preferences = null, cliFlag = null } = {}) {
+  if (cliFlag !== null && cliFlag !== undefined) return Boolean(cliFlag)
+  const envVal = env.LEG_AUTO_APPROVE ?? env.BATON_AUTO_APPROVE
+  if (envVal !== undefined) return envVal !== '0' && envVal !== 'false' && envVal !== 'off'
+  if ((env.LEG_NO_AUTO_APPROVE ?? env.BATON_NO_AUTO_APPROVE) === '1') return false
+  const prefs = preferences ?? readPreferences()
+  if (typeof prefs?.auto_approve === 'boolean') return prefs.auto_approve
+  return true
+}
+
 export function readPreferences() {
   const file = preferencesFile()
-  if (!existsSync(file)) return { handoff_order: [...HANDOFF_AGENTS] }
+  if (!existsSync(file)) return { handoff_order: [...HANDOFF_AGENTS], auto_approve: true }
   try {
     const value = JSON.parse(readFileSync(file, 'utf8'))
-    return { handoff_order: normalizeHandoffOrder(value?.handoff_order) }
+    return {
+      handoff_order: normalizeHandoffOrder(value?.handoff_order),
+      auto_approve: value?.auto_approve !== false,
+    }
   } catch {
-    return { handoff_order: [...HANDOFF_AGENTS] }
+    return { handoff_order: [...HANDOFF_AGENTS], auto_approve: true }
   }
 }
 
 export function writePreferences(patch) {
-  const order = requireHandoffOrder(patch?.handoff_order)
+  const order = patch?.handoff_order !== undefined ? requireHandoffOrder(patch?.handoff_order) : undefined
   mkdirSync(home(), { recursive: true })
   return withFileLock(preferencesFile() + '.lock', () => {
-    const next = { ...readPreferences(), handoff_order: order }
+    const current = readPreferences()
+    const next = { ...current }
+    if (order !== undefined) next.handoff_order = order
+    if (patch?.auto_approve !== undefined) next.auto_approve = Boolean(patch.auto_approve)
     writeJsonAtomic(preferencesFile(), next)
     return next
   })

package/src/runner.mjs

@@ -158,7 +158,7 @@ function gitDiff(cwd, headAtStart) {
 
 // Fallback when the cwd is not a git repo (tests, ad-hoc dirs): a shallow
 // mtime snapshot, so "wrote a file but no DONE" still reads as incomplete.
-const SNAP_SKIP = new Set(['.git', 'node_modules', '.baton', '.baton-worktrees'])
+const SNAP_SKIP = new Set(['.git', 'node_modules', '.baton', '.baton-worktrees', '.leg', '.leg-worktrees'])
 function fsSnapshot(cwd, depth = 3) {
   const out = new Map()
   const walk = (dir, rel, d) => {

package/src/server.mjs

@@ -27,7 +27,7 @@ import { resolveChb } from './handoff.mjs'
 import { listSessions, readSession, readEvents as readSessionEvents, requestControl, removeSession, overlaps, isActive, sessionsRoot, reapLost, readLand, readLandings, readRequests, writeRequests, appendEvent as appendSessionEvent, updateSession, HANDOFF_ORDER_CAPABILITY } from './sessions.mjs'
 import { sessionDetail, sessionDiff, DiffInputError } from './session-detail.mjs'
 import { refreshPointers } from './resume.mjs'
-import { landSession, landBlocker, landingNow, pruneSessionWorktree } from './land.mjs'
+import { landSession, landBlocker, landingNow, pruneSessionWorktree, canLand, prepareLanding, applyLandFix } from './land.mjs'
 import { readUsage, recordUsage, usageIsStale, candidates, isAvailable } from './usage.mjs'
 import { readAccounts, envFor, LAYOUT } from './accounts.mjs'
 import { readCodexUsage } from './taps/codex.mjs'
@@ -191,16 +191,17 @@ export async function detectTools({ refresh = false } = {}) {
     return !r.error && r.status === 0
   }
   const agents = {}
-  for (const name of ['claude', 'codex', 'agy']) {
+  for (const name of ['claude', 'codex', 'agy', 'grok']) {
     try {
-      const { bin, viaNode, entry } = (await getAdapter(name)).resolve()
+      const a = name === 'grok' ? (await import('./adapters/grok.mjs')).default : await getAdapter(name)
+      const { bin, viaNode, entry } = a.resolve()
       const target = viaNode ? (entry ?? bin) : bin
       agents[name] = /[\\/]/.test(target) ? existsSync(target) : probe(target)
     } catch { agents[name] = false }
   }
   let chb = false
   try { resolveChb(); chb = true } catch {}
-  toolsCache = { ...agents, grok: probe('grok'), chb, git: probe('git') }
+  toolsCache = { ...agents, chb, git: probe('git') }
   return toolsCache
 }
 
@@ -279,6 +280,7 @@ export function sessionsView({ viewer = null, share = null } = {}) {
     const preferredNext = chain[0] ?? null
     const availabilityKnown = Boolean(s.installed)
     const eligibleNext = availabilityKnown ? (chain.find((next) => s.installed[next.agent] !== false && isAvailable(readUsage(next.agent, next.account))) ?? null) : null
+    const can = s.worktree ? canLand(s) : { ok: false, blockers: [{ code: 'no_worktree', message: 'this terminal works in the checkout itself: there is no branch of its own to land', fix: null }] }
     return {
       ...s,
       handoff_order: handoffOrder,
@@ -296,7 +298,8 @@ export function sessionsView({ viewer = null, share = null } = {}) {
       files: [...new Set([...(s.files_touched ?? []), ...(s.files_dirty ?? [])])].filter(visibleSessionFile),
       // a 'landing' left behind by a board restart is no longer in flight
       land: land?.state === 'landing' && !landingNow(s.session_id) ? { ...land, state: 'interrupted' } : land,
-      land_blocker: s.worktree ? landBlocker(s) : null,
+      can_land: can,
+      land_blocker: s.worktree ? (can.ok ? null : can.blockers[0]?.message) : null,
     }
   })
   const accounts = []
@@ -563,7 +566,7 @@ export function createBoardServer({ bind, port, token = process.env.LEG_TOKEN ||
         const you = { ...viewer, share: { on: shared, people: shared ? share.people.length : 0 } }
         if (guest) return send(res, 200, { ok: true, version: VERSION, you })
         const cards = listCards()
-        return send(res, 200, { ok: true, version: VERSION, bind, port, home: home(), you, scheduler: { ...schedulerStatus(), in_process: Boolean(sched), max_concurrent: MAX_CONCURRENT }, tools: await detectTools(), columns: columnsFor(cards), cards: cards.length })
+        return send(res, 200, { ok: true, pid: process.pid, version: VERSION, bind, port, home: home(), you, scheduler: { ...schedulerStatus(), in_process: Boolean(sched), max_concurrent: MAX_CONCURRENT }, tools: await detectTools(), columns: columnsFor(cards), cards: cards.length })
       }
       if (req.method === 'GET' && path === '/api/adapters') return send(res, 200, { adapters: await adaptersInfo() })
       if (req.method === 'GET' && path === '/api/presets') return send(res, 200, { presets: PRESETS })
@@ -687,9 +690,25 @@ export function createBoardServer({ bind, port, token = process.env.LEG_TOKEN ||
           }
         }
         if (req.method === 'POST' && parts[3] === 'land') {
+          if (parts[4] === 'prepare') {
+            const cl = canLand(sess)
+            if (!cl.ok) return send(res, 409, { ok: false, error: cl.blockers[0].message, blockers: cl.blockers })
+            const prep = await prepareLanding(sess, { by: actor.id })
+            return send(res, prep.ok ? 200 : 409, prep)
+          }
+          if (parts[4] === 'fix') {
+            const body = await readBody(req)
+            try {
+              const r = await applyLandFix(sess.session_id, body?.action, { by: actor.id, message: body?.message })
+              try { sse.broadcast('sessions', (v) => viewFor(v)) } catch {}
+              return send(res, 200, r)
+            } catch (err) {
+              return send(res, 400, { ok: false, error: err.message })
+            }
+          }
           const why = landBlocker(sess)
           if (why) return send(res, 409, { error: why })
-          landSession(sess, { by: actor.id })
+          landSession(sess, { by: actor.id, autoCommit: true })
             .catch((err) => log(`land ${id}: ${err.message}`))
             .finally(() => { trunkCache.clear(); try { sse.broadcast('sessions', (v) => viewFor(v)) } catch {} })
           log(`land requested for ${id} by ${actor.id}`)
@@ -797,10 +816,12 @@ export function createBoardServer({ bind, port, token = process.env.LEG_TOKEN ||
           // A terminal that crashed instead of exiting left its hand-off in
           // .baton/RESUME.md looking live. The board is the thing that starts
           // after a crash, so it is where that gets corrected.
-          try {
-            const touched = refreshPointers()
-            if (touched.length) log(`rewrote ${touched.length} stale resume pointer${touched.length === 1 ? '' : 's'}: the terminal each described is gone, or no Baton stamped it`)
-          } catch (err) { log(`resume pointers not refreshed: ${err.message}`) }
+          setImmediate(() => {
+            try {
+              const touched = refreshPointers()
+              if (touched.length) log(`rewrote ${touched.length} stale resume pointer${touched.length === 1 ? '' : 's'}: the terminal each described is gone, or no Baton stamped it`)
+            } catch (err) { log(`resume pointers not refreshed: ${err.message}`) }
+          })
           if (scheduler) {
             sched = createScheduler()
             sched.run().catch((err) => log(`scheduler crashed: ${err.message}`))

package/src/sessions.mjs

@@ -11,9 +11,10 @@ import { randomBytes } from 'node:crypto'
 import { home } from './store.mjs'
 import { writeJsonAtomic, withFileLock } from './fsx.mjs'
 import { scrub } from './redact.mjs'
-import { HANDOFF_AGENTS, normalizeHandoffOrder } from './preferences.mjs'
+import { HANDOFF_AGENTS, ALL_HANDOFF_AGENTS, normalizeHandoffOrder } from './preferences.mjs'
 
 export const AGENTS = HANDOFF_AGENTS
+export const SUPERVISED_AGENTS = ALL_HANDOFF_AGENTS
 export const HANDOFF_ORDER_CAPABILITY = 'handoff_order_v1'
 export const SESSION_STATUSES = ['starting', 'running', 'warning', 'limit', 'handing_off', 'waiting', 'handed_off', 'ended', 'lost']
 const ACTIVE = ['starting', 'running', 'warning', 'limit', 'handing_off', 'waiting']
@@ -160,7 +161,7 @@ export function readLandings() {
   return readFileSync(landingsFile(), 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l) } catch { return null } }).filter(Boolean)
 }
 
-function pidAlive(pid) {
+export function pidAlive(pid) {
   if (!pid) return false
   // EPERM means the process exists but is not ours to signal (e.g. an elevated
   // terminal): it is alive. Only ESRCH ("no such process") means gone.

package/src/taps/grok.mjs

@@ -0,0 +1,251 @@
+// grok tap - how Baton supervises the xAI grok CLI (xai-org/grok-build).
+// Usage percentages tap: Grok CLI exposes no usage command. Baton reads the
+// login token from ~/.grok/auth.json and polls:
+//   GET https://cli-chat-proxy.grok.com/v1/billing?format=credits
+//   GET https://cli-chat-proxy.grok.com/v1/user?include=subscription
+// Every 60s, same cadence as Claude Code tap.
+// Wall tap: exact signals cited from xai-org/grok-build (Apache 2.0, Rust):
+//   - crates/codegen/xai-grok-sampling-types/src/error.rs:304:
+//     SamplingError::Api { status: StatusCode::TOO_MANY_REQUESTS, .. }
+//   - crates/codegen/xai-grok-shell/src/sampling/error.rs:15, 18-33, 132:
+//     RATE_LIMITED_ERROR_CODE = -32003
+//     RATE_LIMITED_USER_MESSAGE_OAUTH ("You've hit the rate limit for your plan. Try again later.")
+//     RATE_LIMITED_USER_MESSAGE_API_KEY ("You've hit the rate limit for your API key. Try again later.")
+//     FREE_USAGE_USER_MESSAGE ("You've used all of your free queries. Upgrade to a paid plan for more access.")
+//     FREE_USAGE_EXHAUSTED_ERROR_CODE ("subscription:free-usage-exhausted")
+//   - crates/codegen/xai-grok-hooks/src/event.rs:306-315:
+//     StopFailureKind::RateLimit serializes to "rate_limit"
+//   - crates/codegen/xai-grok-shell/src/session/acp_session_impl/turn_end.rs:118, 125:
+//     maps -32003 to StopFailureKind::RateLimit ("rate_limit") on StopFailure
+//   - crates/codegen/xai-grok-pager/src/app/error_display.rs:263-267:
+//     HTTP 429 maps to headline "Rate limited (429)" and "You've hit the rate limit for your plan. Try again later."
+//   - crates/codegen/xai-grok-pager/src/headless.rs:84, 1512:
+//     headless mode emits {"type":"error","message": ...} on -32003
+// Native https and http, not fetch (test/lessons.test.mjs no-global-fetch).
+import https from 'node:https'
+import http from 'node:http'
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { LAYOUT } from '../accounts.mjs'
+
+export const GROK_BILLING_URL = (process.env.LEG_GROK_BILLING_URL || process.env.BATON_GROK_BILLING_URL) || 'https://cli-chat-proxy.grok.com/v1/billing?format=credits'
+export const GROK_USER_URL = (process.env.LEG_GROK_USER_URL || process.env.BATON_GROK_USER_URL) || 'https://cli-chat-proxy.grok.com/v1/user?include=subscription'
+
+export function defaultGrokHome() {
+  return process.env.GROK_HOME || LAYOUT.grok?.home() || join(homedir(), '.grok')
+}
+
+// Read login token from ~/.grok/auth.json. Re-read on each poll so refreshed tokens
+// take effect. Handles token expiry gracefully.
+export function readGrokToken(configDir = defaultGrokHome()) {
+  const f = join(configDir, 'auth.json')
+  if (!existsSync(f)) return null
+  try {
+    const raw = readFileSync(f, 'utf8')
+    const j = JSON.parse(raw)
+    let entry = null
+    if (typeof j === 'object' && j !== null) {
+      if (typeof j.key === 'string' && j.key) {
+        entry = j
+      } else if (typeof j.token === 'string' && j.token) {
+        entry = { key: j.token, expires_at: j.expires_at }
+      } else {
+        const scopeKey = Object.keys(j).find((k) => k.startsWith('https://auth.x.ai') && j[k]?.key)
+        if (scopeKey) {
+          entry = j[scopeKey]
+        } else {
+          for (const k of Object.keys(j)) {
+            if (j[k] && typeof j[k] === 'object' && typeof j[k].key === 'string' && j[k].key) {
+              entry = j[k]
+              break
+            }
+          }
+        }
+      }
+    }
+    if (!entry?.key) return null
+    let expired = false
+    if (entry.expires_at) {
+      const expMs = Date.parse(entry.expires_at)
+      if (Number.isFinite(expMs) && Date.now() > expMs) expired = true
+    }
+    return { token: entry.key, expired, expires_at: entry.expires_at ?? null }
+  } catch {
+    return null
+  }
+}
+
+function getJson(url, headers, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const u = new URL(url)
+    const mod = u.protocol === 'http:' ? http : https
+    const req = mod.request({
+      host: u.hostname,
+      port: u.port || (u.protocol === 'http:' ? 80 : 443),
+      path: u.pathname + u.search,
+      method: 'GET',
+      headers,
+      timeout: timeoutMs,
+    }, (res) => {
+      let d = ''
+      res.setEncoding('utf8')
+      res.on('data', (c) => { d += c })
+      res.on('end', () => resolvePromise({ status: res.statusCode, text: d }))
+    })
+    req.on('timeout', () => { req.destroy(new Error('usage endpoint timed out')) })
+    req.on('error', (err) => resolvePromise({ status: 0, text: '', error: err.message }))
+    req.end()
+  })
+}
+
+// → { ok, limits: { five_hour, seven_day }|null, status, tier, expired, error }
+export async function fetchGrokUsage({
+  configDir = defaultGrokHome(),
+  timeoutMs = 8000,
+  billingUrl = GROK_BILLING_URL,
+  userUrl = GROK_USER_URL,
+} = {}) {
+  const t = readGrokToken(configDir)
+  if (!t) return { ok: false, limits: null, error: `no grok login found in ${configDir}` }
+  if (t.expired) {
+    return { ok: false, limits: null, status: 401, expired: true, error: 'grok auth token is expired' }
+  }
+
+  const headers = {
+    Authorization: `Bearer ${t.token}`,
+    Accept: 'application/json',
+    'User-Agent': 'legcli',
+  }
+
+  const billingRes = await getJson(billingUrl, headers, timeoutMs)
+  if (billingRes.error) return { ok: false, limits: null, status: 0, error: billingRes.error }
+  if (billingRes.status === 401) {
+    return { ok: false, limits: null, status: 401, expired: true, error: 'grok authentication failed (401)' }
+  }
+  if (billingRes.status !== 200) {
+    return { ok: false, limits: null, status: billingRes.status, expired: false, error: `billing endpoint ${billingRes.status}: ${billingRes.text.slice(0, 120)}` }
+  }
+
+  let billingJson
+  try {
+    billingJson = JSON.parse(billingRes.text)
+  } catch {
+    return { ok: false, limits: null, status: billingRes.status, error: 'billing endpoint returned no JSON' }
+  }
+
+  const config = billingJson.config || billingJson
+  const pct = Number(config.creditUsagePercent ?? billingJson.creditUsagePercent)
+  if (!Number.isFinite(pct)) {
+    return { ok: false, limits: null, status: billingRes.status, error: 'no creditUsagePercent found in billing response' }
+  }
+
+  let resetsAt = null
+  const resetStr = config.currentPeriod?.end || config.billingPeriodEnd || billingJson.billingPeriodEnd || null
+  if (typeof resetStr === 'string') {
+    const tMs = Date.parse(resetStr)
+    if (Number.isFinite(tMs)) resetsAt = Math.floor(tMs / 1000)
+  }
+
+  const periodType = String(config.currentPeriod?.type || '')
+  const isShort = periodType.includes('HOUR') || periodType.includes('DAILY')
+  const windowObj = { pct, resets_at: resetsAt }
+  const limits = {
+    five_hour: isShort ? windowObj : null,
+    seven_day: !isShort ? windowObj : null,
+  }
+
+  let tier = null
+  try {
+    const userRes = await getJson(userUrl, headers, timeoutMs)
+    if (userRes.status === 200) {
+      const userJson = JSON.parse(userRes.text)
+      tier = userJson.subscriptionTier || userJson.subscription?.tier || null
+    }
+  } catch {}
+
+  return {
+    ok: true,
+    limits,
+    status: billingRes.status,
+    tier,
+    expired: false,
+    raw_keys: Object.keys(billingJson),
+  }
+}
+
+// Exact signals cited from xai-org/grok-build source code:
+const LIMIT_RES = [
+  ['grok-rate-limit-oauth', /You've hit the rate limit for your plan/i],
+  ['grok-rate-limit-api-key', /You've hit the rate limit for your API key/i],
+  ['grok-rate-limit-429', /Rate limited \(429\)/i],
+  ['grok-rate-limit-code', /-32003/],
+  ['grok-rate-limit-event', /"rate_limit"/i],
+  ['grok-free-usage-exhausted', /subscription:free-usage-exhausted|You've used all of your free queries/i],
+  ['grok-too-many-requests', /TOO_MANY_REQUESTS/],
+]
+
+// Scans log or stream text for Grok rate limit signals.
+// → { signal, detail, resets_at } | null
+export function scanLog(text) {
+  if (!text) return null
+  const s = String(text)
+  for (const [id, re] of LIMIT_RES) {
+    const m = re.exec(s)
+    if (!m) continue
+    const at = s.lastIndexOf(m[0])
+    const detail = s.slice(Math.max(0, at - 80), at + 160).replace(/\s+/g, ' ').trim()
+    let resets_at = null
+    const dm = /(?:try again in|resets in)\s+((?:\d+\s*[smhd])+)/i.exec(s.slice(at))
+    if (dm) {
+      let secs = 0
+      for (const [, n, u] of dm[1].matchAll(/(\d+)\s*([smhd])/gi)) {
+        secs += parseInt(n, 10) * { s: 1, m: 60, h: 3600, d: 86400 }[u.toLowerCase()]
+      }
+      if (secs) resets_at = Math.floor(Date.now() / 1000) + secs
+    }
+    return { signal: id, detail, resets_at }
+  }
+  return null
+}
+
+export function logSize(path) {
+  try { return statSync(path).size } catch { return 0 }
+}
+
+export function sessionsRootFor(grokHome = defaultGrokHome()) {
+  return join(grokHome, 'sessions')
+}
+
+// Prompts typed into grok in `cwd` since `sinceMs`.
+// Grok stores sessions under ~/.grok/sessions/<encoded-cwd>/<session-id>/
+// with prompt_history.jsonl in the cwd dir and summary.json in each session dir.
+export function promptsSince({ grokHome = defaultGrokHome(), cwd, sinceMs }) {
+  const root = sessionsRootFor(grokHome)
+  if (!existsSync(root)) return []
+  const encoded = encodeURIComponent(cwd)
+  const dir = join(root, encoded)
+  if (!existsSync(dir)) return []
+
+  const histFile = join(dir, 'prompt_history.jsonl')
+  const out = []
+  if (existsSync(histFile)) {
+    try {
+      const lines = readFileSync(histFile, 'utf8').split('\n').filter(Boolean)
+      for (const line of lines) {
+        try {
+          const j = JSON.parse(line)
+          const tsMs = Date.parse(j.timestamp)
+          if (Number.isFinite(tsMs) && tsMs >= sinceMs - 2000) {
+            out.push({
+              text: String(j.prompt ?? ''),
+              ts: tsMs,
+              sessionId: j.session_id ?? null,
+            })
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+  return out
+}