failproofai 0.0.13 → 0.0.14-beta.1

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

@@ -0,0 +1,182 @@
+/**
+ * OpenClaw (openclaw gateway) session enumeration — AUDIT-ONLY.
+ *
+ * Surfaces the on-disk transcripts (agents/<agentId>/sessions/<uuid>.jsonl) as
+ * synthetic dashboard "projects" grouped by agentId. 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.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { runtimeCache } from "./runtime-cache";
+import { listOpenClawTranscripts, openclawHome } from "./openclaw-sessions";
+import type { ProjectFolder, SessionFile } from "./projects";
+import { formatDate } from "./format-date";
+
+export interface OpenClawSessionRef {
+  sessionId: string;
+  agentId: string;
+  /** Channel/source the session last ran in (from sessions.json metadata) —
+   *  e.g. "telegram", "slack", or "local" for a CLI session. Drives grouping. */
+  channel: string;
+  /** Human-readable label from `origin.label` (e.g. "Chetan (@chhhee10) id:…"). */
+  label?: string;
+  /** Chat id (e.g. "telegram:8674922496") + type ("direct"/"group") for the
+   *  gateway-metadata columns. */
+  chatId?: string;
+  chatType?: string;
+  mtimeMs: number;
+  sizeBytes: number;
+}
+
+interface SessionIndexMeta {
+  lastMs?: number;
+  channel?: string;
+  chatType?: string;
+  label?: string;
+  chatId?: string;
+}
+
+function str(v: unknown): string | undefined {
+  return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+
+/** Read the per-agent sessions.json index → sessionId → routing metadata.
+ *  OpenClaw routes gateway sessions through the agent's default key
+ *  (`agent:<id>:main`) and records the channel in metadata fields
+ *  (`lastChannel`, `chatType`, `origin.{label,provider,from}`, `lastTo`) rather
+ *  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");
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(indexPath, "utf-8"));
+  } catch {
+    return out;
+  }
+  if (!raw || typeof raw !== "object") return out;
+  for (const v of Object.values(raw as Record<string, unknown>)) {
+    if (!v || typeof v !== "object") continue;
+    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 lastMs =
+      typeof e.lastInteractionAt === "number"
+        ? e.lastInteractionAt
+        : typeof e.updatedAt === "number"
+          ? (e.updatedAt as number)
+          : undefined;
+    out.set(sessionId, {
+      lastMs,
+      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),
+    });
+  }
+  return out;
+}
+
+/** List every OpenClaw session across all agents. Fail-open ([] on any error). */
+export async function getOpenClawSessions(): Promise<OpenClawSessionRef[]> {
+  const transcripts = listOpenClawTranscripts();
+  const indexByAgent = new Map<string, Map<string, SessionIndexMeta>>();
+  const refs: OpenClawSessionRef[] = [];
+  for (const t of transcripts) {
+    let idx = indexByAgent.get(t.agentId);
+    if (!idx) {
+      idx = readSessionsIndex(t.agentId);
+      indexByAgent.set(t.agentId, idx);
+    }
+    const meta = idx.get(t.sessionId);
+    refs.push({
+      sessionId: t.sessionId,
+      agentId: t.agentId,
+      // Gateway sessions group by channel; CLI/local runs have none.
+      channel: meta?.channel ?? "local",
+      label: meta?.label,
+      chatType: meta?.chatType,
+      chatId: meta?.chatId,
+      mtimeMs: meta?.lastMs ?? t.mtimeMs,
+      sizeBytes: t.sizeBytes,
+    });
+  }
+  refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return refs;
+}
+
+export const getCachedOpenClawSessions = runtimeCache(getOpenClawSessions, 2);
+
+// ── Dashboard history browser (projects list + project-detail sessions) ──
+
+/**
+ * Surface OpenClaw sessions as synthetic "projects" grouped by **channel**
+ * (telegram/slack/…/local) — gateway sessions run per channel, not in a host
+ * repo. Mirrors Hermes's group-by-source. One ProjectFolder per channel; its
+ * `name` is `openclaw-<channel>`, reversed in `getOpenClawSessionsByEncodedName`.
+ */
+export async function getOpenClawProjects(): Promise<ProjectFolder[]> {
+  const sessions = await getOpenClawSessions();
+  const latestByChannel = new Map<string, number>();
+  for (const s of sessions) {
+    latestByChannel.set(s.channel, Math.max(latestByChannel.get(s.channel) ?? 0, s.mtimeMs));
+  }
+  const out: ProjectFolder[] = [];
+  for (const [channel, latest] of latestByChannel) {
+    const lastModified = new Date(latest);
+    out.push({
+      name: `openclaw-${channel}`,
+      path: `openclaw:${channel}`,
+      isDirectory: true,
+      lastModified,
+      lastModifiedFormatted: formatDate(lastModified),
+      cli: ["openclaw"],
+    });
+  }
+  out.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return out;
+}
+
+export interface OpenClawProjectByName {
+  cwd: string | null;
+  sessions: SessionFile[];
+}
+
+/** Resolve the OpenClaw sessions for a synthetic project name
+ *  (`openclaw-<channel>`), for the project-detail page. Session names use the
+ *  human-readable `origin.label` (e.g. "Chetan (@chhhee10) id:…") rather than
+ *  the raw session key. */
+export async function getOpenClawSessionsByEncodedName(
+  name: string,
+): Promise<OpenClawProjectByName> {
+  if (!name.startsWith("openclaw-")) return { cwd: null, sessions: [] };
+  const channel = name.slice("openclaw-".length);
+  const sessions = await getOpenClawSessions();
+  const matched = sessions.filter((s) => s.channel === channel);
+  return {
+    cwd: `openclaw:${channel}`,
+    sessions: matched.map((s) => {
+      const lastModified = new Date(s.mtimeMs);
+      return {
+        name: s.label ?? s.chatId ?? s.sessionId,
+        path: s.sessionId,
+        lastModified,
+        lastModifiedFormatted: formatDate(lastModified),
+        sessionId: s.sessionId,
+        cli: "openclaw" as const,
+        channelId: s.chatId,
+        channelType: s.chatType,
+      };
+    }),
+  };
+}
+
+export const getCachedOpenClawProjects = runtimeCache(getOpenClawProjects, 2);
+export const getCachedOpenClawSessionsByEncodedName = runtimeCache(
+  (name: string) => getOpenClawSessionsByEncodedName(name),
+  2,
+  { maxSize: 50 },
+);

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

@@ -0,0 +1,284 @@
+/**
+ * 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.
+ *
+ * The transcript is type-discriminated JSONL:
+ *   {type:"session", cwd, …}              — header (carries cwd)
+ *   {type:"model_change" | "thinking_level_change" | "custom", …} — metadata
+ *   {type:"message", timestamp, message:{role, content, …}} — the turns, where
+ *     role ∈ "user" (content string) | "assistant" (content = list of
+ *     {type:"text",text} / {type:"toolCall", id, name, arguments}) |
+ *     "toolResult" ({toolCallId, toolName, content, details, isError}).
+ * `openclawLinesToLogEntries` pairs each assistant `toolCall` with its later
+ * `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).
+ */
+import { readFile } from "node:fs/promises";
+import { readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { runtimeCache } from "./runtime-cache";
+import {
+  baseEntry,
+  formatTimestamp,
+  parseRawLines,
+  type LogEntry,
+  type UserEntry,
+  type AssistantEntry,
+  type GenericEntry,
+  type ContentBlock,
+  type ToolUseBlock,
+  type LogSource,
+} from "./log-entries";
+import { formatDuration } from "./format-duration";
+
+/** 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). */
+export function openclawHome(): string {
+  return process.env.OPENCLAW_HOME || join(homedir(), ".openclaw");
+}
+
+// ── Parsing helpers ──
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+
+/** Text from a `content` field that may be a string or an array of
+ *  `{ type:"text", text }` blocks. */
+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) : ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}
+
+function toDate(value: unknown, fallbackMs: number): Date {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value > 1e12) return new Date(value);
+    if (value > 1e9) return new Date(value * 1000);
+  }
+  if (typeof value === "string") {
+    const ms = Date.parse(value);
+    if (!Number.isNaN(ms)) return new Date(ms);
+  }
+  return new Date(fallbackMs);
+}
+
+// ── Pure parser: transcript lines → LogEntry[] ──
+
+/**
+ * Convert OpenClaw transcript JSONL lines (parsed objects, in file order) into
+ * `LogEntry[]`. Only `type:"message"` lines carry turns; `session` /
+ * `model_change` / `thinking_level_change` / `custom` lines are metadata and
+ * are skipped (they'd otherwise clutter the audit with empty system entries).
+ * Assistant `toolCall` blocks are paired with their later `toolResult` message
+ * by `toolCallId`. Pure — unit-testable with plain line objects.
+ */
+export function openclawLinesToLogEntries(
+  lines: Record<string, unknown>[],
+  source: LogSource = "session",
+): LogEntry[] {
+  const entries: LogEntry[] = [];
+  const toolUseById = new Map<string, ToolUseBlock>();
+  const toolUseStartMs = new Map<string, number>();
+  const baseMs = Date.now();
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!isPlainObject(line)) continue;
+    if (line.type !== "message") continue; // skip session/model_change/custom/…
+
+    const m = isPlainObject(line.message) ? line.message : undefined;
+    if (!m) continue;
+    const role = typeof m.role === "string" ? m.role : "system";
+
+    // Outer line `timestamp` is an ISO string; message.timestamp is epoch ms.
+    const date = toDate(line.timestamp ?? m.timestamp, baseMs + i);
+    const timestamp = date.toISOString();
+    const raw: Record<string, unknown> = {
+      uuid: line.id != null ? String(line.id) : `openclaw-${i}`,
+      parentUuid: line.parentId != null ? String(line.parentId) : null,
+    };
+    const base = baseEntry(raw, timestamp, date, source);
+
+    if (role === "user") {
+      entries.push({
+        type: "user",
+        ...base,
+        message: { role: "user", content: extractText(m.content) },
+      } satisfies UserEntry);
+      continue;
+    }
+
+    if (role === "assistant") {
+      const blocks: ContentBlock[] = [];
+      const content = m.content;
+      if (Array.isArray(content)) {
+        for (const b of content) {
+          if (!isPlainObject(b)) continue;
+          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 name = typeof b.name === "string" ? b.name : "tool";
+            const input = isPlainObject(b.arguments) ? b.arguments : {};
+            const block: ToolUseBlock = { type: "tool_use", id, name, input };
+            blocks.push(block);
+            toolUseById.set(id, block);
+            toolUseStartMs.set(id, date.getTime());
+          }
+        }
+      } else {
+        const text = extractText(content);
+        if (text) blocks.push({ type: "text", text });
+      }
+      if (blocks.length === 0) continue; // empty / failed assistant turn
+      entries.push({
+        type: "assistant",
+        ...base,
+        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 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 durationMs =
+          details && typeof details.durationMs === "number"
+            ? details.durationMs
+            : Math.max(0, date.getTime() - startMs);
+        block.result = {
+          timestamp,
+          timestampFormatted: formatTimestamp(date),
+          content: extractText(m.content),
+          durationMs,
+          durationFormatted: formatDuration(durationMs),
+        };
+        continue;
+      }
+      // Orphan tool result — fall through to a system entry.
+    }
+
+    entries.push({ type: "system", ...base, raw } satisfies GenericEntry);
+  }
+
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return entries;
+}
+
+// ── Discovery + file loader ──
+
+export interface OpenClawTranscriptFile {
+  agentId: string;
+  sessionId: string;
+  transcriptPath: string;
+  mtimeMs: number;
+  sizeBytes: number;
+}
+
+/** Enumerate `agents/<agentId>/sessions/<uuid>.jsonl` transcripts, skipping the
+ *  heavy `.trajectory.jsonl` OTel traces and pointer files. */
+export function listOpenClawTranscripts(): OpenClawTranscriptFile[] {
+  const agentsDir = join(openclawHome(), "agents");
+  const out: OpenClawTranscriptFile[] = [];
+  let agentIds: string[];
+  try {
+    agentIds = readdirSync(agentsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return out;
+  }
+  for (const agentId of agentIds) {
+    const sessionsDir = join(agentsDir, agentId, "sessions");
+    let files: string[];
+    try {
+      files = readdirSync(sessionsDir);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      // Only `<uuid>.jsonl` — not `<uuid>.trajectory.jsonl` / `.trajectory-path.json`.
+      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 });
+      } catch {
+        // skip unreadable
+      }
+    }
+  }
+  return out;
+}
+
+/** Resolve a session UUID to its on-disk transcript path (host-side). Guards
+ *  against traversal by requiring a UUID filename. Shared by the audit adapter
+ *  and download-session. */
+export function findOpenClawTranscript(sessionId: string): string | null {
+  if (!OPENCLAW_SESSION_ID_RE.test(sessionId)) return null;
+  for (const t of listOpenClawTranscripts()) {
+    if (t.sessionId === sessionId) return t.transcriptPath;
+  }
+  return null;
+}
+
+export interface OpenClawSessionLogData {
+  entries: LogEntry[];
+  rawLines: Record<string, unknown>[];
+  cwd?: string;
+  filePath: string;
+}
+
+/** Load and parse one session transcript by UUID. Returns `null` when the file
+ *  is missing/unreadable or the id fails validation. */
+export async function getOpenClawSessionLog(
+  sessionId: string,
+): Promise<OpenClawSessionLogData | null> {
+  const filePath = findOpenClawTranscript(sessionId);
+  if (!filePath) return null;
+  let content: string;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const rawLines = parseRawLines(content, "session");
+  const entries = openclawLinesToLogEntries(rawLines, "session");
+  // 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) {
+      cwd = line.cwd;
+      break;
+    }
+  }
+  return { entries, rawLines, cwd, filePath };
+}
+
+export const getCachedOpenClawSessionLog = runtimeCache(
+  (sessionId: string) => getOpenClawSessionLog(sessionId),
+  2,
+  { maxSize: 50 },
+);

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

@@ -16,7 +16,7 @@ import { formatDate } from "./format-date";
 export const UUID_RE = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
 export const PATH_TRAVERSAL_RE = /(^|[\\/])\.\.($|[\\/])/;
 
-export type ProjectCli = "claude" | "codex" | "copilot" | "cursor" | "opencode" | "pi" | "gemini" | "hermes";
+export type ProjectCli = "claude" | "codex" | "copilot" | "cursor" | "opencode" | "pi" | "hermes" | "openclaw" | "factory" | "devin" | "antigravity" | "goose";
 
 export interface ProjectFolder {
   name: string;
@@ -143,18 +143,26 @@ export async function getProjectFolders(): Promise<ProjectFolder[]> {
     { getCursorProjects },
     { getOpenCodeProjects },
     { getPiProjects },
-    { getGeminiProjects },
     { getHermesProjects },
+    { getOpenClawProjects },
+    { getFactoryProjects },
+    { getDevinProjects },
+    { getAntigravityProjects },
+    { getGooseProjects },
   ] = await Promise.all([
     import("./codex-projects"),
     import("./copilot-projects"),
     import("./cursor-projects"),
     import("./opencode-projects"),
     import("./pi-projects"),
-    import("./gemini-projects"),
     import("./hermes-projects"),
+    import("./openclaw-projects"),
+    import("./factory-projects"),
+    import("./devin-projects"),
+    import("./antigravity-projects"),
+    import("./goose-projects"),
   ]);
-  const [claude, codex, copilot, cursor, opencode, pi, gemini, hermes] = await Promise.all([
+  const [claude, codex, copilot, cursor, opencode, pi, hermes, openclaw, factory, devin, antigravity, goose] = await Promise.all([
     getClaudeProjectFolders(),
     getCodexProjects().catch((error) => {
       logError("Error reading Codex projects:", error);
@@ -176,16 +184,32 @@ export async function getProjectFolders(): Promise<ProjectFolder[]> {
       logError("Error reading Pi projects:", error);
       return [] as ProjectFolder[];
     }),
-    getGeminiProjects().catch((error) => {
-      logError("Error reading Gemini projects:", error);
-      return [] as ProjectFolder[];
-    }),
     getHermesProjects().catch((error) => {
       logError("Error reading Hermes projects:", error);
       return [] as ProjectFolder[];
     }),
+    getOpenClawProjects().catch((error) => {
+      logError("Error reading OpenClaw projects:", error);
+      return [] as ProjectFolder[];
+    }),
+    getFactoryProjects().catch((error) => {
+      logError("Error reading Factory projects:", error);
+      return [] as ProjectFolder[];
+    }),
+    getDevinProjects().catch((error) => {
+      logError("Error reading Devin projects:", error);
+      return [] as ProjectFolder[];
+    }),
+    getAntigravityProjects().catch((error) => {
+      logError("Error reading Antigravity projects:", error);
+      return [] as ProjectFolder[];
+    }),
+    getGooseProjects().catch((error) => {
+      logError("Error reading Goose projects:", error);
+      return [] as ProjectFolder[];
+    }),
   ]);
-  return mergeProjectFolders(claude, codex, copilot, cursor, opencode, pi, gemini, hermes);
+  return mergeProjectFolders(claude, codex, copilot, cursor, opencode, pi, hermes, openclaw, factory, devin, antigravity, goose);
 }
 
 /**

package/.next/standalone/lib/telemetry-sanitize.ts

@@ -0,0 +1,43 @@
+import os from "node:os";
+
+/** Max length of a telemetry error message; longer strings are truncated. */
+const MAX_ERROR_MESSAGE_LEN = 300;
+
+/**
+ * Turn an error into a telemetry-safe message string for the `error_message`
+ * property on failure events (e.g. `cli_audit_failed`, `audit_run_failed`).
+ *
+ * Two protections keep this consistent with failproofai's telemetry philosophy
+ * (no raw local paths / PII on the wire):
+ *   1. The user's home directory is collapsed to `~`, so an error that embeds a
+ *      path like `/home/alice/.codex/…` is reported as `~/.codex/…`.
+ *   2. The message is truncated to a bounded length (with an ellipsis marker).
+ *
+ * Never throws — falls back to `"unknown"` if the error can't be stringified.
+ */
+export function sanitizeErrorMessage(err: unknown): string {
+  let msg: string;
+  try {
+    msg = err instanceof Error ? err.message : String(err);
+  } catch {
+    return "unknown";
+  }
+  if (!msg) return "";
+
+  let home = "";
+  try {
+    home = os.homedir();
+  } catch {
+    /* homedir unavailable — skip path stripping */
+  }
+  // Only strip a real, non-root home to avoid mangling messages when homedir is
+  // "/" or empty.
+  if (home && home.length > 1) {
+    msg = msg.split(home).join("~");
+  }
+
+  if (msg.length > MAX_ERROR_MESSAGE_LEN) {
+    msg = msg.slice(0, MAX_ERROR_MESSAGE_LEN) + "…";
+  }
+  return msg;
+}