mixdog 0.7.1

package/src/daemon/host.mjs

@@ -0,0 +1,118 @@
+/**
+ * Daemon host — one shared backend process per plugin data dir.
+ *
+ * `ensureDaemon(dataDir)` is the thin-client entry: connect to a running
+ * daemon, or spawn one (serialized so N cold-start terminals don't storm) and
+ * connect. `runDaemon(dataDir)` is the daemon process entry: it claims the
+ * owner lock (singleton invariant — a loser exits), listens on the shared pipe,
+ * and serves every connected client.
+ *
+ * The daemon process delegates per-session request routing to
+ * `serveDaemon` in server-main.mjs, so each connection is a real
+ * Claude Code session.
+ *
+ * Ownership is the owner lock + pipe ownership, both liveness-based (ESRCH ⇒
+ * dead). No time-boxed "run anyway" escape: a loser attaches or exits.
+ */
+import { spawn } from 'child_process'
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import { fileURLToPath } from 'url'
+import { connect } from './transport.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+// The daemon BODY lives in server-main (reached via `server.mjs --daemon`); the
+// host only spawns it and connects clients. server.mjs is two levels up from
+// src/daemon/. Pipe ownership (transport.listen → null) is the singleton arbiter.
+const SERVER_ENTRY = path.join(path.dirname(__filename), '..', '..', 'server.mjs')
+const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT || path.join(os.tmpdir(), 'mixdog')
+
+function pidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false
+  try { process.kill(pid, 0); return true }
+  catch (e) { return e.code !== 'ESRCH' } // ESRCH ⇒ dead; EPERM/other ⇒ alive
+}
+
+function lockDir(dataDir) {
+  const dir = dataDir && dataDir.length ? dataDir : RUNTIME_ROOT
+  try { fs.mkdirSync(dir, { recursive: true }) } catch {}
+  return dir
+}
+const spawnLockPath = (dataDir) => path.join(lockDir(dataDir), '.daemon-spawn.lock')
+
+// Atomic create-or-fail lock holding our pid. Reclaims a lock whose holder pid
+// is dead. Returns true if we now hold it.
+function tryAcquireLock(file) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      fs.writeFileSync(file, String(process.pid), { flag: 'wx' })
+      return true
+    } catch (e) {
+      if (e.code !== 'EEXIST') return false
+      let holder = 0
+      try { holder = Number(fs.readFileSync(file, 'utf8')) } catch {}
+      if (holder === process.pid) return true
+      if (pidAlive(holder)) return false
+      try { fs.unlinkSync(file) } catch {} // stale holder dead — reclaim and retry
+    }
+  }
+  return false
+}
+function releaseLock(file) {
+  try {
+    if (Number(fs.readFileSync(file, 'utf8')) === process.pid) fs.unlinkSync(file)
+  } catch {}
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+// Poll-connect until a daemon is listening or the budget expires.
+async function waitForDaemon(dataDir, budgetMs) {
+  const deadline = Date.now() + budgetMs
+  for (;;) {
+    try { return await connect(dataDir, { timeoutMs: 1000 }) } catch {}
+    if (Date.now() >= deadline) throw new Error('daemon did not come up within budget')
+    await sleep(150)
+  }
+}
+
+function spawnDaemonProcess(dataDir) {
+  const child = spawn(process.env.BUN_EXEC_PATH || process.execPath, [SERVER_ENTRY, '--daemon', dataDir], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, MIXDOG_DAEMON_MODE: '1', MIXDOG_DAEMON_DATA_DIR: dataDir },
+    ...(process.platform === 'win32' ? { windowsHide: true } : {}),
+  })
+  child.unref()
+  return child
+}
+
+// Thin-client entry: return a framed connection to the shared daemon, spawning
+// it if needed. Spawning is serialized via the spawn lock so N co-booting
+// terminals produce one daemon; the owner lock inside runDaemon is the final
+// singleton arbiter if two ever race through.
+export async function ensureDaemon(dataDir) {
+  const deadline = Date.now() + 30000 // final safety bound, not the recovery path
+  for (;;) {
+    // 1) Already running?
+    try { return await connect(dataDir, { timeoutMs: 1200 }) } catch {}
+    // 2) Become the spawner. tryAcquireLock reclaims a DEAD holder, so a
+    //    spawner that died before its daemon listened is recovered here on the
+    //    next pass — liveness-based, not a fixed wait that wedges all waiters.
+    const spawnLock = spawnLockPath(dataDir)
+    if (tryAcquireLock(spawnLock)) {
+      try {
+        spawnDaemonProcess(dataDir)
+        return await waitForDaemon(dataDir, 30000)
+      } finally {
+        releaseLock(spawnLock)
+      }
+    }
+    // 3) A live client is spawning — briefly wait for its pipe, then loop back
+    //    to retry both (1) connect and (2) dead-holder reclaim.
+    try { return await connect(dataDir, { timeoutMs: 800 }) } catch {}
+    if (Date.now() >= deadline) throw new Error('daemon did not come up within budget')
+    await sleep(150)
+  }
+}

package/src/daemon/mcp-transport.mjs

@@ -0,0 +1,47 @@
+/**
+ * MCP Transport adapter over a daemon framed connection.
+ *
+ * Lets the daemon hand each accepted client connection to its own MCP SDK
+ * `Server` instance, so the SDK does protocol-correct initialize / capabilities
+ * / tools negotiation per connection while we only supply the wire. The SDK
+ * `Transport` contract is minimal: start / send / close + onmessage / onclose /
+ * onerror. Our framed connection already speaks NDJSON JSON-RPC objects, so the
+ * adapter is a thin pass-through.
+ */
+export class FramedServerTransport {
+  constructor(conn, opts = {}) {
+    this._conn = conn
+    // Out-of-band control-frame sink (session-identity handshake). Control
+    // frames carry a `__mixdog` marker, no jsonrpc, and must NOT reach the SDK.
+    this._onControl = typeof opts.onControl === 'function' ? opts.onControl : null
+    this._started = false
+    // SDK assigns these before/after start(); call them if present.
+    this.onmessage = undefined
+    this.onclose = undefined
+    this.onerror = undefined
+  }
+
+  async start() {
+    if (this._started) return
+    this._started = true
+    this._conn.onMessage((msg) => {
+      if (msg && msg.__mixdog) {
+        try { this._onControl?.(msg) } catch (e) { this.onerror?.(e) }
+        return
+      }
+      try { this.onmessage?.(msg) }
+      catch (e) { this.onerror?.(e) }
+    })
+    this._conn.onClose(() => {
+      try { this.onclose?.() } catch {}
+    })
+  }
+
+  async send(message) {
+    this._conn.send(message)
+  }
+
+  async close() {
+    this._conn.close()
+  }
+}

package/src/daemon/session.mjs

@@ -0,0 +1,100 @@
+/**
+ * Per-connection Session — the unit of isolation in the shared daemon.
+ *
+ * Today `server-main` is one process per Claude Code terminal, so session
+ * identity (sessionId, cwd, transcript, instanceId, lead pid) lives in process
+ * globals / env (`SESSION_ID`, `MIXDOG_SESSION_CWD`, …). In the daemon, one
+ * process serves N terminals, so that state must move OFF process globals and
+ * onto a Session keyed by the client connection. `cwd` is the highest-risk
+ * field: it is mutable (the `cwd` tool changes it) and must never leak from one
+ * client to another — the old `MIXDOG_SESSION_CWD` env is replaced by
+ * `session.cwd`, threaded per call into `dispatchTool` and worker payloads.
+ *
+ * Identity-only and install/process-scoped state (shared DB, plugin config,
+ * the single memory/channels services) deliberately stays OUT of Session.
+ */
+
+import { _safeProcessCwd } from '../shared/user-cwd.mjs'
+
+// Fields a thin client sends in its `initialize` handshake. Everything is
+// optional so a minimal client still gets a usable session.
+//   { sessionId, cwd, transcriptPath, leadPid, instanceId, env }
+export class Session {
+  constructor(conn, init = {}) {
+    this.conn = conn
+    this.sessionId = init.sessionId || null
+    // Mutable per-session working dir. Resolution order at call time:
+    //   session.cwd ?? init default ?? process.cwd(). NEVER read a global env.
+    this.cwd = init.cwd || null
+    // Optional live cwd resolver. The boot session (single stdio client) sets
+    // this to pwd() so it keeps tracking the legacy MIXDOG_SESSION_CWD env and
+    // stays behaviour-identical; daemon sessions leave it null and own a static
+    // per-connection `cwd` instead.
+    this.cwdFn = typeof init.cwdFn === 'function' ? init.cwdFn : null
+    // Optional write-side hook for cwd. The boot session points this at the
+    // legacy MIXDOG_SESSION_CWD env (which cwdFn=pwd reads back); daemon
+    // sessions leave it null and `setCwd` mutates this.cwd directly.
+    this.setCwdFn = typeof init.setCwdFn === 'function' ? init.setCwdFn : null
+    this.transcriptPath = init.transcriptPath || null
+    this.leadPid = Number.isFinite(init.leadPid) ? init.leadPid : null
+    this.clientHostPid = Number.isFinite(init.clientHostPid) ? init.clientHostPid : null
+    // Per-session runtime seat (was server.mjs `instanceId` = process.pid).
+    this.instanceId = init.instanceId || init.sessionId || null
+    // Opaque per-session scratch for state that is process-global today and
+    // gets migrated incrementally (lead guard, recent-bash tracker, recap
+    // status). Keyed by feature name so each wiring step claims its own slot
+    // without widening this constructor.
+    this.scratch = new Map()
+    this.createdAt = init.now ?? null // stamped by caller; daemon avoids Date.now at construct
+  }
+
+  // The cwd a tool call should resolve against. Falls back to the process cwd
+  // only when the session never advertised one (never another session's cwd).
+  resolveCwd() {
+    // Fallback uses _safeProcessCwd(), NOT captureOriginalUserCwd(): a daemon
+    // serves N terminals, so the fallback must consult NO per-session signal
+    // (MIXDOG_SESSION_CWD / user-cwd.txt) — that would leak one terminal's cwd
+    // into another. _safeProcessCwd() reads only the install-scoped
+    // CLAUDE_PLUGIN_ROOT to guard the daemon-launch-dir == plugin-cache case
+    // down to homedir(), surfacing a missing cwd as ENOENT (absolute paths
+    // required) instead of a silent stale read under the plugin cache.
+    return (this.cwdFn ? this.cwdFn() : this.cwd) || _safeProcessCwd()
+  }
+
+  // Per-session cwd write (the `cwd set` tool). The boot session routes to its
+  // legacy env via setCwdFn so cwdFn=pwd keeps reading it; daemon sessions
+  // store it on the session so one terminal's cwd never leaks into another.
+  setCwd(value) {
+    if (this.setCwdFn) this.setCwdFn(value)
+    else this.cwd = value
+  }
+}
+
+/**
+ * Registry of live sessions keyed by connection. One Session per connection;
+ * a reconnecting client (daemon restart) re-initializes and gets a fresh
+ * Session carrying the same sessionId (resume semantics land with M4 reconnect).
+ */
+export class SessionRegistry {
+  constructor() {
+    this._byConn = new Map()
+  }
+
+  open(conn, init) {
+    const session = new Session(conn, init)
+    this._byConn.set(conn, session)
+    return session
+  }
+
+  get(conn) {
+    return this._byConn.get(conn) || null
+  }
+
+  close(conn) {
+    this._byConn.delete(conn)
+  }
+
+  get size() {
+    return this._byConn.size
+  }
+}

package/src/daemon/thin-client.mjs

@@ -0,0 +1,71 @@
+/**
+ * Thin client — bridges one Claude Code terminal's stdio to the shared daemon.
+ *
+ * Every per-terminal `server.mjs` invocation (spawned by run-mcp) runs this
+ * instead of the heavy in-process backend. It connects to the shared daemon
+ * (spawning it if needed) and pipes NDJSON JSON-RPC both ways: run-mcp/CC stdin
+ * → daemon, daemon → stdout. When the daemon connection drops, the thin client
+ * exits; run-mcp then respawns this server.mjs (which re-attaches or re-spawns
+ * the daemon), reusing run-mcp's existing initialize cache/replay.
+ *
+ * Session identity is advertised out-of-band via a `__mixdog` control frame
+ * that the daemon transport filters BEFORE the MCP SDK sees it, so it has no
+ * ordering dependency on the MCP initialize handshake.
+ */
+import { ensureDaemon } from './host.mjs'
+import { explicitSessionCwd, readLastSessionCwd } from '../shared/user-cwd.mjs'
+
+export async function runThinClient(dataDir) {
+  const conn = await ensureDaemon(dataDir)
+
+  // daemon → CC (stdout)
+  conn.onMessage((msg) => {
+    try { process.stdout.write(JSON.stringify(msg) + '\n') } catch {}
+  })
+  // daemon gone → exit so run-mcp respawns us and we re-attach/re-spawn it
+  conn.onClose(() => process.exit(0))
+
+  // Advertise this terminal's identity (filtered out-of-band on the daemon).
+  try {
+    const rawLeadPid = Number(process.env.MIXDOG_SUPERVISOR_PID)
+    const leadPid = Number.isFinite(rawLeadPid) && rawLeadPid > 0 ? rawLeadPid : undefined
+    const hasEnvSessionCwd = typeof process.env.MIXDOG_SESSION_CWD === 'string' && process.env.MIXDOG_SESSION_CWD.length > 0
+    const advertisedCwd = hasEnvSessionCwd
+      ? (explicitSessionCwd() || readLastSessionCwd(leadPid) || undefined)
+      : (readLastSessionCwd(leadPid) || explicitSessionCwd() || undefined)
+    conn.send({
+      __mixdog: 'session',
+      sessionId: process.env.MIXDOG_SESSION_ID || undefined,
+      // Advertise an explicit session cwd so the daemon Session never falls
+      // back to its own process.cwd() (the plugin CACHE dir), which would make
+      // every bridge worker resolve paths under ...\plugins\cache\...\<ver>.
+      // explicitSessionCwd() = MIXDOG_SESSION_CWD (if it exists) ?? user-cwd.txt
+      // (rewritten every session start); it NEVER returns process.cwd().
+      cwd: advertisedCwd,
+      leadPid,
+      transcriptPath: process.env.MIXDOG_TRANSCRIPT_PATH || undefined,
+      clientHostPid: Number(process.env.MIXDOG_OWNER_HOST_PID) || undefined,
+    })
+  } catch {}
+
+  // CC/run-mcp (stdin, NDJSON) → daemon
+  let buf = ''
+  process.stdin.setEncoding('utf8')
+  process.stdin.on('data', (chunk) => {
+    buf += chunk
+    let nl
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl)
+      buf = buf.slice(nl + 1)
+      if (!line) continue
+      let obj
+      try { obj = JSON.parse(line) } catch { continue }
+      conn.send(obj)
+    }
+  })
+  process.stdin.on('end', () => process.exit(0))
+  process.stdin.on('close', () => process.exit(0))
+
+  // Keep the process alive; the pipes drive everything.
+  await new Promise(() => {})
+}

package/src/daemon/transport.mjs

@@ -0,0 +1,163 @@
+/**
+ * Daemon transport — NDJSON JSON-RPC over a per-data-dir named pipe.
+ *
+ * Replaces the per-terminal `run-mcp ↔ server.mjs` stdio link with a single
+ * shared endpoint: one daemon process listens; N thin clients (one per Claude
+ * Code terminal) connect. This module is PURE transport — framing, accept,
+ * connect, liveness. It carries no session or JSON-RPC semantics; the daemon
+ * host layers those on top via the `onConnection` callback.
+ *
+ * Pipe ownership is the singleton primitive: on Windows a second `listen()`
+ * fails with EADDRINUSE, on Unix we probe-then-unlink. `listen()` returning
+ * null means "a live daemon already owns this pipe — attach as a client".
+ */
+import net from 'net'
+import { createHash } from 'crypto'
+import { unlinkSync, mkdirSync } from 'fs'
+import path from 'path'
+import os from 'os'
+
+// Inbound frame guardrail (mirrors run-mcp's MAX_LINE_BYTES). A JSON-RPC line
+// is newline-terminated; an unterminated line growing past this cap signals a
+// runaway producer. 4 MB comfortably fits any legitimate tool result.
+const MAX_LINE_BYTES = 4 * 1024 * 1024
+
+const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT || path.join(os.tmpdir(), 'mixdog')
+
+// One pipe per plugin data dir so distinct installs / data dirs never collide.
+function daemonPipePath(dataDir) {
+  const hash = createHash('sha1').update(String(dataDir || 'default')).digest('hex').slice(0, 12)
+  if (process.platform === 'win32') return `\\\\.\\pipe\\mixdog-daemon-${hash}`
+  return path.join(RUNTIME_ROOT, `mixdog-daemon-${hash}.sock`)
+}
+
+// Wrap a net.Socket in NDJSON framing. `send(obj)` writes one JSON line;
+// `onMessage(cb)` fires per parsed object; `onClose(cb)` fires once on
+// socket end/error. Non-JSON lines are dropped (never throw on the socket).
+function frameConnection(socket) {
+  let buf = ''
+  let closed = false
+  const msgHandlers = []
+  const closeHandlers = []
+  socket.setEncoding('utf8')
+  socket.on('data', (chunk) => {
+    buf += chunk
+    let nl
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl)
+      buf = buf.slice(nl + 1)
+      if (!line) continue
+      let obj
+      try { obj = JSON.parse(line) } catch { continue }
+      for (const h of msgHandlers) { try { h(obj) } catch (e) { try { process.stderr.write(`[transport] message handler failed: ${e?.message ?? e}\n`) } catch {} } }
+    }
+    if (buf.length > MAX_LINE_BYTES) {
+      // Runaway unterminated frame — drop the connection rather than grow
+      // unbounded. A well-behaved peer never produces a 4 MB line without a \n.
+      try { socket.destroy() } catch {}
+    }
+  })
+  const fireClose = () => {
+    if (closed) return
+    closed = true
+    for (const h of closeHandlers) { try { h() } catch {} }
+  }
+  socket.on('close', fireClose)
+  socket.on('error', fireClose)
+  return {
+    socket,
+    send(obj) {
+      if (closed) return false
+      try { return socket.write(JSON.stringify(obj) + '\n') } catch { return false }
+    },
+    onMessage(cb) { msgHandlers.push(cb) },
+    onClose(cb) { closeHandlers.push(cb) },
+    close() { try { socket.end() } catch {} },
+    get closed() { return closed },
+  }
+}
+
+// Start the daemon endpoint. Resolves the net.Server on success, or `null`
+// when another live daemon already owns the pipe (this process must attach as
+// a client instead). `onConnection(conn)` is invoked with a framed connection
+// per accepted client.
+export async function listen({ dataDir, onConnection }) {
+  const pipePath = daemonPipePath(dataDir)
+  if (process.platform !== 'win32') {
+    // Unix domain sockets need the parent dir to exist; RUNTIME_ROOT may not.
+    try { mkdirSync(path.dirname(pipePath), { recursive: true }) } catch {}
+  }
+  // Fresh server per attempt: a net.Server that emitted 'error' cannot be
+  // re-listened reliably, so the Unix retry below recreates it each time.
+  const attempt = () => new Promise((resolve, reject) => {
+    const server = net.createServer((socket) => {
+      try { onConnection(frameConnection(socket)) } catch {}
+    })
+    const onErr = (e) => { server.removeListener('listening', onOk); reject(e) }
+    const onOk = () => { server.removeListener('error', onErr); resolve(server) }
+    server.once('error', onErr)
+    server.once('listening', onOk)
+    server.listen(pipePath)
+  })
+  if (process.platform === 'win32') {
+    // Windows named pipes reject a second listener with EADDRINUSE on their own,
+    // so no pre-listen probe is needed.
+    try { return await attempt() }
+    catch (e) { if (isAddrInUse(e)) return null; throw e }
+  }
+  // Unix: a leftover socket file from a crashed daemon makes bind fail with
+  // EADDRINUSE. Only unlink when a probe says nothing answers — and re-probe
+  // after every failed bind, so if a sibling rebinds in the probe→unlink
+  // window we see it alive on the next pass and attach instead of stealing it.
+  // (runDaemon calls this under the owner lock, which already serializes
+  // dataDir entry; this loop closes the residual TOCTOU window.)
+  for (let i = 0; i < 3; i++) {
+    try { return await attempt() }
+    catch (e) {
+      if (!isAddrInUse(e)) throw e
+      if (await probeAlive(pipePath)) return null
+      try { unlinkSync(pipePath) } catch {}
+    }
+  }
+  return null
+}
+
+// Connect to an existing daemon. Resolves a framed connection or rejects
+// (ENOENT / ECONNREFUSED when no daemon is listening, or on timeout).
+export function connect(dataDir, { timeoutMs = 2000 } = {}) {
+  const pipePath = daemonPipePath(dataDir)
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(pipePath)
+    const timer = setTimeout(() => {
+      try { socket.destroy() } catch {}
+      reject(new Error('daemon connect timeout'))
+    }, timeoutMs)
+    socket.once('connect', () => { clearTimeout(timer); resolve(frameConnection(socket)) })
+    socket.once('error', (e) => { clearTimeout(timer); reject(e) })
+  })
+}
+
+function isAddrInUse(e) {
+  const msg = String(e?.message || e || '')
+  return e?.code === 'EADDRINUSE' || msg.includes('EADDRINUSE') || msg.includes('Failed to listen')
+}
+
+// Resolves true if something is listening on the pipe (daemon alive), false on
+// ECONNREFUSED / ENOENT (dead/absent). Other errors / timeout resolve true so
+// we err on NOT stealing a possibly-live peer's socket.
+function probeAlive(pipePath) {
+  return new Promise((resolve) => {
+    let done = false
+    const finish = (alive) => {
+      if (done) return
+      done = true
+      try { c.destroy() } catch {}
+      clearTimeout(t)
+      resolve(alive)
+    }
+    const c = net.connect(pipePath)
+    const t = setTimeout(() => finish(true), 500)
+    c.once('connect', () => finish(true))
+    c.once('error', (e) => finish(!(e?.code === 'ECONNREFUSED' || e?.code === 'ENOENT')))
+  })
+}

package/src/memory/data/runtime-manifest.json

@@ -0,0 +1,40 @@
+{
+  "schema_version": 1,
+  "generated_at": "2026-06-11T13:16:44.033Z",
+  "release_tag": "runtime-v0.4.0",
+  "pg": {
+    "major": 16,
+    "minor": 4
+  },
+  "pgvector": {
+    "version": "0.8.2"
+  },
+  "assets": {
+    "darwin-arm64": {
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-darwin-arm64-pg16.4-pgvector0.8.2.tar.gz",
+      "sha256": "7a642006ef60ccf8c385ba89c761c2b6f4927f6f01a1c4fb152604e6b41fe3d2",
+      "size": 23397361
+    },
+    "darwin-x64": {
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-darwin-x64-pg16.4-pgvector0.8.2.tar.gz",
+      "sha256": "8e39bfc3f06d88e9854946d5d83f7d77d9530f99284d7c1c51872c12f389f7e7",
+      "size": 23687666
+    },
+    "linux-x64": {
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-linux-x64-pg16.4-pgvector0.8.2.tar.gz",
+      "sha256": "28ee64125a0125ff36c47560c08ce8f38e49aef034c010c7e4867e8cdd783385",
+      "size": 23276106
+    },
+    "win32-x64": {
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-win32-x64-pg16.4-pgvector0.8.2.tar.gz",
+      "sha256": "6faed8a49b3303b0adb1c5715b2b19c5cc47df2e738d586d0d0bd432f1ca035d",
+      "size": 44036958
+    },
+    "linux-arm64": {
+      "unsupported": true,
+      "url": "TBD",
+      "sha256": "TBD",
+      "size": 0
+    }
+  }
+}