failproofai 1.0.4-beta.6 → 1.0.4-beta.8

package/.next/standalone/lib/openclaw-db.ts

@@ -0,0 +1,271 @@
+/**
+ * Read OpenClaw 2026.9.2+ transcripts from the per-agent SQLite databases at
+ * `agents/<agentId>/agent/openclaw-agent.sqlite`.
+ *
+ * `event_json` is the exact logical JSONL record, so the dashboard can feed it
+ * through the same parser and download format used by archived JSONL files.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { openSqliteReadonly, type SqliteReader } from "./sqlite-reader";
+
+const DB_NAME = "openclaw-agent.sqlite";
+
+export interface OpenClawSqliteSession {
+  sessionId: string;
+  agentId: string;
+  dbPath: string;
+  transcriptPath: string;
+  mtimeMs: number;
+  sizeBytes: number;
+  channel: string;
+  label?: string;
+  chatId?: string;
+  chatType?: string;
+}
+
+export interface OpenClawSqliteTranscript {
+  agentId: string;
+  dbPath: string;
+  filePath: string;
+  rawLines: Record<string, unknown>[];
+  eventJsonLines: string[];
+}
+
+interface WindowRow {
+  session_id: string;
+  session_key: string;
+  updated_at: number;
+  transcript_updated_at: number | null;
+  ended_at: number | null;
+  channel: string | null;
+  chat_type: string | null;
+  display_name: string | null;
+  event_updated_at: number;
+  size_bytes: number;
+}
+
+interface NodeRow {
+  current_session_id: string;
+  entry_json: string;
+  label: string | null;
+  display_name: string | null;
+}
+
+interface ConversationRow {
+  session_id: string;
+  channel: string;
+  kind: string;
+  peer_id: string;
+  delivery_target: string;
+  label: string | null;
+}
+
+interface EventRow {
+  event_json: string;
+}
+
+interface SessionMeta {
+  channel?: string;
+  label?: string;
+  chatId?: string;
+  chatType?: string;
+}
+
+function str(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function parseObject(value: string): Record<string, unknown> | undefined {
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function syntheticPath(agentId: string, sessionId: string): string {
+  return `openclaw-sqlite://${encodeURIComponent(agentId)}/${sessionId}`;
+}
+
+/** Existing per-agent SQLite databases, derived from the configured agents. */
+export function listOpenClawDatabases(
+  home: string,
+  agentIds: string[],
+): Array<{ agentId: string; dbPath: string }> {
+  const out: Array<{ agentId: string; dbPath: string }> = [];
+  for (const agentId of agentIds) {
+    const dbPath = join(home, "agents", agentId, "agent", DB_NAME);
+    if (existsSync(dbPath)) out.push({ agentId, dbPath });
+  }
+  return out;
+}
+
+function readNodeMetadata(db: SqliteReader): Map<string, SessionMeta> {
+  const out = new Map<string, SessionMeta>();
+  let rows: NodeRow[];
+  try {
+    rows = db.query<NodeRow>(
+      `SELECT current_session_id, entry_json, label, display_name
+         FROM session_nodes`,
+    );
+  } catch {
+    return out;
+  }
+  for (const row of rows) {
+    const entry = parseObject(row.entry_json) ?? {};
+    const origin =
+      entry.origin &&
+      typeof entry.origin === "object" &&
+      !Array.isArray(entry.origin)
+        ? (entry.origin as Record<string, unknown>)
+        : {};
+    out.set(row.current_session_id, {
+      channel:
+        str(entry.lastChannel) ?? str(origin.provider) ?? str(origin.surface),
+      label:
+        str(row.label) ??
+        str(row.display_name) ??
+        str(entry.displayName) ??
+        str(origin.label),
+      chatId: str(entry.lastTo) ?? str(origin.from),
+      chatType: str(entry.chatType) ?? str(origin.chatType),
+    });
+  }
+  return out;
+}
+
+function readConversationMetadata(db: SqliteReader): Map<string, SessionMeta> {
+  const out = new Map<string, SessionMeta>();
+  let rows: ConversationRow[];
+  try {
+    rows = db.query<ConversationRow>(
+      `SELECT sc.session_id, c.channel, c.kind, c.peer_id,
+              c.delivery_target, c.label
+         FROM session_conversations sc
+         JOIN conversations c ON c.conversation_id = sc.conversation_id
+        ORDER BY CASE sc.role WHEN 'primary' THEN 0 ELSE 1 END, sc.last_seen_at DESC`,
+    );
+  } catch {
+    return out;
+  }
+  for (const row of rows) {
+    if (out.has(row.session_id)) continue;
+    out.set(row.session_id, {
+      channel: str(row.channel),
+      label: str(row.label),
+      chatId: str(row.delivery_target) ?? str(row.peer_id),
+      chatType: str(row.kind),
+    });
+  }
+  return out;
+}
+
+/** List every transcript-bearing session in all per-agent databases. */
+export async function listOpenClawSqliteSessions(
+  home: string,
+  agentIds: string[],
+): Promise<OpenClawSqliteSession[]> {
+  const sessions: OpenClawSqliteSession[] = [];
+  for (const { agentId, dbPath } of listOpenClawDatabases(home, agentIds)) {
+    const db = await openSqliteReadonly(dbPath);
+    if (!db) continue;
+    try {
+      let rows: WindowRow[];
+      try {
+        rows = db.query<WindowRow>(
+          `SELECT w.session_id, w.session_key, w.updated_at,
+                  w.transcript_updated_at, w.ended_at, w.channel,
+                  w.chat_type, w.display_name,
+                  COALESCE((SELECT MAX(e.created_at)
+                              FROM transcript_events e
+                             WHERE e.session_id = w.session_id), 0) AS event_updated_at,
+                  COALESCE((SELECT SUM(length(e.event_json) + 1)
+                              FROM transcript_events e
+                             WHERE e.session_id = w.session_id), 0) AS size_bytes
+             FROM session_windows w
+            WHERE EXISTS (SELECT 1 FROM transcript_events e
+                           WHERE e.session_id = w.session_id)`,
+        );
+      } catch {
+        continue;
+      }
+
+      const nodes = readNodeMetadata(db);
+      const conversations = readConversationMetadata(db);
+      for (const row of rows) {
+        const node = nodes.get(row.session_id);
+        const conversation = conversations.get(row.session_id);
+        sessions.push({
+          sessionId: row.session_id,
+          agentId,
+          dbPath,
+          transcriptPath: syntheticPath(agentId, row.session_id),
+          mtimeMs: Math.max(
+            Number(row.updated_at) || 0,
+            Number(row.transcript_updated_at) || 0,
+            Number(row.ended_at) || 0,
+            Number(row.event_updated_at) || 0,
+          ),
+          sizeBytes: Number(row.size_bytes) || 0,
+          channel:
+            str(row.channel) ??
+            conversation?.channel ??
+            node?.channel ??
+            "local",
+          label: str(row.display_name) ?? conversation?.label ?? node?.label,
+          chatId: conversation?.chatId ?? node?.chatId,
+          chatType:
+            str(row.chat_type) ?? conversation?.chatType ?? node?.chatType,
+        });
+      }
+    } finally {
+      db.close();
+    }
+  }
+  return sessions;
+}
+
+/** Read one SQLite transcript by UUID. The first matching agent wins. */
+export async function readOpenClawSqliteTranscript(
+  home: string,
+  agentIds: string[],
+  sessionId: string,
+): Promise<OpenClawSqliteTranscript | null> {
+  for (const { agentId, dbPath } of listOpenClawDatabases(home, agentIds)) {
+    const db = await openSqliteReadonly(dbPath);
+    if (!db) continue;
+    try {
+      let rows: EventRow[];
+      try {
+        rows = db.query<EventRow>(
+          `SELECT event_json
+             FROM transcript_events
+            WHERE session_id = ?
+            ORDER BY seq ASC`,
+          [sessionId],
+        );
+      } catch {
+        continue;
+      }
+      if (rows.length === 0) continue;
+      const eventJsonLines = rows.map((row) => row.event_json);
+      const rawLines = eventJsonLines
+        .map(parseObject)
+        .filter((line): line is Record<string, unknown> => line !== undefined);
+      return {
+        agentId,
+        dbPath,
+        filePath: syntheticPath(agentId, sessionId),
+        rawLines,
+        eventJsonLines,
+      };
+    } finally {
+      db.close();
+    }
+  }
+  return null;
+}

package/.next/standalone/lib/openclaw-projects.ts

@@ -1,18 +1,21 @@
 /**
  * OpenClaw (openclaw gateway) session enumeration — AUDIT-ONLY.
  *
- * Surfaces the on-disk transcripts (agents/<agentId>/sessions/<uuid>.jsonl) as
- * synthetic dashboard "projects" grouped by (agentId, channel). The per-agent
- * `sessions.json` index maps sessionKey → {sessionId, timestamps}; we read it to
- * recover the sessionKey (which encodes the channel for gateway sessions) and a
- * reliable last-activity time. Verified live against openclaw v2026.7.1.
+ * Surfaces both legacy JSONL transcripts and OpenClaw 2026.9.2+ per-agent
+ * SQLite transcripts as synthetic dashboard "projects" grouped by
+ * (agentId, channel).
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { runtimeCache } from "./runtime-cache";
-import { listOpenClawAgents, listOpenClawTranscripts, openclawHome } from "./openclaw-sessions";
+import {
+  listOpenClawAgents,
+  listOpenClawTranscripts,
+  openclawHome,
+} from "./openclaw-sessions";
 import type { ProjectFolder, SessionFile } from "./projects";
 import { formatDate } from "./format-date";
+import { listOpenClawSqliteSessions } from "./openclaw-db";
 
 export interface OpenClawSessionRef {
   sessionId: string;
@@ -51,7 +54,13 @@ function str(v: unknown): string | undefined {
  *  than in the key — verified live against v2026.7.1. */
 function readSessionsIndex(agentId: string): Map<string, SessionIndexMeta> {
   const out = new Map<string, SessionIndexMeta>();
-  const indexPath = join(openclawHome(), "agents", agentId, "sessions", "sessions.json");
+  const indexPath = join(
+    openclawHome(),
+    "agents",
+    agentId,
+    "sessions",
+    "sessions.json",
+  );
   let raw: unknown;
   try {
     raw = JSON.parse(readFileSync(indexPath, "utf-8"));
@@ -64,7 +73,9 @@ function readSessionsIndex(agentId: string): Map<string, SessionIndexMeta> {
     const e = v as Record<string, unknown>;
     const sessionId = str(e.sessionId);
     if (!sessionId) continue;
-    const origin = (e.origin && typeof e.origin === "object" ? e.origin : {}) as Record<string, unknown>;
+    const origin = (
+      e.origin && typeof e.origin === "object" ? e.origin : {}
+    ) as Record<string, unknown>;
     const lastMs =
       typeof e.lastInteractionAt === "number"
         ? e.lastInteractionAt
@@ -73,7 +84,8 @@ function readSessionsIndex(agentId: string): Map<string, SessionIndexMeta> {
           : undefined;
     out.set(sessionId, {
       lastMs,
-      channel: str(e.lastChannel) ?? str(origin.provider) ?? str(origin.surface),
+      channel:
+        str(e.lastChannel) ?? str(origin.provider) ?? str(origin.surface),
       chatType: str(e.chatType) ?? str(origin.chatType),
       label: str(origin.label),
       chatId: str(e.lastTo) ?? str(origin.from),
@@ -86,7 +98,7 @@ function readSessionsIndex(agentId: string): Map<string, SessionIndexMeta> {
 export async function getOpenClawSessions(): Promise<OpenClawSessionRef[]> {
   const transcripts = listOpenClawTranscripts();
   const indexByAgent = new Map<string, Map<string, SessionIndexMeta>>();
-  const refs: OpenClawSessionRef[] = [];
+  const refs = new Map<string, OpenClawSessionRef>();
   for (const t of transcripts) {
     let idx = indexByAgent.get(t.agentId);
     if (!idx) {
@@ -94,7 +106,7 @@ export async function getOpenClawSessions(): Promise<OpenClawSessionRef[]> {
       indexByAgent.set(t.agentId, idx);
     }
     const meta = idx.get(t.sessionId);
-    refs.push({
+    refs.set(`${t.agentId}\0${t.sessionId}`, {
       sessionId: t.sessionId,
       agentId: t.agentId,
       // Gateway sessions group by channel; CLI/local runs have none.
@@ -107,8 +119,18 @@ export async function getOpenClawSessions(): Promise<OpenClawSessionRef[]> {
       sizeBytes: t.sizeBytes,
     });
   }
-  refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  return refs;
+
+  // SQLite is the live source on OpenClaw 2026.9.2+. Insert it second so it
+  // replaces an archived JSONL copy of the same agent/session.
+  const sqliteSessions = await listOpenClawSqliteSessions(
+    openclawHome(),
+    listOpenClawAgents(),
+  );
+  for (const s of sqliteSessions) {
+    refs.set(`${s.agentId}\0${s.sessionId}`, s);
+  }
+
+  return [...refs.values()].sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 
 export const getCachedOpenClawSessions = runtimeCache(getOpenClawSessions, 2);
@@ -145,7 +167,9 @@ export interface OpenClawNameSplit {
  * form (`agentId: null`), so links shared before agents became part of the name
  * keep resolving — to every agent on that channel, which is what they meant.
  */
-export function openClawProjectNameCandidates(name: string): OpenClawNameSplit[] {
+export function openClawProjectNameCandidates(
+  name: string,
+): OpenClawNameSplit[] {
   if (!name.startsWith("openclaw-")) return [];
   const rest = name.slice("openclaw-".length);
   if (!rest) return [];
@@ -163,7 +187,9 @@ export function openClawProjectNameCandidates(name: string): OpenClawNameSplit[]
 }
 
 /** The best-guess split for a project name — `null` if it isn't an OpenClaw one. */
-export function parseOpenClawProjectName(name: string): OpenClawNameSplit | null {
+export function parseOpenClawProjectName(
+  name: string,
+): OpenClawNameSplit | null {
   return openClawProjectNameCandidates(name)[0] ?? null;
 }
 
@@ -190,7 +216,12 @@ export async function getOpenClawProjects(): Promise<ProjectFolder[]> {
       prev.latest = Math.max(prev.latest, s.mtimeMs);
       prev.count += 1;
     } else {
-      groups.set(key, { agentId: s.agentId, channel: s.channel, latest: s.mtimeMs, count: 1 });
+      groups.set(key, {
+        agentId: s.agentId,
+        channel: s.channel,
+        latest: s.mtimeMs,
+        count: 1,
+      });
     }
   }
   const out: ProjectFolder[] = [];
@@ -228,7 +259,9 @@ export async function getOpenClawSessionsByEncodedName(
   const sessions = await getOpenClawSessions();
   const matching = (split: OpenClawNameSplit) =>
     sessions.filter(
-      (s) => s.channel === split.channel && (split.agentId === null || s.agentId === split.agentId),
+      (s) =>
+        s.channel === split.channel &&
+        (split.agentId === null || s.agentId === split.agentId),
     );
 
   // Take the first split that actually owns sessions — length alone picks the
@@ -250,7 +283,10 @@ export async function getOpenClawSessionsByEncodedName(
   return {
     // Legacy channel-only names keep their old cwd label, since they really do
     // span every agent on that channel.
-    cwd: agentId === null ? `openclaw:${channel}` : openClawProjectPath(agentId, channel),
+    cwd:
+      agentId === null
+        ? `openclaw:${channel}`
+        : openClawProjectPath(agentId, channel),
     sessions: matched.map((s) => {
       const lastModified = new Date(s.mtimeMs);
       return {

package/.next/standalone/lib/openclaw-sessions.ts

@@ -1,11 +1,9 @@
 /**
  * OpenClaw (openclaw gateway) session transcript loader + parser.
  *
- * AUDIT-ONLY (Pillar 2). OpenClaw writes one JSONL transcript per session at
- * `~/.openclaw/agents/<agentId>/sessions/<sessionId>.jsonl` (sessionId is a
- * UUID), alongside a much larger `<sessionId>.trajectory.jsonl` OTel trace we
- * IGNORE, and a `sessions.json` index keyed by sessionKey. Verified live
- * against openclaw v2026.7.1.
+ * Legacy OpenClaw writes one JSONL transcript per session under `sessions/`;
+ * 2026.9.2+ stores the same logical records as `event_json` rows in each
+ * agent's `agent/openclaw-agent.sqlite`. SQLite is preferred when both exist.
  *
  * The transcript is type-discriminated JSONL:
  *   {type:"session", cwd, …}              — header (carries cwd)
@@ -18,8 +16,8 @@
  * `toolResult` by `toolCallId` (mirrors lib/hermes-sessions.ts) and is PURE, so
  * it is unit-testable with plain line objects.
  *
- * Home override: set `OPENCLAW_HOME` (used by tests / to point at a copied
- * gateway config dir).
+ * Home override: `OPENCLAW_STATE_DIR`, then `OPENCLAW_HOME` (used by tests /
+ * to point at a copied gateway config dir).
  */
 import { readFile } from "node:fs/promises";
 import { readdirSync, statSync } from "node:fs";
@@ -39,13 +37,18 @@ import {
   type LogSource,
 } from "./log-entries";
 import { formatDuration } from "./format-duration";
+import { readOpenClawSqliteTranscript } from "./openclaw-db";
 
 /** OpenClaw sessions are stored under UUID filenames. */
 export const OPENCLAW_SESSION_ID_RE = /^[0-9a-fA-F-]{36}$/;
 
-/** Absolute path to OpenClaw's config home (override with OPENCLAW_HOME). */
+/** Absolute path to OpenClaw's state home. */
 export function openclawHome(): string {
-  return process.env.OPENCLAW_HOME || join(homedir(), ".openclaw");
+  return (
+    process.env.OPENCLAW_STATE_DIR ||
+    process.env.OPENCLAW_HOME ||
+    join(homedir(), ".openclaw")
+  );
 }
 
 // ── Parsing helpers ──
@@ -60,7 +63,11 @@ function extractText(content: unknown): string {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     return content
-      .map((c) => (isPlainObject(c) && typeof c.text === "string" ? (c.text as string) : ""))
+      .map((c) =>
+        isPlainObject(c) && typeof c.text === "string"
+          ? (c.text as string)
+          : "",
+      )
       .filter(Boolean)
       .join("\n");
   }
@@ -134,7 +141,10 @@ export function openclawLinesToLogEntries(
           if (b.type === "text" && typeof b.text === "string") {
             blocks.push({ type: "text", text: b.text });
           } else if (b.type === "toolCall") {
-            const id = typeof b.id === "string" ? b.id : `${String(b.name ?? "tool")}-${blocks.length}`;
+            const id =
+              typeof b.id === "string"
+                ? b.id
+                : `${String(b.name ?? "tool")}-${blocks.length}`;
             const name = typeof b.name === "string" ? b.name : "tool";
             const input = isPlainObject(b.arguments) ? b.arguments : {};
             const block: ToolUseBlock = { type: "tool_use", id, name, input };
@@ -151,17 +161,23 @@ export function openclawLinesToLogEntries(
       entries.push({
         type: "assistant",
         ...base,
-        message: { role: "assistant", content: blocks, model: typeof m.model === "string" ? m.model : undefined },
+        message: {
+          role: "assistant",
+          content: blocks,
+          model: typeof m.model === "string" ? m.model : undefined,
+        },
       } satisfies AssistantEntry);
       continue;
     }
 
     if (role === "toolResult") {
-      const callId = typeof m.toolCallId === "string" ? m.toolCallId : undefined;
+      const callId =
+        typeof m.toolCallId === "string" ? m.toolCallId : undefined;
       const block = callId ? toolUseById.get(callId) : undefined;
       if (block) {
         const details = isPlainObject(m.details) ? m.details : undefined;
-        const startMs = (callId && toolUseStartMs.get(callId)) || date.getTime();
+        const startMs =
+          (callId && toolUseStartMs.get(callId)) || date.getTime();
         const durationMs =
           details && typeof details.durationMs === "number"
             ? details.durationMs
@@ -238,13 +254,20 @@ export function listOpenClawTranscripts(): OpenClawTranscriptFile[] {
     }
     for (const file of files) {
       // Only `<uuid>.jsonl` — not `<uuid>.trajectory.jsonl` / `.trajectory-path.json`.
-      if (!file.endsWith(".jsonl") || file.endsWith(".trajectory.jsonl")) continue;
+      if (!file.endsWith(".jsonl") || file.endsWith(".trajectory.jsonl"))
+        continue;
       const sessionId = file.slice(0, -".jsonl".length);
       if (!OPENCLAW_SESSION_ID_RE.test(sessionId)) continue;
       const transcriptPath = join(sessionsDir, file);
       try {
         const st = statSync(transcriptPath);
-        out.push({ agentId, sessionId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
+        out.push({
+          agentId,
+          sessionId,
+          transcriptPath,
+          mtimeMs: st.mtimeMs,
+          sizeBytes: st.size,
+        });
       } catch {
         // skip unreadable
       }
@@ -276,6 +299,36 @@ export interface OpenClawSessionLogData {
 export async function getOpenClawSessionLog(
   sessionId: string,
 ): Promise<OpenClawSessionLogData | null> {
+  if (!OPENCLAW_SESSION_ID_RE.test(sessionId)) return null;
+
+  // New OpenClaw versions keep live transcripts in SQLite. Prefer that copy
+  // when an archived JSONL with the same UUID also exists.
+  const sqlite = await readOpenClawSqliteTranscript(
+    openclawHome(),
+    listOpenClawAgents(),
+    sessionId,
+  );
+  if (sqlite) {
+    const entries = openclawLinesToLogEntries(sqlite.rawLines, "session");
+    let cwd: string | undefined;
+    for (const line of sqlite.rawLines) {
+      if (
+        line.type === "session" &&
+        typeof line.cwd === "string" &&
+        line.cwd.length > 0
+      ) {
+        cwd = line.cwd;
+        break;
+      }
+    }
+    return {
+      entries,
+      rawLines: sqlite.rawLines,
+      cwd,
+      filePath: sqlite.filePath,
+    };
+  }
+
   const filePath = findOpenClawTranscript(sessionId);
   if (!filePath) return null;
   let content: string;
@@ -289,7 +342,12 @@ export async function getOpenClawSessionLog(
   // cwd lives on the `type:"session"` header line.
   let cwd: string | undefined;
   for (const line of rawLines) {
-    if (isPlainObject(line) && line.type === "session" && typeof line.cwd === "string" && line.cwd.length > 0) {
+    if (
+      isPlainObject(line) &&
+      line.type === "session" &&
+      typeof line.cwd === "string" &&
+      line.cwd.length > 0
+    ) {
       cwd = line.cwd;
       break;
     }

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "1.0.4-beta.6",
+  "version": "1.0.4-beta.8",
   "description": "Observability and enforcement for AI agent harnesses. 39 built-in policies hooked into 12 of them — Claude Code, Codex, Cursor, Hermes, OpenClaw and more — blocking the tool call before it runs. Local dashboard included, no account needed.",
   "bin": {
     "failproofai": "./dist/cli.mjs",
@@ -121,15 +121,15 @@
     "browserslist": "4.28.8"
   },
   "optionalDependencies": {
-    "@failproofai/failproofaid-linux-x64": "1.0.4-beta.6",
-    "@failproofai/failproofaid-linux-arm64": "1.0.4-beta.6",
-    "@failproofai/failproofaid-darwin-x64": "1.0.4-beta.6",
-    "@failproofai/failproofaid-darwin-arm64": "1.0.4-beta.6"
+    "@failproofai/failproofaid-linux-x64": "1.0.4-beta.8",
+    "@failproofai/failproofaid-linux-arm64": "1.0.4-beta.8",
+    "@failproofai/failproofaid-darwin-x64": "1.0.4-beta.8",
+    "@failproofai/failproofaid-darwin-arm64": "1.0.4-beta.8"
   },
   "failproofaidBinaries": {
-    "linux-x64": "24118b8bd058cc5d8711053c4c77cdca9361c12dbf0f421a757d33f07596d428",
-    "linux-arm64": "b4278c34a288de2c747bcebcc623d8fd5bda3a1f1e55800926eb1a4b89f0a5e9",
-    "darwin-x64": "ecb66699f45f605b0d54ac9e4bac360ac11e4e136442dcccdd083514d77c7d42",
-    "darwin-arm64": "b3dbad58bda960ef9481f90bc5085ba8624b2472519cc0bf212a0e8451dd2db4"
+    "linux-x64": "17274c1da30675b49de74953a4ce2777e09ba07b9da79250ab155e5fdb316a0a",
+    "linux-arm64": "a07b228d899914baca1c75024be19c0319eb4fc40c6d5a303ba733bf6721924a",
+    "darwin-x64": "d170fd5604cb419bc83f4a5ab1a6cb5be2f9aec957aed99ce237990aa5d3966f",
+    "darwin-arm64": "0e2bde5bd0762641fa072a6640e485c637b2102f2fb6c1afeca679f005e89679"
   }
 }