failproofai 1.0.3 → 1.0.4-beta.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "failproofai",
-  "version": "1.0.3",
-  "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.",
+  "version": "1.0.4-beta.1",
+  "description": "Observability and enforcement for AI agent harnesses. 39 built-in policies hooked into 16 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",
     "failproofaid": "./bin/failproofaid-shim.mjs"
@@ -87,7 +87,7 @@
     "@testing-library/jest-dom": "^7.0.0",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.5",
-    "@types/node": "26.2.0",
+    "@types/node": "26.4.0",
     "@types/react": "19.2.18",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.1.0",
@@ -120,15 +120,15 @@
     "sharp": "0.35.0"
   },
   "optionalDependencies": {
-    "@failproofai/failproofaid-linux-x64": "1.0.3",
-    "@failproofai/failproofaid-linux-arm64": "1.0.3",
-    "@failproofai/failproofaid-darwin-x64": "1.0.3",
-    "@failproofai/failproofaid-darwin-arm64": "1.0.3"
+    "@failproofai/failproofaid-linux-x64": "1.0.4-beta.1",
+    "@failproofai/failproofaid-linux-arm64": "1.0.4-beta.1",
+    "@failproofai/failproofaid-darwin-x64": "1.0.4-beta.1",
+    "@failproofai/failproofaid-darwin-arm64": "1.0.4-beta.1"
   },
   "failproofaidBinaries": {
-    "linux-x64": "2a4164e88792f2cd8616868eb63a52011e110b8b13643e1082ad3af982730226",
-    "linux-arm64": "c995f896183ba54b596535687b94bfd52efaa56736a36016d2de987bccdaa810",
-    "darwin-x64": "a56c871ce0d460683a2e57cb6eed2f91a329c2f03889612fef62191fcb57868a",
-    "darwin-arm64": "dab3246a917dc32869dfb36b5b682beaa87330c8cd2797027c9b9adc4084ceab"
+    "linux-x64": "bda0aa2ff38779c247161c8928a6b5ca7dd846ae3ce5c6a6efd8b9509f67fca7",
+    "linux-arm64": "557699a24bec7a970839b952ee139b679e2feb0a505f5652a0e770e295ae148a",
+    "darwin-x64": "f23ff6e57f45ac51c0f3c7f5b876041100c119d7a3b81105a0df00018a2e2cc1",
+    "darwin-arm64": "7bc433a08d26fc148c21bc5471679440bf50300e47f1a2af505465476ca3352e"
   }
 }

package/src/audit/cli-adapters/cline.ts

@@ -0,0 +1,50 @@
+/**
+ * Cline transcript adapter — AUDIT-ONLY (Pillar 2).
+ *
+ * The thinnest adapter we have, because cline already stores Claude's own
+ * content blocks: lib/cline-projects.ts enumerates the per-session directories
+ * (each carrying a real `cwd`, so `audit --project <cwd>` filters work as they
+ * do for Devin, Goose and ori), lib/cline-sessions.ts pairs tool_result back
+ * onto tool_use, and `logEntriesToEvents` does the rest unchanged.
+ */
+import { getClineSessions } from "../../../lib/cline-projects";
+import { getClineSessionLog } from "../../../lib/cline-sessions";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listClineTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  const projectFilter = opts.projects ? new Set(opts.projects) : null;
+  const sinceMs = opts.sinceMs ?? 0;
+  const sessions = await getClineSessions();
+  const out: TranscriptMetadata[] = [];
+  for (const s of sessions) {
+    if (s.mtimeMs < sinceMs) continue;
+    if (projectFilter && (!s.cwd || !projectFilter.has(s.cwd))) continue;
+    out.push({
+      cli: "cline",
+      projectName: s.projectName,
+      sessionId: s.sessionId,
+      transcriptPath: `cline-session://${s.sessionId}`,
+      mtimeMs: s.mtimeMs,
+      // ended_at/started_at advance per session, so (mtime) is a real cache key.
+      sizeBytes: 0,
+    });
+  }
+  return out;
+}
+
+export async function streamClineEvents(
+  meta: TranscriptMetadata,
+): Promise<NormalizedToolEvent[]> {
+  const log = await getClineSessionLog(meta.sessionId);
+  if (!log) return [];
+  return logEntriesToEvents(log.entries, {
+    cli: "cline",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd: log.cwd ?? "",
+  });
+}

package/src/audit/cli-adapters/grok.ts

@@ -0,0 +1,70 @@
+/**
+ * grok CLI transcript adapter — AUDIT (Pillar 2).
+ *
+ * grok writes one session DIRECTORY at
+ * `~/.grok/sessions/<percent-encoded-cwd>/<sessionId>/`, whose
+ * `chat_history.jsonl` holds the turns (verified live against grok 1.0.3).
+ * lib/grok-sessions.ts enumerates and parses them.
+ *
+ * `chat_history.jsonl` has no per-message timestamps, so the parser anchors a
+ * synthesized timeline on the session's `created_at` (from summary.json) —
+ * `listGrokTranscripts` already resolved that, so it is passed straight
+ * through here rather than re-read.
+ */
+import { readFile } from "node:fs/promises";
+import { listGrokTranscripts, grokLinesToLogEntries } from "../../../lib/grok-sessions";
+import { parseRawLines } from "../../../lib/log-entries";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listGrokTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  const projectFilter = opts.projects ? new Set(opts.projects) : null;
+  const sinceMs = opts.sinceMs ?? 0;
+  const out: TranscriptMetadata[] = [];
+
+  for (const t of listGrokTranscripts()) {
+    if (t.mtimeMs < sinceMs) continue;
+    // `audit --project <cwd>` filters on the real cwd (summary.json's info.cwd
+    // when present, else the percent-decoded folder name).
+    if (projectFilter && !projectFilter.has(t.cwd)) continue;
+    out.push({
+      cli: "grok",
+      projectName: t.projectName,
+      sessionId: t.sessionId,
+      transcriptPath: t.transcriptPath,
+      mtimeMs: t.mtimeMs,
+      sizeBytes: t.sizeBytes,
+    });
+  }
+  return out;
+}
+
+export async function streamGrokEvents(meta: TranscriptMetadata): Promise<NormalizedToolEvent[]> {
+  let content: string;
+  try {
+    content = await readFile(meta.transcriptPath, "utf-8");
+  } catch {
+    return [];
+  }
+
+  // Recover this session's cwd + created_at from the enumeration (both come
+  // from summary.json, which streamEvents is not otherwise given).
+  const known = listGrokTranscripts().find((t) => t.sessionId === meta.sessionId);
+
+  const rawLines = parseRawLines(content, "session");
+  const entries = grokLinesToLogEntries(
+    rawLines,
+    known?.createdAtMs ?? meta.mtimeMs,
+    "session",
+  );
+
+  return logEntriesToEvents(entries, {
+    cli: "grok",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd: known?.cwd ?? "",
+  });
+}

package/src/audit/cli-adapters/index.ts

@@ -23,6 +23,10 @@ import { listFactoryTranscriptMetadata, streamFactoryEvents } from "./factory";
 import { listAntigravityTranscriptMetadata, streamAntigravityEvents } from "./antigravity";
 import { listDevinTranscriptMetadata, streamDevinEvents } from "./devin";
 import { listGooseTranscriptMetadata, streamGooseEvents } from "./goose";
+import { listGrokTranscriptMetadata, streamGrokEvents } from "./grok";
+import { listQwenTranscriptMetadata, streamQwenEvents } from "./qwen";
+import { listOriTranscriptMetadata, streamOriEvents } from "./ori";
+import { listClineTranscriptMetadata, streamClineEvents } from "./cline";
 
 export type { ListOpts };
 
@@ -123,6 +127,26 @@ export const ADAPTERS: Record<IntegrationType, CliAdapter> = {
     listTranscripts: listGooseTranscriptMetadata,
     streamEvents: streamGooseEvents,
   },
+  grok: {
+    cli: "grok",
+    listTranscripts: listGrokTranscriptMetadata,
+    streamEvents: streamGrokEvents,
+  },
+  qwen: {
+    cli: "qwen",
+    listTranscripts: listQwenTranscriptMetadata,
+    streamEvents: streamQwenEvents,
+  },
+  ori: {
+    cli: "ori",
+    listTranscripts: listOriTranscriptMetadata,
+    streamEvents: streamOriEvents,
+  },
+  cline: {
+    cli: "cline",
+    listTranscripts: listClineTranscriptMetadata,
+    streamEvents: streamClineEvents,
+  },
 };
 
 export function getAdapter(cli: IntegrationType): CliAdapter {

package/src/audit/cli-adapters/ori.ts

@@ -0,0 +1,55 @@
+/**
+ * Ori (OpenRouter's ori) transcript adapter — AUDIT-ONLY (Pillar 2).
+ *
+ * Covers ori's OWN agent (bare `ori` / `ori code`). Sessions launched through
+ * ori's LAUNCHER (`ori claude`, `ori codex`, …) are recorded by the launched
+ * CLI in its own store and are picked up by that CLI's adapter, not this one.
+ *
+ * ori keeps the whole conversation in one SQLite DB in its global workspace —
+ * lib/ori-projects.ts enumerates `ori_agent_loop_sessions`, lib/ori-sessions.ts
+ * parses each session's serialized message array — producing the same
+ * LogEntry[] shape the other adapters do, so `logEntriesToEvents` handles the
+ * rest. Each session carries a real `cwd`, so `audit --project <cwd>` filters
+ * work as they do for Devin and Goose.
+ */
+import { getOriSessions } from "../../../lib/ori-projects";
+import { getOriSessionLog } from "../../../lib/ori-sessions";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listOriTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  const projectFilter = opts.projects ? new Set(opts.projects) : null;
+  const sinceMs = opts.sinceMs ?? 0;
+  const sessions = await getOriSessions();
+  const out: TranscriptMetadata[] = [];
+  for (const s of sessions) {
+    if (s.mtimeMs < sinceMs) continue;
+    if (projectFilter && (!s.cwd || !projectFilter.has(s.cwd))) continue;
+    out.push({
+      cli: "ori",
+      projectName: s.projectName,
+      sessionId: s.sessionId,
+      transcriptPath: `ori-db://${s.sessionId}`,
+      mtimeMs: s.mtimeMs,
+      // updated_at advances on each turn, so (mtime) forms a real cache key.
+      sizeBytes: 0,
+    });
+  }
+  return out;
+}
+
+export async function streamOriEvents(
+  meta: TranscriptMetadata,
+): Promise<NormalizedToolEvent[]> {
+  const log = await getOriSessionLog(meta.sessionId);
+  if (!log) return [];
+  return logEntriesToEvents(log.entries, {
+    cli: "ori",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd: log.cwd ?? "",
+  });
+}

package/src/audit/cli-adapters/qwen.ts

@@ -0,0 +1,71 @@
+/**
+ * Qwen Code transcript adapter — AUDIT (Pillar 2).
+ *
+ * qwen writes real JSONL transcripts at
+ * `~/.qwen/projects/<encoded-cwd>/chats/<sessionId>.jsonl` (Claude-style
+ * encoded-cwd folders, one level deeper than Claude's; verified live against
+ * qwen-code 0.21.12). lib/qwen-sessions.ts enumerates and parses them — the
+ * message bodies are Gemini-shaped `parts[]`, not Claude content blocks — into
+ * the shared LogEntry[] shape, so `logEntriesToEvents` handles the rest.
+ */
+import { readFile } from "node:fs/promises";
+import { listQwenTranscripts, qwenLinesToLogEntries } from "../../../lib/qwen-sessions";
+import { parseRawLines } from "../../../lib/log-entries";
+import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
+import type { ListOpts } from "./claude";
+import { logEntriesToEvents } from "./shared";
+
+export async function listQwenTranscriptMetadata(
+  opts: ListOpts = {},
+): Promise<TranscriptMetadata[]> {
+  const projectFilter = opts.projects ? new Set(opts.projects) : null;
+  const sinceMs = opts.sinceMs ?? 0;
+  const out: TranscriptMetadata[] = [];
+
+  for (const t of listQwenTranscripts()) {
+    if (t.mtimeMs < sinceMs) continue;
+    // `audit --project <cwd>` filters on the decoded working directory.
+    if (projectFilter && !projectFilter.has(t.cwd)) continue;
+    out.push({
+      cli: "qwen",
+      projectName: t.projectName,
+      sessionId: t.sessionId,
+      transcriptPath: t.transcriptPath,
+      mtimeMs: t.mtimeMs,
+      sizeBytes: t.sizeBytes,
+    });
+  }
+  return out;
+}
+
+export async function streamQwenEvents(meta: TranscriptMetadata): Promise<NormalizedToolEvent[]> {
+  let content: string;
+  try {
+    content = await readFile(meta.transcriptPath, "utf-8");
+  } catch {
+    return [];
+  }
+
+  const rawLines = parseRawLines(content, "session");
+  const entries = qwenLinesToLogEntries(rawLines, "session");
+
+  // Every qwen line carries the real cwd — take the first rather than
+  // re-decoding the (lossy) folder name.
+  let cwd = "";
+  for (const line of rawLines) {
+    if (line && typeof line === "object") {
+      const c = (line as Record<string, unknown>).cwd;
+      if (typeof c === "string" && c.length > 0) {
+        cwd = c;
+        break;
+      }
+    }
+  }
+
+  return logEntriesToEvents(entries, {
+    cli: "qwen",
+    sessionId: meta.sessionId,
+    transcriptPath: meta.transcriptPath,
+    cwd,
+  });
+}