failproofai 0.0.13 → 0.0.14-beta.1

package/scripts/postinstall.mjs

@@ -1,243 +0,0 @@
-#!/usr/bin/env node
-/**
- * postinstall script for the failproofai package.
- *
- * 1. Warns if hooks config exists but hooks are missing from Claude Code settings.
- * 2. Tracks a package_installed telemetry event.
- *
- * No external dependencies — Node.js built-ins only.
- */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { resolve } from "node:path";
-import { platform, arch, release, homedir, hostname } from "node:os";
-import { createHmac } from "node:crypto";
-import { trackInstallEvent } from "./install-telemetry.mjs";
-import { diagnoseShadow } from "./install-diagnosis.mjs";
-
-// Skip when running in development context (e.g. `bun install` in the source repo).
-// INIT_CWD is set by npm/bun to the directory where install was invoked; it differs
-// from process.cwd() only when we are being installed as a dependency by someone else.
-if (!process.env.INIT_CWD || process.env.INIT_CWD === process.cwd()) process.exit(0);
-
-// Verify server.js exists — fail the install early if the dashboard build is missing.
-const serverJsPath = resolve(process.cwd(), ".next", "standalone", "server.js");
-if (!existsSync(serverJsPath)) {
-  console.error(
-    `\n[failproofai] Error: server.js not found at:\n  ${serverJsPath}\n\n` +
-    `  The package may not have been built correctly.\n` +
-    `  Try reinstalling: npm install -g failproofai@latest\n`
-  );
-  // Await so the event lands before process.exit(1) kills the in-flight fetch —
-  // a failed install is exactly the signal we most want and would otherwise lose.
-  await trackInstallEvent("package_install_failed", {
-    reason: "server_js_missing",
-    platform: platform(),
-    arch: arch(),
-    node_version: process.versions.node,
-  }).catch(() => {});
-  process.exit(1);
-}
-
-// Detect when an older `failproofai` is shadowing this fresh install on PATH —
-// classic case is a leftover `bun link` from a prior dev session, or a
-// `bun install -g` whose ~/.bun/bin sorts ahead of npm's prefix. Without this
-// warning the user only finds out later via a confusing runtime error from
-// scripts/launch.ts pointing at the *old* install's missing build output.
-try {
-  let selfVersion = null;
-  try {
-    selfVersion = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf8")).version ?? null;
-  } catch {}
-  const diag = diagnoseShadow({ selfPackageRoot: process.cwd(), selfVersion });
-  if (diag.shadowed) {
-    console.warn(
-      `\n[failproofai] Warning: another failproofai install is earlier on your PATH.\n` +
-      `  Just installed: ${diag.selfPackageRoot}` + (diag.selfVersion ? `  (v${diag.selfVersion})` : "") + `\n` +
-      `  PATH resolves : ${diag.pathFirstPath}` + (diag.pathFirstVersion ? `  (v${diag.pathFirstVersion})` : "") + `\n\n` +
-      `  Your shell will run the older copy. Remove the shadow with:\n` +
-      `    ${diag.recommendation}\n`
-    );
-  }
-} catch {
-  // Diagnosis is best-effort — never fail the install over a warning.
-}
-
-const FAILPROOFAI_HOOK_MARKER = "__failproofai_hook__";
-const NAMESPACE = "failproofai-telemetry-v1";
-
-function hashToId(raw) {
-  return createHmac("sha256", NAMESPACE).update(raw).digest("hex");
-}
-
-/**
- * Returns the current hooks configuration state.
- * @returns {{ configured: boolean, registered: boolean, policyCount: number }}
- */
-function checkHooks() {
-  const hooksConfigPath = resolve(homedir(), ".failproofai", "policies-config.json");
-  if (!existsSync(hooksConfigPath)) {
-    return { configured: false, registered: false, policyCount: 0 };
-  }
-
-  let config;
-  try {
-    config = JSON.parse(readFileSync(hooksConfigPath, "utf8"));
-  } catch {
-    return { configured: false, registered: false, policyCount: 0 };
-  }
-
-  if (!Array.isArray(config.enabledPolicies) || config.enabledPolicies.length === 0) {
-    return { configured: false, registered: false, policyCount: 0 };
-  }
-
-  const policyCount = config.enabledPolicies.length;
-
-  // Check if Claude Code settings have failproofai hooks
-  const settingsPath = resolve(homedir(), ".claude", "settings.json");
-  if (!existsSync(settingsPath)) {
-    printHooksWarning();
-    return { configured: true, registered: false, policyCount };
-  }
-
-  let settings;
-  try {
-    settings = JSON.parse(readFileSync(settingsPath, "utf8"));
-  } catch {
-    printHooksWarning();
-    return { configured: true, registered: false, policyCount };
-  }
-
-  if (!settings.hooks) {
-    printHooksWarning();
-    return { configured: true, registered: false, policyCount };
-  }
-
-  // Walk settings.hooks looking for failproofai entries
-  for (const matchers of Object.values(settings.hooks)) {
-    if (!Array.isArray(matchers)) continue;
-    for (const matcher of matchers) {
-      if (!matcher.hooks) continue;
-      if (matcher.hooks.some((h) => h[FAILPROOFAI_HOOK_MARKER] === true)) {
-        return { configured: true, registered: true, policyCount };
-      }
-    }
-  }
-
-  printHooksWarning();
-  return { configured: true, registered: false, policyCount };
-}
-
-function printHooksWarning() {
-  console.log(
-    `\n[failproofai] Warning: hooks config exists with enabled policies, but hooks are not registered in Claude Code settings.\n` +
-    `  To re-register hooks, run:\n` +
-    `    failproofai policies --uninstall && failproofai policies --install\n`
-  );
-}
-
-let hooksResult = { configured: false, registered: false, policyCount: 0 };
-try {
-  hooksResult = checkHooks();
-} catch {
-  // Non-critical — don't fail the install
-}
-
-if (!hooksResult.configured && !hooksResult.registered) {
-  console.log(
-    `\n[failproofai] Installed. Next steps:\n` +
-    `  1. Run \`failproofai policies --install\` to enable safety policies.\n` +
-    `  2. Run \`failproofai\` to open the dashboard (or just \`failproofai\` to start now — it'll offer to set up policies for you).\n` +
-    `  Disable first-run prompt: FAILPROOFAI_NO_FIRST_RUN=1\n`
-  );
-}
-
-// First-run + version_changed detection. The presence of ~/.failproofai/last-version
-// is a stable signal: written on every postinstall, absent before the first one.
-// Cannot piggy-back on instance-id because most users hit Tier 2 (OS machine ID)
-// and never create that file.
-//
-// Semver comparison: a release (no prerelease tag) is greater than the same
-// version with a prerelease tag (semver §11). Inside the prerelease, numeric
-// identifiers are lower than non-numeric ones of the same length.
-function compareSemver(a, b) {
-  const parse = (v) => {
-    const m = /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/.exec(v);
-    if (!m) return null;
-    return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ?? null };
-  };
-  const pa = parse(a);
-  const pb = parse(b);
-  if (!pa || !pb) return a < b ? -1 : a > b ? 1 : 0;
-  for (let i = 0; i < 3; i++) {
-    if (pa.nums[i] !== pb.nums[i]) return pa.nums[i] < pb.nums[i] ? -1 : 1;
-  }
-  if (pa.pre === null && pb.pre === null) return 0;
-  if (pa.pre === null) return 1;
-  if (pb.pre === null) return -1;
-  const ax = pa.pre.split(/[.-]/);
-  const bx = pb.pre.split(/[.-]/);
-  for (let i = 0; i < Math.max(ax.length, bx.length); i++) {
-    const ai = ax[i], bi = bx[i];
-    if (ai === undefined) return -1;
-    if (bi === undefined) return 1;
-    const aNum = /^\d+$/.test(ai), bNum = /^\d+$/.test(bi);
-    if (aNum && bNum) {
-      const d = Number(ai) - Number(bi);
-      if (d !== 0) return d < 0 ? -1 : 1;
-    } else if (aNum) {
-      return -1;
-    } else if (bNum) {
-      return 1;
-    } else if (ai !== bi) {
-      return ai < bi ? -1 : 1;
-    }
-  }
-  return 0;
-}
-
-const currentVersion = process.env.npm_package_version ?? "unknown";
-const lastVersionFile = resolve(homedir(), ".failproofai", "last-version");
-let previousVersion = null;
-try {
-  if (existsSync(lastVersionFile)) {
-    previousVersion = readFileSync(lastVersionFile, "utf8").trim() || null;
-  }
-} catch {}
-
-if (previousVersion === null) {
-  trackInstallEvent("first_install", {
-    platform: platform(),
-    arch: arch(),
-    os_release: release(),
-    node_version: process.versions.node,
-    // `version` is carried automatically as `failproofai_version` — no explicit dup.
-  }).catch(() => {});
-} else {
-  // Same version is a reinstall — still worth tracking; users hitting `npm install -g`
-  // repeatedly is itself signal. Drop the `!==` guard so cmp===0 reaches the event.
-  const cmp = compareSemver(previousVersion, currentVersion);
-  trackInstallEvent("version_changed", {
-    from_version: previousVersion,
-    to_version: currentVersion,
-    direction: cmp < 0 ? "upgrade" : cmp > 0 ? "downgrade" : "reinstall",
-    platform: platform(),
-    arch: arch(),
-  }).catch(() => {});
-}
-
-try {
-  mkdirSync(resolve(homedir(), ".failproofai"), { recursive: true });
-  writeFileSync(lastVersionFile, currentVersion, "utf8");
-} catch {}
-
-// Telemetry (best-effort, fire-and-forget)
-trackInstallEvent("package_installed", {
-  platform: platform(),
-  arch: arch(),
-  os_release: release(),
-  node_version: process.versions.node,
-  hostname_hash: hashToId(hostname()),
-  hooks_configured: hooksResult.configured,
-  hooks_registered: hooksResult.registered,
-  enabled_policy_count: hooksResult.policyCount,
-}).catch(() => {});

package/scripts/preuninstall.mjs

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-/**
- * preuninstall script for the failproofai package.
- *
- * Removes failproofai hook entries from all reachable Claude Code settings files:
- *   - ~/.claude/settings.json            (user scope — always attempted)
- *   - {cwd}/.claude/settings.json        (project scope — if it exists)
- *   - {cwd}/.claude/settings.local.json  (local scope — if it exists)
- *
- * Does NOT delete ~/.failproofai/ (preserves cache, hooks-config, instance-id).
- *
- * Never exits non-zero — uninstall must not be blocked by cleanup failures.
- * No external dependencies — Node.js built-ins only.
- */
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { homedir, platform, arch } from "node:os";
-import { trackInstallEvent } from "./install-telemetry.mjs";
-
-// Skip when running in development context (same guard as postinstall.mjs).
-if (process.env.INIT_CWD && process.env.INIT_CWD === process.cwd()) process.exit(0);
-
-const FAILPROOFAI_HOOK_MARKER = "__failproofai_hook__";
-
-/**
- * Remove all failproofai-marked hook entries from a single settings file.
- * Returns the number of hook entries removed.
- * Writes the file only when at least one hook was removed.
- */
-function removeHooksFromFile(settingsPath) {
-  if (!existsSync(settingsPath)) return 0;
-
-  let settings;
-  try {
-    settings = JSON.parse(readFileSync(settingsPath, "utf8"));
-  } catch {
-    return 0; // Corrupt or unreadable — nothing to do
-  }
-
-  if (!settings?.hooks) return 0;
-
-  let hooksRemoved = 0;
-
-  for (const eventType of Object.keys(settings.hooks)) {
-    const matchers = settings.hooks[eventType];
-    if (!Array.isArray(matchers)) continue;
-
-    for (let i = matchers.length - 1; i >= 0; i--) {
-      const matcher = matchers[i];
-      if (!matcher.hooks) continue;
-
-      const before = matcher.hooks.length;
-      matcher.hooks = matcher.hooks.filter((h) => {
-        if (h[FAILPROOFAI_HOOK_MARKER] === true) return false; // marked entry
-        // Fallback for legacy installs that predate the marker
-        const cmd = typeof h.command === "string" ? h.command : "";
-        if (cmd.includes("failproofai") && cmd.includes("--hook")) return false;
-        return true;
-      });
-      hooksRemoved += before - matcher.hooks.length;
-
-      // Remove now-empty matchers
-      if (matcher.hooks.length === 0) {
-        matchers.splice(i, 1);
-      }
-    }
-
-    // Remove now-empty event type arrays
-    if (matchers.length === 0) {
-      delete settings.hooks[eventType];
-    }
-  }
-
-  // Remove now-empty hooks object
-  if (Object.keys(settings.hooks).length === 0) {
-    delete settings.hooks;
-  }
-
-  if (hooksRemoved > 0) {
-    try {
-      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
-    } catch {
-      // Best-effort — don't block uninstall
-    }
-  }
-
-  return hooksRemoved;
-}
-
-let totalRemoved = 0;
-
-try {
-  const home = homedir();
-  const projectCwd = process.cwd();
-
-  // Build list of settings files to clean, deduped in case cwd === home
-  const candidates = [
-    resolve(home, ".claude", "settings.json"),              // user scope
-    resolve(projectCwd, ".claude", "settings.json"),        // project scope
-    resolve(projectCwd, ".claude", "settings.local.json"),  // local scope
-  ];
-  const seen = new Set();
-  const settingsPaths = candidates.filter((p) => {
-    if (seen.has(p)) return false;
-    seen.add(p);
-    return true;
-  });
-
-  for (const settingsPath of settingsPaths) {
-    const removed = removeHooksFromFile(settingsPath);
-    if (removed > 0) {
-      console.log(`[failproofai] Removed ${removed} hook(s) from ${settingsPath}.`);
-      totalRemoved += removed;
-    }
-  }
-
-  if (totalRemoved === 0) {
-    console.log("[failproofai] No hook entries found to remove.");
-  }
-} catch {
-  // Never block uninstall
-}
-
-// Telemetry — best-effort, awaited so the process stays alive long enough to send
-try {
-  await trackInstallEvent("package_uninstalled", {
-    platform: platform(),
-    arch: arch(),
-    hooks_removed: totalRemoved,
-  });
-} catch {}

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

@@ -1,51 +0,0 @@
-/**
- * Gemini CLI transcript adapter.
- */
-import { statSync } from "node:fs";
-import { getGeminiProjects, getGeminiSessionsByEncodedName } from "../../../lib/gemini-projects";
-import { getGeminiSessionLog } from "../../../lib/gemini-sessions";
-import type { NormalizedToolEvent, TranscriptMetadata } from "../types";
-import type { ListOpts } from "./claude";
-import { logEntriesToEvents } from "./shared";
-
-export async function listGeminiTranscriptMetadata(
-  opts: ListOpts = {},
-): Promise<TranscriptMetadata[]> {
-  const projectFilter = opts.projects ? new Set(opts.projects) : null;
-  const sinceMs = opts.sinceMs ?? 0;
-  const out: TranscriptMetadata[] = [];
-
-  const projects = await getGeminiProjects();
-  for (const project of projects) {
-    const { cwd, sessions } = await getGeminiSessionsByEncodedName(project.name);
-    const effectiveCwd = cwd ?? "";
-    if (projectFilter && !projectFilter.has(effectiveCwd)) continue;
-    for (const s of sessions) {
-      const mtimeMs = s.lastModified.getTime();
-      if (mtimeMs < sinceMs) continue;
-      let sizeBytes = 0;
-      try { sizeBytes = statSync(s.path).size; } catch { /* unreadable */ }
-      if (!s.sessionId) continue;
-      out.push({
-        cli: "gemini",
-        projectName: project.name,
-        sessionId: s.sessionId,
-        transcriptPath: s.path,
-        mtimeMs,
-        sizeBytes,
-      });
-    }
-  }
-  return out;
-}
-
-export async function streamGeminiEvents(meta: TranscriptMetadata): Promise<NormalizedToolEvent[]> {
-  const log = await getGeminiSessionLog(meta.sessionId);
-  if (!log) return [];
-  return logEntriesToEvents(log.entries, {
-    cli: "gemini",
-    sessionId: meta.sessionId,
-    transcriptPath: meta.transcriptPath,
-    cwd: log.cwd ?? "",
-  });
-}

package/src/hooks/first-run-nudge.ts

@@ -1,146 +0,0 @@
-/**
- * First-run nudge for `failproofai` (no-args invocation).
- *
- * Fires when a user runs the bare CLI without having installed any policies on
- * any detected agent CLI. PostHog data showed only ~10% of npm-installed users
- * ran `failproofai policies --install`; this prompt closes the awareness gap
- * by offering to run that install inline.
- *
- * The hooks themselves are the sentinel — if any are installed for any
- * detected CLI, we never prompt again. No separate state file needed.
- *
- * Honors `FAILPROOFAI_NO_FIRST_RUN=1` for opt-out, falls back to a short
- * stderr hint in non-TTY contexts (CI, piped invocations).
- */
-import * as readline from "node:readline";
-
-import { detectInstalledClis, getIntegration } from "./integrations";
-import { installHooks } from "./manager";
-import { trackHookEvent } from "./hook-telemetry";
-import { getInstanceId } from "../../lib/telemetry-id";
-import type { IntegrationType } from "./types";
-
-type TTYIn = NodeJS.ReadableStream & { isTTY?: boolean };
-type TTYOut = NodeJS.WritableStream & { isTTY?: boolean };
-
-export interface FirstRunNudgeOptions {
-  stdin?: TTYIn;
-  stdout?: TTYOut;
-}
-
-async function emit(event: string, props: Record<string, unknown>): Promise<void> {
-  try {
-    await trackHookEvent(getInstanceId(), event, props);
-  } catch {
-    // Telemetry must never break first-run UX.
-  }
-}
-
-function anyHooksInstalled(detected: IntegrationType[]): boolean {
-  for (const id of detected) {
-    const integration = getIntegration(id);
-    for (const scope of integration.scopes) {
-      try {
-        if (integration.hooksInstalledInSettings(scope)) return true;
-      } catch {
-        // A broken settings file shouldn't suppress the nudge.
-      }
-    }
-  }
-  return false;
-}
-
-function clisLabel(detected: IntegrationType[]): string {
-  return detected.map((id) => getIntegration(id).displayName).join(", ");
-}
-
-async function promptYesNo(
-  stdin: TTYIn,
-  stdout: TTYOut,
-): Promise<"yes" | "no" | "sigint"> {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: stdin, output: stdout });
-    let settled = false;
-    const finish = (answer: "yes" | "no" | "sigint") => {
-      if (settled) return;
-      settled = true;
-      rl.close();
-      resolve(answer);
-    };
-    rl.on("SIGINT", () => finish("sigint"));
-    rl.question("Install policies now? [Y/n] ", (raw) => {
-      const a = (raw ?? "").trim().toLowerCase();
-      if (a === "" || a === "y" || a === "yes") finish("yes");
-      else finish("no");
-    });
-  });
-}
-
-export async function maybeRunFirstRunNudge(opts: FirstRunNudgeOptions = {}): Promise<void> {
-  if (process.env.FAILPROOFAI_NO_FIRST_RUN === "1") return;
-
-  const stdin: TTYIn = opts.stdin ?? process.stdin;
-  const stdout: TTYOut = opts.stdout ?? process.stdout;
-
-  let detected: IntegrationType[];
-  try {
-    detected = detectInstalledClis();
-  } catch {
-    return;
-  }
-  if (detected.length === 0) return;
-
-  if (anyHooksInstalled(detected)) return;
-
-  const detectedProps = { detected_clis: detected, detected_count: detected.length };
-
-  if (!stdin.isTTY || !stdout.isTTY) {
-    stdout.write(
-      `\n[failproofai] No policies are installed. Run \`failproofai policies --install\` to set them up.\n` +
-        `[failproofai] Launching dashboard…\n\n`,
-    );
-    await emit("first_run_nudge_skipped_noninteractive", detectedProps);
-    return;
-  }
-
-  stdout.write(
-    `\n┌─ Failproof AI — first-run setup ────────────────────────────────────\n` +
-      `│  Detected agent CLI(s): ${clisLabel(detected)}\n` +
-      `│  Policies block unsafe actions (sudo, rm -rf /, secret leaks, …)\n` +
-      `│  before your agent runs them. Nothing is installed yet.\n` +
-      `└──────────────────────────────────────────────────────────────────────\n\n` +
-      `  Disable this prompt anytime: FAILPROOFAI_NO_FIRST_RUN=1\n\n`,
-  );
-
-  await emit("first_run_nudge_shown", detectedProps);
-
-  const answer = await promptYesNo(stdin, stdout);
-
-  if (answer === "sigint") {
-    await emit("first_run_nudge_declined", { ...detectedProps, reason: "sigint" });
-    process.exit(130);
-  }
-
-  if (answer === "no") {
-    await emit("first_run_nudge_declined", { ...detectedProps, reason: "user_no" });
-    return;
-  }
-
-  await emit("first_run_nudge_accepted", {
-    ...detectedProps,
-    target_scope: "user",
-    source: "first-run-nudge",
-  });
-
-  await installHooks(
-    undefined,
-    "user",
-    undefined,
-    false,
-    "first-run-nudge",
-    undefined,
-    false,
-    detected,
-  );
-  process.exit(0);
-}