failproofai 1.0.4-beta.8 → 1.0.4

package/.next/standalone/app/actions/get-leaks.ts

@@ -1,104 +0,0 @@
-"use server";
-
-import {
-  activeFindings,
-  dismissFinding,
-  readLeakRecord,
-} from "@/src/audit/leak-store";
-import { readConfig, updateConfig } from "@/src/hooks/fp-config";
-
-/**
- * One credential, flattened for the report table.
- *
- * A separate shape from `LeakFinding` on purpose: this crosses into a client
- * component, so it carries only what is drawn. The finding's raw sightings, its
- * rule and its salt stay on the server side of the boundary — not because any
- * of them is a secret (the record holds no secret by construction), but because
- * a display type that mirrors the storage type drifts into rendering whatever
- * gets added to storage next.
- */
-export interface LeakRow {
-  id: string;
-  /** WHAT — `ghp_••••••••4f2a`. Never the value; there is no value to send. */
-  display: string;
-  label: string;
-  length: number;
-  /** False means no console to revoke at — the advice changes completely. */
-  attributed: boolean;
-  /** The identifier it was assigned to, when there was one. */
-  name: string | null;
-  /** WHO — the harness whose transcript carried it. */
-  cli: string;
-  /** WHERE — home-shortened project path. */
-  project: string;
-  /** WHEN — ISO, formatted client-side so it lands in the reader's timezone. */
-  lastSeen: string;
-  firstSeen: string;
-  /** HOW — "read from ~/…/.env". */
-  mechanism: string;
-  /** WHY IT MATTERS — an input the agent sent can be denied next time; a
-   *  result it received cannot be un-received. */
-  direction: "input" | "result";
-  occurrences: number;
-  sessions: number;
-}
-
-export interface LeaksPayload {
-  rows: LeakRow[];
-  /** Whether this machine may raise a desktop notification. Drawn as a toggle
-   *  beside the table, because the table is where somebody decides the banner
-   *  was worth it or not. */
-  notify: boolean;
-}
-
-export async function getLeaksAction(): Promise<LeaksPayload> {
-  const findings = activeFindings(readLeakRecord());
-  const rows: LeakRow[] = findings.map((f) => {
-    // The most recent sighting: where the key is now, not where it debuted.
-    const seen = f.sightings?.[f.sightings.length - 1];
-    return {
-      id: f.id,
-      display: f.fingerprint?.display ?? "[credential]",
-      label: f.fingerprint?.label ?? "secret",
-      length: f.fingerprint?.length ?? 0,
-      attributed: f.fingerprint?.attributed === true,
-      name: f.name,
-      cli: seen?.cli ?? "unknown",
-      project: seen?.cwd ?? "unknown",
-      lastSeen: f.lastSeen,
-      firstSeen: f.firstSeen,
-      mechanism: seen?.mechanism?.summary ?? "seen in a transcript",
-      direction: seen?.mechanism?.direction ?? "result",
-      occurrences: f.occurrences,
-      sessions: new Set((f.sightings ?? []).map((s) => s.sessionId)).size,
-    };
-  });
-  rows.sort((a, b) => Date.parse(b.lastSeen) - Date.parse(a.lastSeen));
-  return { rows, notify: readConfig().audit.notify };
-}
-
-/**
- * Mark one finding as not-a-secret.
- *
- * The finding is RETAINED, not deleted — deleting it would let the next scan
- * rediscover the same value and alert again, which is the one outcome that
- * teaches a user the dismiss button does not work.
- */
-export async function dismissLeakAction(id: string): Promise<boolean> {
-  return dismissFinding(id);
-}
-
-/**
- * Turn the desktop banner on or off.
- *
- * Writes the same `audit.notify` key `failproofai config` writes and the daemon's
- * audit child reads, so the dashboard and the CLI cannot disagree about it.
- */
-export async function setLeakNotifyAction(notify: boolean): Promise<boolean> {
-  try {
-    updateConfig({ audit: { notify } });
-    return true;
-  } catch {
-    return false;
-  }
-}

package/.next/standalone/app/audit/_components/leak-section.tsx

@@ -1,192 +0,0 @@
-"use client";
-
-/**
- * The leak report: every credential this machine found in its own transcripts.
- *
- * This is what replaced the persona poster and the five scored sections. The
- * old report answered "what kind of agent user are you"; this one answers the
- * only question a leaked key raises — what is it, where did it go, how did it
- * get there, and what do I do now.
- *
- * Each row is one DISTINCT credential, not one sighting: a key pasted into
- * forty commands is one thing to rotate, not forty. The count of exposures is a
- * column, which is the honest way to show forty without implying forty problems.
- */
-import { useCallback, useEffect, useState } from "react";
-import {
-  dismissLeakAction,
-  getLeaksAction,
-  setLeakNotifyAction,
-  type LeakRow,
-} from "@/app/actions/get-leaks";
-
-/** Rendered in the reader's timezone, which is why it is not done server-side. */
-function when(iso: string): string {
-  const t = Date.parse(iso);
-  if (!Number.isFinite(t)) return "unknown";
-  const days = Math.floor((Date.now() - t) / 86_400_000);
-  if (days <= 0) return "today";
-  if (days === 1) return "yesterday";
-  if (days < 30) return `${days}d ago`;
-  return new Date(t).toLocaleDateString(undefined, { month: "short", day: "numeric" });
-}
-
-/**
- * What to actually do about this one.
- *
- * Two genuinely different situations, and conflating them is what makes
- * security advice useless. A recognised prefix means a console exists and the
- * key can be revoked there in a minute. An unattributed value — the majority,
- * per the pattern census — has no console at all: the only move is to find
- * where it came from, and the identifier name is usually the only clue.
- */
-function advice(row: LeakRow): string {
-  if (row.attributed) return `rotate it in the ${row.label.replace(/ (API )?(key|token).*$/i, "")} console`;
-  if (row.name) return `find what reads ${row.name}, then rotate it there`;
-  return "trace it to its owner, then rotate it";
-}
-
-export function LeakSection() {
-  const [rows, setRows] = useState<LeakRow[] | null>(null);
-  const [notify, setNotify] = useState(true);
-  const [busy, setBusy] = useState<string | null>(null);
-
-  const load = useCallback(async () => {
-    const payload = await getLeaksAction();
-    setRows(payload.rows);
-    setNotify(payload.notify);
-  }, []);
-
-  useEffect(() => {
-    void load();
-  }, [load]);
-
-  const dismiss = useCallback(
-    async (id: string) => {
-      setBusy(id);
-      try {
-        // Optimism would be wrong here: a dismissal that did not persist means
-        // the row comes back on the next load, and the user has to guess which
-        // of the two states is real.
-        if (await dismissLeakAction(id)) setRows((prev) => prev?.filter((r) => r.id !== id) ?? null);
-      } finally {
-        setBusy(null);
-      }
-    },
-    [],
-  );
-
-  const toggleNotify = useCallback(async () => {
-    const next = !notify;
-    setNotify(next);
-    if (!(await setLeakNotifyAction(next))) setNotify(!next);
-  }, [notify]);
-
-  if (rows === null) return null;
-
-  return (
-    <section className="audit-sec" data-screen-label="02 Leaks">
-      <div className="audit-sec-head">
-        <span className="audit-sec-eyebrow">
-          <span className="ix">02</span>{"// credentials"}
-        </span>
-        <button
-          type="button"
-          className="cbb-toggle leak-notify"
-          data-on={notify}
-          onClick={toggleNotify}
-          aria-label={notify ? "turn desktop notifications off" : "turn desktop notifications on"}
-          title="desktop notification when a new credential is found"
-        >
-          <span className="cbb-toggle-knob" />
-        </button>
-      </div>
-
-      {rows.length === 0 ? (
-        <>
-          <h2 className="audit-sec-title">no credentials found</h2>
-          <div className="audit-sec-sub">
-            {"// nothing in this machine's transcripts matched a known key format"}
-            <br />
-            {"// or a secret-named assignment."}
-          </div>
-        </>
-      ) : (
-        <>
-          <h2 className="audit-sec-title">
-            {rows.length} credential{rows.length === 1 ? "" : "s"} in your transcripts
-          </h2>
-          <div className="audit-sec-sub">
-            {"// one row per distinct key — an exposure count is not a key count."}
-          </div>
-
-          <ul className="leak-list">
-            {rows.map((row) => (
-              <li key={row.id} className="leak-row" data-attributed={row.attributed}>
-                <div className="leak-row-top">
-                  <code className="leak-key">{row.display}</code>
-                  <span className="leak-label">{row.label}</span>
-                  {row.name ? <span className="leak-name">{row.name}</span> : null}
-                  <button
-                    type="button"
-                    className="leak-dismiss"
-                    onClick={() => void dismiss(row.id)}
-                    disabled={busy === row.id}
-                  >
-                    not a secret
-                  </button>
-                </div>
-
-                {/* The 5W1H, as one sentence rather than a grid of labelled
-                    cells — a person reading a leak wants the story, and the
-                    grid version made every row look like a form to fill in. */}
-                {/* The date is FIRST seen, not last. "When did this key get
-                    into a transcript" is the question a leak raises; "when did
-                    I last run a scan that noticed" is not. They also looked
-                    identical in practice — the record keeps the 500 most
-                    recently seen findings, so everything surviving the cap
-                    reported the same recent `lastSeen` and every row read
-                    "today", which is true and useless. */}
-                <div className="leak-how">
-                  <span className="leak-verb">{row.mechanism}</span>
-                  {" in "}
-                  <span className="leak-where">{row.project}</span>
-                  {" via "}
-                  <span className="leak-who">{row.cli}</span>
-                  {" · leaked "}
-                  <span className="leak-when">{when(row.firstSeen)}</span>
-                  {row.firstSeen !== row.lastSeen ? (
-                    <>
-                      {" · last seen "}
-                      <span className="leak-when">{when(row.lastSeen)}</span>
-                    </>
-                  ) : null}
-                </div>
-
-                <div className="leak-foot">
-                  <span className="leak-meta">
-                    {row.occurrences} exposure{row.occurrences === 1 ? "" : "s"}
-                    {row.sessions > 1 ? ` · ${row.sessions} sessions` : ""}
-                    {" · "}
-                    {row.length} chars
-                  </span>
-                  {/* The direction is the difference between a leak a gate can
-                      stop next time and one it cannot. An input travelled OUT
-                      of the machine with the agent's request; a result came
-                      back INTO the transcript from a file or a command, where
-                      no PreToolUse hook can intercept it. */}
-                  <span className="leak-dir">
-                    {row.direction === "input"
-                      ? "sent by the agent — blockable at PreToolUse"
-                      : "returned to the agent — already in the transcript"}
-                  </span>
-                  <span className="leak-fix">{advice(row)}</span>
-                </div>
-              </li>
-            ))}
-          </ul>
-        </>
-      )}
-    </section>
-  );
-}

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

@@ -1,271 +0,0 @@
-/**
- * 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;
-}