failproofai 0.0.13-beta.2 → 0.0.14-beta.0

package/lib/goose-sessions.ts

@@ -0,0 +1,296 @@
+/**
+ * Goose (codename goose, Block) session transcript loader + parser.
+ *
+ * AUDIT-ONLY (Pillar 2). Goose (≥ v1.10.0) stores every session in one SQLite DB
+ * at `~/.local/share/goose/sessions/sessions.db`. We read it DIRECTLY via the
+ * bundled sql.js driver (lib/sqlite-reader.ts) — the same reusable path
+ * Devin/Hermes/OpenClaw use. Like Devin (and unlike the cwd-less Hermes gateway),
+ * each Goose `sessions` row carries a real `working_dir`, so Goose sessions group
+ * by project cwd like Claude/Factory/Devin.
+ *
+ * Schema (verified live against goose v1.43.0, schema_version 15):
+ *   sessions(id TEXT `YYYYMMDD_N`, name, description, session_type
+ *            (user|hidden|subagent|scheduled|terminal|acp), working_dir,
+ *            created_at TIMESTAMP, updated_at TIMESTAMP, total_tokens, …)
+ *   messages(id INTEGER PK, session_id, role (user|assistant),
+ *            content_json TEXT=JSON-array-of-blocks, created_timestamp INT, …)
+ *
+ * `content_json` is a Claude-style typed-block array (NOT OpenAI-style like
+ * Devin): `{type:"text",text}`, `{type:"toolRequest",id,toolCall:{value:{name,
+ * arguments}},_meta:{goose_extension}}`, and `{type:"toolResponse",id,toolResult:
+ * {value:{content:[{type:"text",text}],isError}}}`. Tool RESULTS are stored in
+ * `role:"user"` rows (Claude convention). `gooseRowsToLogEntries` pairs each
+ * toolRequest with its later toolResponse by id and is a PURE function of the
+ * parsed rows, so it is unit-testable without a DB.
+ *
+ * `session_type = 'hidden'` rows are `goose run --no-session` scratch runs — the
+ * enumerator (lib/goose-projects.ts) filters them out.
+ *
+ * Home override: set `GOOSE_HOME` (the data dir that contains `sessions/`, used
+ * by tests) or `GOOSE_DB_PATH` (points directly at a sessions.db).
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { openSqliteReadonly } from "./sqlite-reader";
+import { runtimeCache } from "./runtime-cache";
+import {
+  baseEntry,
+  formatTimestamp,
+  type LogEntry,
+  type UserEntry,
+  type AssistantEntry,
+  type GenericEntry,
+  type ContentBlock,
+  type ToolUseBlock,
+  type LogSource,
+} from "./log-entries";
+import { formatDuration } from "./format-duration";
+
+/** Goose session IDs are date-prefixed counters, e.g. `20260714_3`. */
+export const GOOSE_SESSION_ID_RE = /^\d{8}_\d+$/;
+
+/** Absolute path to Goose's data home (override with GOOSE_HOME; respects
+ *  XDG_DATA_HOME otherwise). */
+export function gooseHome(): string {
+  if (process.env.GOOSE_HOME) return process.env.GOOSE_HOME;
+  const xdg = process.env.XDG_DATA_HOME;
+  return join(xdg && xdg.length > 0 ? xdg : join(homedir(), ".local", "share"), "goose");
+}
+
+/** Absolute path to Goose's SQLite DB (override with GOOSE_DB_PATH). */
+export function gooseDbPath(): string {
+  return process.env.GOOSE_DB_PATH || join(gooseHome(), "sessions", "sessions.db");
+}
+
+/** Coerce a Goose timestamp to epoch ms. `messages.created_timestamp` is an
+ *  INTEGER epoch (seconds or ms); `sessions.created_at`/`updated_at` are SQLite
+ *  `CURRENT_TIMESTAMP` strings ("YYYY-MM-DD HH:MM:SS", UTC). */
+export function gooseTimestampToMs(value: unknown): number {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value > 1e12) return value; // already ms
+    if (value > 1e9) return value * 1000; // seconds
+  }
+  if (typeof value === "string" && value.length > 0) {
+    // SQLite CURRENT_TIMESTAMP has no zone and is UTC — normalize to ISO-Z so
+    // Date.parse doesn't treat it as local time.
+    const iso = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value)
+      ? value.replace(" ", "T") + "Z"
+      : value;
+    const ms = Date.parse(iso);
+    if (!Number.isNaN(ms)) return ms;
+  }
+  return Date.now();
+}
+
+// ── Parsing helpers ──
+
+function safeJsonParse(s: unknown): unknown {
+  if (typeof s !== "string" || s.length === 0) return undefined;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return undefined;
+  }
+}
+
+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 {
+  const ms = typeof value === "number" || typeof value === "string" ? gooseTimestampToMs(value) : NaN;
+  return Number.isNaN(ms) ? new Date(fallbackMs) : new Date(ms);
+}
+
+/** Pull `{ id, name, input }` from a Goose `toolRequest` block:
+ *  `{id, toolCall:{status, value:{name, arguments}}}`. */
+function extractToolRequest(
+  block: Record<string, unknown>,
+  idx: number,
+): { id: string; name: string; input: Record<string, unknown> } {
+  const id = typeof block.id === "string" && block.id ? block.id : `goose-tool-${idx}`;
+  const toolCall = isPlainObject(block.toolCall) ? block.toolCall : {};
+  const value = isPlainObject(toolCall.value) ? toolCall.value : {};
+  const name = typeof value.name === "string" ? value.name : "tool";
+  const input = isPlainObject(value.arguments) ? value.arguments : {};
+  return { id, name, input };
+}
+
+/** Text of a Goose `toolResponse` block:
+ *  `{id, toolResult:{status, value:{content:[{type:"text",text}], …}}}`. */
+function extractToolResult(block: Record<string, unknown>): string {
+  const toolResult = isPlainObject(block.toolResult) ? block.toolResult : {};
+  const value = toolResult.value;
+  if (isPlainObject(value) && Array.isArray(value.content)) return extractText(value.content);
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return extractText(value);
+  return "";
+}
+
+// ── Pure parser: message rows → LogEntry[] ──
+
+export interface GooseMessageRow {
+  role: string | null;
+  content_json: string | null;
+  created_timestamp: number | null;
+}
+
+/**
+ * Convert Goose `messages` rows (in insertion order) into `LogEntry[]`. Each
+ * row's `content_json` is a typed-block array; `toolRequest` blocks become
+ * `tool_use` blocks on an assistant entry, and later `toolResponse` blocks
+ * (which arrive in `role:"user"` rows) attach as the matching tool_use's result
+ * by id. Pure — unit-testable with plain rows.
+ */
+export function gooseRowsToLogEntries(
+  rows: GooseMessageRow[],
+  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 < rows.length; i++) {
+    const r = rows[i];
+    const parsed = safeJsonParse(r.content_json);
+    if (!Array.isArray(parsed)) continue;
+
+    const role = typeof r.role === "string" ? r.role : "system";
+    const date = toDate(r.created_timestamp, baseMs + i);
+    const timestamp = date.toISOString();
+    const raw: Record<string, unknown> = { uuid: `goose-${i}`, parentUuid: null };
+    const base = baseEntry(raw, timestamp, date, source);
+
+    const textParts: string[] = [];
+    const toolReqs: Record<string, unknown>[] = [];
+    const toolResps: Record<string, unknown>[] = [];
+    for (const b of parsed) {
+      if (!isPlainObject(b)) continue;
+      if (b.type === "text" && typeof b.text === "string") textParts.push(b.text);
+      else if (b.type === "toolRequest") toolReqs.push(b);
+      else if (b.type === "toolResponse") toolResps.push(b);
+    }
+
+    // Attach tool results to their earlier tool_use blocks (results arrive in
+    // role:"user" rows, so this runs before we consider the row a user turn).
+    for (const tr of toolResps) {
+      const callId = typeof tr.id === "string" ? tr.id : undefined;
+      const block = callId ? toolUseById.get(callId) : undefined;
+      if (!block) continue;
+      const startMs = (callId && toolUseStartMs.get(callId)) || date.getTime();
+      const durationMs = Math.max(0, date.getTime() - startMs);
+      block.result = {
+        timestamp,
+        timestampFormatted: formatTimestamp(date),
+        content: extractToolResult(tr),
+        durationMs,
+        durationFormatted: formatDuration(durationMs),
+      };
+    }
+
+    const text = textParts.join("\n").trim();
+
+    if (toolReqs.length > 0 || (role === "assistant" && text)) {
+      const blocks: ContentBlock[] = [];
+      if (text) blocks.push({ type: "text", text });
+      for (const req of toolReqs) {
+        const { id, name, input } = extractToolRequest(req, blocks.length);
+        const block: ToolUseBlock = { type: "tool_use", id, name, input };
+        blocks.push(block);
+        toolUseById.set(id, block);
+        toolUseStartMs.set(id, date.getTime());
+      }
+      if (blocks.length === 0) continue;
+      entries.push({
+        type: "assistant",
+        ...base,
+        message: { role: "assistant", content: blocks },
+      } satisfies AssistantEntry);
+      continue;
+    }
+
+    if (role === "user" && text) {
+      entries.push({
+        type: "user",
+        ...base,
+        message: { role: "user", content: text },
+      } satisfies UserEntry);
+      continue;
+    }
+
+    // Pure tool-result rows (no text, no requests) produced no new entry above.
+    if (text) {
+      entries.push({ type: "system", ...base, raw } satisfies GenericEntry);
+    }
+  }
+
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+  return entries;
+}
+
+// ── DB loader ──
+
+export interface GooseSessionLogData {
+  entries: LogEntry[];
+  rawLines: Record<string, unknown>[];
+  cwd?: string;
+  filePath: string; // synthetic — goose keeps sessions in a DB; we use goose-db://<id>
+}
+
+/**
+ * Load one session by ID from `sessions.db`. Returns `null` when the DB is
+ * unavailable or the session doesn't exist.
+ */
+export async function getGooseSessionLog(
+  sessionId: string,
+): Promise<GooseSessionLogData | null> {
+  if (!sessionId || !GOOSE_SESSION_ID_RE.test(sessionId)) return null;
+  const db = await openSqliteReadonly(gooseDbPath());
+  if (!db) return null;
+  try {
+    const sessionRows = db.query<{ working_dir: string | null }>(
+      "SELECT working_dir FROM sessions WHERE id = ?",
+      [sessionId],
+    );
+    if (sessionRows.length === 0) return null;
+    const realCwd = sessionRows[0].working_dir;
+
+    const msgRows = db.query<GooseMessageRow>(
+      "SELECT role, content_json, created_timestamp FROM messages " +
+        "WHERE session_id = ? ORDER BY id ASC",
+      [sessionId],
+    );
+    const entries = gooseRowsToLogEntries(msgRows, "session");
+    const cwd = realCwd && realCwd.length > 0 ? realCwd : undefined;
+    return {
+      entries,
+      rawLines: msgRows as unknown as Record<string, unknown>[],
+      cwd,
+      filePath: `goose-db://${sessionId}`,
+    };
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+
+export const getCachedGooseSessionLog = runtimeCache(
+  (sessionId: string) => getGooseSessionLog(sessionId),
+  2,
+  { maxSize: 50 },
+);

package/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 },
+);