failproofai 0.0.1-beta.1

package/.next/standalone/lib/log-stats.ts

@@ -0,0 +1,54 @@
+import type { LogEntry } from "./log-entries";
+import { formatDuration } from "./format-duration";
+
+export interface LogStats {
+  turnCount: number;
+  userCount: number;
+  assistantCount: number;
+  toolCallCount: number;
+  subagentCount: number;
+  duration: string;
+  models: string[];
+}
+
+/**
+ * Computes summary statistics from parsed log entries.
+ *
+ * Iterates entries once, counting users, assistants, tool calls, and
+ * subagent spawns. Duration is derived from the timestamp delta between
+ * the first and last entry. Models are de-duplicated into a set.
+ */
+export function calculateLogStats(entries: LogEntry[]): LogStats {
+  let userCount = 0;
+  let assistantCount = 0;
+  let toolCallCount = 0;
+  let subagentCount = 0;
+  let turnCount = 0;
+  const models = new Set<string>();
+
+  for (const entry of entries) {
+    if (entry.type === "user") userCount++;
+    if (entry.type === "queue-operation") turnCount++;
+    if (entry.type === "assistant") {
+      assistantCount++;
+      for (const block of entry.message.content) {
+        if (block.type === "tool_use") {
+          if (block.name === "Task" && (block.subagentType || block.subagentId)) {
+            subagentCount++;
+          } else {
+            toolCallCount++;
+          }
+        }
+      }
+      if (entry.message.model) models.add(entry.message.model);
+    }
+  }
+
+  let duration = "";
+  if (entries.length >= 2) {
+    const diffMs = entries[entries.length - 1].timestampMs - entries[0].timestampMs;
+    duration = formatDuration(diffMs);
+  }
+
+  return { turnCount, userCount, assistantCount, toolCallCount, subagentCount, duration, models: Array.from(models) };
+}

package/.next/standalone/lib/logger.ts

@@ -0,0 +1,70 @@
+/**
+ * Centralized logger with level filtering.
+ *
+ * Reads FAILPROOFAI_LOG_LEVEL env var (info | warn | error).
+ * Default level: warn — only WARN and ERROR messages are emitted.
+ *
+ * Format: [failproofai<ISO timestamp>] LEVEL message
+ */
+
+export type LogLevel = "info" | "warn" | "error";
+
+const LEVEL_ORDER: Record<LogLevel, number> = { info: 0, warn: 1, error: 2 };
+
+let currentLevel: LogLevel = "warn";
+
+export function initLogger(): void {
+  const raw = (process.env.FAILPROOFAI_LOG_LEVEL ?? "").toLowerCase();
+  if (raw === "info" || raw === "warn" || raw === "error") {
+    currentLevel = raw;
+  } else {
+    currentLevel = "warn";
+  }
+}
+
+export function getLogLevel(): LogLevel {
+  return currentLevel;
+}
+
+function shouldEmit(level: LogLevel): boolean {
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
+}
+
+function stamp(label: string): string {
+  return `[failproofai${new Date().toISOString()}] ${label}`;
+}
+
+export function logInfo(msg: string, detail?: unknown): void {
+  if (!shouldEmit("info")) return;
+  if (detail !== undefined) {
+    console.log(stamp("INFO"), msg, detail);
+  } else {
+    console.log(stamp("INFO"), msg);
+  }
+}
+
+export function logWarn(msg: string, detail?: unknown): void {
+  if (!shouldEmit("warn")) return;
+  if (detail !== undefined) {
+    console.warn(stamp("WARN"), msg, detail);
+  } else {
+    console.warn(stamp("WARN"), msg);
+  }
+}
+
+export function logError(msg: string, detail?: unknown): void {
+  // error is always emitted
+  if (detail !== undefined) {
+    console.error(stamp("ERROR"), msg, detail);
+  } else {
+    console.error(stamp("ERROR"), msg);
+  }
+}
+
+export function logActivity(username: string, action: string, detail?: string): void {
+  if (!shouldEmit("info")) return;
+  const parts = [`user=${username}`, `action=${action}`];
+  if (detail) parts.push(detail);
+  console.log(stamp("ACTIVITY"), parts.join(" "));
+}
+

package/.next/standalone/lib/paths.ts

@@ -0,0 +1,42 @@
+/**
+ * OS-aware path resolution for the `.claude/projects` directory.
+ *
+ * Supports an optional `CLAUDE_PROJECTS_PATH` environment variable
+ * override; otherwise defaults to `~/.claude/projects` on all platforms.
+ */
+import { homedir } from "os";
+import { join } from "path";
+
+export function getDefaultClaudeProjectsPath(): string {
+  // ~/.claude/projects on all platforms (including Windows)
+  return join(homedir(), ".claude", "projects");
+}
+
+/**
+ * Decodes a Claude project folder name back to its original filesystem path.
+ *
+ * Claude encodes project paths by replacing path separators with `-`.
+ * On Windows, `C:/code/project` becomes `C--code-project` (`:` → `-`, `/` → `-`).
+ * On Linux/macOS, `/home/user/project` becomes `-home-user-project`.
+ *
+ * This function reverses that encoding.
+ */
+export function decodeFolderName(name: string): string {
+  // Windows drive-letter pattern: "C--rest-of-path"
+  if (/^[A-Za-z]--/.test(name)) {
+    return name[0] + ":/" + name.slice(3).replace(/-/g, "/");
+  }
+  return name.replace(/-/g, "/");
+}
+
+export function getClaudeProjectsPath(): string {
+  // Check if path is provided via environment variable
+  const envPath = process.env.CLAUDE_PROJECTS_PATH;
+  
+  if (envPath) {
+    return envPath;
+  }
+  
+  return getDefaultClaudeProjectsPath();
+}
+

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

@@ -0,0 +1,181 @@
+/**
+ * Server-side helpers for reading Claude Agent SDK project folders and
+ * session log files from the local filesystem.
+ *
+ * All functions return sorted arrays (newest-first) and pre-format dates
+ * so that client components can display them without hydration mismatches.
+ */
+import { readdir, stat } from "fs/promises";
+import { join, resolve, sep } from "path";
+import { getClaudeProjectsPath } from "./paths";
+import { runtimeCache } from "./runtime-cache";
+import { batchAll } from "./concurrency";
+import { logWarn, logError } from "./logger";
+import { formatDate } from "./utils";
+
+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 interface ProjectFolder {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+  lastModified: Date;
+  lastModifiedFormatted?: string; // Pre-formatted date string to avoid hydration issues
+}
+
+export interface SessionFile {
+  name: string;
+  path: string;
+  lastModified: Date;
+  lastModifiedFormatted?: string;
+  sessionId?: string;
+}
+
+/** Stats a path and returns mtime. Falls back to epoch (1970-01-01) on error
+ *  so that callers always get a valid Date for sorting without try/catch. */
+async function getMtime(path: string, label: string): Promise<Date> {
+  try {
+    return (await stat(path)).mtime;
+  } catch (error) {
+    logWarn(`Failed to stat ${label}:`, error);
+    return new Date(0);
+  }
+}
+
+/** Reads a directory safely, returning [] if it doesn't exist. */
+async function safeReaddir(dirPath: string) {
+  try {
+    const s = await stat(dirPath);
+    if (!s.isDirectory()) return null;
+    return await readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+
+export async function getProjectFolders(): Promise<ProjectFolder[]> {
+  try {
+    const projectsPath = getClaudeProjectsPath();
+    const entries = await safeReaddir(projectsPath);
+    if (!entries) return [];
+
+    const settled = await batchAll(
+      entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => async () => {
+          const folderPath = join(projectsPath, entry.name);
+          const mtime = await getMtime(folderPath, entry.name);
+          return {
+            name: entry.name,
+            path: folderPath,
+            isDirectory: true,
+            lastModified: mtime,
+            lastModifiedFormatted: formatDate(mtime),
+          } as ProjectFolder;
+        }),
+      16,
+    );
+    const folders = settled
+      .filter((r): r is PromiseFulfilledResult<ProjectFolder> => r.status === "fulfilled")
+      .map((r) => r.value);
+
+    folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    return folders;
+  } catch (error) {
+    logError("Error reading project folders:", error);
+    return [];
+  }
+}
+
+/**
+ * Gets the full path to a specific project folder
+ * @param projectName - Name of the project folder
+ * @returns Full path to the project folder
+ */
+export function getProjectPath(projectName: string): string {
+  const projectsPath = getClaudeProjectsPath();
+  return join(projectsPath, projectName);
+}
+
+/**
+ * Resolves a project name to its absolute path, verifying it stays under
+ * the Claude projects root. Throws RangeError for any invalid or escaping input.
+ * Callers should catch RangeError and return 400/404 as appropriate.
+ */
+export function resolveProjectPath(projectName: string): string {
+  if (!projectName) throw new RangeError("Empty project name");
+  // Reject absolute paths before joining (catches /etc, \Windows, etc.)
+  if (/^[/\\]/.test(projectName)) throw new RangeError("Absolute project name");
+  const projectsPath = resolve(getClaudeProjectsPath());
+  const candidate = resolve(join(projectsPath, projectName));
+  // Must be strictly under the root (not equal — projects are subdirs)
+  if (!candidate.startsWith(projectsPath + sep)) {
+    throw new RangeError("Project path escapes root");
+  }
+  return candidate;
+}
+
+/**
+ * Resolves a session file path, validating both project name and session ID.
+ * Throws RangeError for invalid inputs (caught by callers for 400/404).
+ */
+export function resolveSessionFilePath(projectName: string, sessionId: string): string {
+  if (!UUID_RE.test(sessionId)) throw new RangeError("Invalid session ID");
+  const projectDir = resolveProjectPath(projectName);
+  return join(projectDir, `${sessionId}.jsonl`);
+}
+
+/**
+ * Extracts session ID (UUID) from a filename
+ * @param filename - File name to extract session ID from
+ * @returns Extracted session ID or undefined if not found
+ */
+export function extractSessionId(filename: string): string | undefined {
+  // Claude session files are named <uuid>.jsonl — extract the UUID portion
+  const uuidPattern = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+  const match = filename.match(uuidPattern);
+  return match ? match[0] : undefined;
+}
+
+export async function getSessionFiles(projectPath: string): Promise<SessionFile[]> {
+  try {
+    const entries = await safeReaddir(projectPath);
+    if (!entries) return [];
+
+    const jsonlEntries = entries.filter(
+      (entry) => entry.isFile() && entry.name.endsWith(".jsonl") && extractSessionId(entry.name)
+    );
+
+    const settled = await batchAll(
+      jsonlEntries.map((entry) => async () => {
+        const filePath = join(projectPath, entry.name);
+        const mtime = await getMtime(filePath, entry.name);
+        return {
+          name: entry.name,
+          path: filePath,
+          lastModified: mtime,
+          lastModifiedFormatted: formatDate(mtime),
+          sessionId: extractSessionId(entry.name),
+        } as SessionFile;
+      }),
+      16,
+    );
+    const files = settled
+      .filter((r): r is PromiseFulfilledResult<SessionFile> => r.status === "fulfilled")
+      .map((r) => r.value);
+
+    files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    return files;
+  } catch (error) {
+    logError("Error reading session files:", error);
+    return [];
+  }
+}
+
+export const getCachedProjectFolders = runtimeCache(getProjectFolders, 30);
+
+export const getCachedSessionFiles = runtimeCache(
+  (projectPath: string) => getSessionFiles(projectPath),
+  30
+);

package/.next/standalone/lib/resolve-subagent-path.ts

@@ -0,0 +1,36 @@
+import { access } from "fs/promises";
+import { join, relative } from "path";
+
+/**
+ * Resolve a subagent log file path by trying candidate locations in priority order.
+ * Returns the file path that exists, or null if none found.
+ */
+export async function resolveSubagentPath(
+  projectsPath: string,
+  projectName: string,
+  sessionId: string,
+  agentId: string
+): Promise<string | null> {
+  const fileName = `agent-${agentId}.jsonl`;
+  const candidatePaths = [
+    join(projectsPath, projectName, fileName),
+    join(projectsPath, projectName, sessionId, fileName),
+    join(projectsPath, projectName, sessionId, "subagents", fileName),
+  ];
+
+  for (const candidatePath of candidatePaths) {
+    if (relative(projectsPath, candidatePath).startsWith("..")) {
+      continue;
+    }
+    try {
+      await access(candidatePath);
+      return candidatePath;
+    } catch (e) {
+      const code = (e as NodeJS.ErrnoException).code;
+      if (code === "ENOENT") continue; // file not found — try next candidate
+      break; // unexpected error (e.g., EACCES) — stop searching
+    }
+  }
+
+  return null;
+}

package/.next/standalone/lib/runtime-cache.ts

@@ -0,0 +1,59 @@
+/**
+ * Simple in-memory cache with TTL, used instead of Next.js `unstable_cache`.
+ *
+ * Next.js Data Cache writes results to .next/cache at build time and
+ * re-serves them indefinitely unless explicitly revalidated. Since our
+ * data comes from local JSONL files that change outside of Next.js,
+ * those stale build-time entries cause ghost data on first load.
+ *
+ * This in-process Map-based cache avoids that problem: entries expire
+ * after `revalidateSeconds` and are never persisted to disk.
+ *
+ * Optional `maxSize` enables LRU eviction — when the cache is full,
+ * the least-recently-used entry is evicted before inserting a new one.
+ */
+
+export interface RuntimeCacheOptions {
+  maxSize?: number;
+}
+
+export function runtimeCache<TArgs extends unknown[], TResult>(
+  fn: (...args: TArgs) => Promise<TResult>,
+  revalidateSeconds: number,
+  options?: RuntimeCacheOptions,
+): (...args: TArgs) => Promise<TResult> {
+  const cache = new Map<string, { data: TResult; expiry: number }>();
+  const inflight = new Map<string, Promise<TResult>>();
+  const maxSize = options?.maxSize;
+
+  return async (...args: TArgs): Promise<TResult> => {
+    const key = JSON.stringify(args);
+    const entry = cache.get(key);
+    if (entry && Date.now() < entry.expiry) {
+      return entry.data;
+    }
+
+    // Coalesce concurrent requests for the same uncached key
+    const existing = inflight.get(key);
+    if (existing) return existing;
+
+    const promise = fn(...args).then(
+      (data) => {
+        inflight.delete(key);
+        // Evict least-recently-used entry if at capacity
+        if (maxSize && cache.size >= maxSize) {
+          const oldestKey = cache.keys().next().value!;
+          cache.delete(oldestKey);
+        }
+        cache.set(key, { data, expiry: Date.now() + revalidateSeconds * 1000 });
+        return data;
+      },
+      (err) => {
+        inflight.delete(key);
+        throw err;
+      },
+    );
+    inflight.set(key, promise);
+    return promise;
+  };
+}

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

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { execSync } from "node:child_process";
+
+const NAMESPACE = "failproofai-telemetry-v1";
+const ID_DIR = path.join(os.homedir(), ".failproofai");
+const ID_FILE = path.join(ID_DIR, "instance-id");
+
+let cachedId: string | undefined;
+
+export function hashToId(raw: string): string {
+  return crypto.createHmac("sha256", NAMESPACE).update(raw).digest("hex");
+}
+
+export function getPlatformMachineId(): string | undefined {
+  try {
+    const platform = os.platform();
+    if (platform === "linux") {
+      for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+        try {
+          const id = fs.readFileSync(p, "utf-8").trim();
+          if (id) return id;
+        } catch {}
+      }
+    } else if (platform === "darwin") {
+      const out = execSync("ioreg -rd1 -c IOPlatformExpertDevice", {
+        encoding: "utf-8",
+        timeout: 3000,
+      });
+      const m = out.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (m?.[1]) return m[1];
+    } else if (platform === "win32") {
+      const out = execSync(
+        'reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid',
+        { encoding: "utf-8", timeout: 3000 },
+      );
+      const m = out.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
+      if (m?.[1]) return m[1];
+    }
+  } catch {}
+  return undefined;
+}
+
+export function getSystemPropertiesId(): string {
+  return [
+    os.hostname(),
+    os.homedir(),
+    os.platform(),
+    os.arch(),
+    os.cpus()[0]?.model ?? "",
+  ].join(":");
+}
+
+function getFileBasedId(): string {
+  try {
+    const existing = fs.readFileSync(ID_FILE, "utf-8").trim();
+    if (existing) return existing;
+  } catch {}
+  const id = crypto.randomUUID();
+  try {
+    fs.mkdirSync(ID_DIR, { recursive: true });
+    fs.writeFileSync(ID_FILE, id, "utf-8");
+  } catch {}
+  return id;
+}
+
+/**
+ * Returns a stable, anonymous machine ID for telemetry.
+ *
+ * Uses a 3-tier strategy:
+ * 1. OS-native machine ID (most stable — survives cache deletion)
+ * 2. Hashed system properties (fallback — less stable if hostname changes)
+ * 3. File-based random UUID at `~/.failproofai/instance-id` (final fallback)
+ *
+ * All raw values are HMAC-hashed with an app-specific namespace so no PII
+ * is transmitted. The result is cached in-process to avoid repeated I/O.
+ */
+export function getInstanceId(): string {
+  if (cachedId) return cachedId;
+
+  const machineId = getPlatformMachineId();
+  if (machineId) {
+    cachedId = hashToId(machineId);
+    return cachedId;
+  }
+
+  const sysProps = getSystemPropertiesId();
+  if (sysProps) {
+    cachedId = hashToId(sysProps);
+    return cachedId;
+  }
+
+  cachedId = getFileBasedId();
+  return cachedId;
+}

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

@@ -0,0 +1,148 @@
+/**
+ * Opt-out telemetry for Failproof AI.
+ *
+ * Set FAILPROOFAI_TELEMETRY_DISABLED=1 to disable all telemetry.
+ * When disabled every export is a zero-cost no-op.
+ *
+ * The PostHog API key is write-only (safe to commit).
+ * The client is stored on globalThis to survive Next.js HMR.
+ */
+
+import { getInstanceId } from "./telemetry-id";
+import { version } from "../package.json";
+import { POSTHOG_API_KEY } from "../src/posthog-key";
+
+const DEFAULT_API_KEY = POSTHOG_API_KEY;
+const DEFAULT_HOST = "https://us.i.posthog.com";
+
+declare global {
+  var __FAILPROOFAI_POSTHOG__: PostHogClient | undefined;
+}
+
+/** Minimal interface for the subset of PostHog we use. */
+interface PostHogClient {
+  capture(event: {
+    distinctId: string;
+    event: string;
+    properties?: Record<string, unknown>;
+  }): void;
+  flush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+
+interface PostHogOptions {
+  host: string;
+  flushAt: number;
+  flushInterval: number;
+  requestTimeout?: number;
+  fetchRetryCount?: number;
+  fetchRetryDelay?: number;
+  fetch?: (url: string, options: Record<string, unknown>) => Promise<Response>;
+}
+
+/**
+ * Wraps native fetch with retry logic and silent failure for non-critical telemetry.
+ * Prevents posthog-node's internal console.error from firing on network errors.
+ */
+async function resilientFetch(
+  url: string,
+  options: Record<string, unknown>,
+): Promise<Response> {
+  const MAX_ATTEMPTS = 5;
+  const BASE_DELAY_MS = 1000;
+  const TIMEOUT_MS = 5000;
+
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      const { signal: _, ...rest } = options;
+      const res = await fetch(url, {
+        ...(rest as RequestInit),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+      if (res.ok) return res;
+      // Non-2xx (e.g. 502) — treat like a transient failure and retry
+    } catch {
+      // Network error (ETIMEDOUT, etc.) — retry
+    }
+    if (attempt < MAX_ATTEMPTS) {
+      const delay = Math.min(BASE_DELAY_MS * 2 ** (attempt - 1), 8000);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  // All attempts failed — return fake OK so PostHog doesn't log errors.
+  // This is anonymous telemetry; silently dropping events is acceptable.
+  return new Response("{}", { status: 200 });
+}
+
+/** Returns true unless the user has explicitly opted out. */
+export function isTelemetryEnabled(): boolean {
+  return process.env.FAILPROOFAI_TELEMETRY_DISABLED !== "1";
+}
+
+/**
+ * Lazily import posthog-node and create a client.
+ * No-op when telemetry is disabled.
+ */
+export async function initTelemetry(): Promise<void> {
+  if (!isTelemetryEnabled()) return;
+  if (globalThis.__FAILPROOFAI_POSTHOG__) return;
+
+  try {
+    const mod: { PostHog: new (key: string, opts: PostHogOptions) => PostHogClient } =
+      await import("posthog-node");
+    const apiKey = process.env.FAILPROOFAI_POSTHOG_KEY ?? DEFAULT_API_KEY;
+    const host = process.env.FAILPROOFAI_POSTHOG_HOST ?? DEFAULT_HOST;
+    globalThis.__FAILPROOFAI_POSTHOG__ = new mod.PostHog(apiKey, {
+      host,
+      flushAt: 1,
+      flushInterval: 0,
+      requestTimeout: 5000,
+      fetchRetryCount: 0,
+      fetch: resilientFetch,
+    });
+
+    // Flush pending events when the process exits
+    const onExit = () => {
+      globalThis.__FAILPROOFAI_POSTHOG__?.shutdown().catch(() => {});
+    };
+    process.on("beforeExit", onExit);
+    process.on("SIGTERM", onExit);
+    process.on("SIGINT", onExit);
+  } catch (err) {
+    // Always log init failures — silent swallowing makes standalone debugging impossible
+    console.warn("[failproofai:telemetry] PostHog init failed:", err instanceof Error ? err.message : err);
+  }
+}
+
+/**
+ * Track a named event. No-op when telemetry is disabled or the client
+ * has not been initialised.
+ */
+export function trackEvent(
+  name: string,
+  properties?: Record<string, unknown>,
+): void {
+  if (!isTelemetryEnabled()) return;
+  const client = globalThis.__FAILPROOFAI_POSTHOG__;
+  if (!client) return;
+
+  client.capture({
+    distinctId: getInstanceId(),
+    event: name,
+    properties: { ...properties, $lib: "failproofai", failproofai_version: version },
+  });
+}
+
+/** Flush pending events without tearing down the client. */
+export async function flushTelemetry(): Promise<void> {
+  const client = globalThis.__FAILPROOFAI_POSTHOG__;
+  if (!client) return;
+  await client.flush();
+}
+
+/** Flush pending events and tear down the client. */
+export async function shutdownTelemetry(): Promise<void> {
+  const client = globalThis.__FAILPROOFAI_POSTHOG__;
+  if (!client) return;
+  await client.shutdown();
+}