failproofai 0.0.2-beta.8 → 0.0.2-beta.9

package/scripts/translate-docs/mdx-translator.ts

@@ -0,0 +1,153 @@
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getLanguageByCode } from "./config";
+import { translateContent } from "./translator";
+import {
+  readCache,
+  writeCache,
+  isCached,
+  setCacheEntry,
+} from "./cache";
+import type { TranslationResult, TranslationCache } from "./types";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DOCS_DIR = join(__dirname, "..", "..", "docs");
+
+/**
+ * Rewrite internal doc links to include the language prefix.
+ * e.g. href="/built-in-policies" -> href="/es/built-in-policies"
+ *      [Getting started](/getting-started) -> [Getting started](/es/getting-started)
+ */
+export function rewriteInternalLinks(
+  content: string,
+  lang: string,
+): string {
+  // Rewrite MDX component href attributes pointing to internal paths
+  let result = content.replace(
+    /href="(\/[^"]*?)"/g,
+    (_match, path: string) => {
+      // Skip external URLs and anchors
+      if (path.startsWith("/http") || path === "/") return `href="${path}"`;
+      return `href="/${lang}${path}"`;
+    },
+  );
+
+  // Rewrite Markdown links with internal paths
+  result = result.replace(
+    /\]\((\/[^)]*?)\)/g,
+    (_match, path: string) => {
+      if (path.startsWith("/http") || path === "/") return `](${path})`;
+      return `](/${lang}${path})`;
+    },
+  );
+
+  return result;
+}
+
+/**
+ * Translate a single MDX doc page for a given language.
+ */
+export async function translateMdxPage(
+  sourcePath: string,
+  lang: string,
+  options: { force?: boolean; dryRun?: boolean; model?: string; cache?: TranslationCache } = {},
+): Promise<TranslationResult> {
+  const relPath = relative(DOCS_DIR, sourcePath);
+  const outputPath = join(DOCS_DIR, lang, relPath);
+  const sourceContent = readFileSync(sourcePath, "utf-8");
+
+  const langConfig = getLanguageByCode(lang);
+  if (!langConfig) throw new Error(`Unknown language: ${lang}`);
+
+  // Check cache — use provided cache object or read from disk
+  if (!options.force && !options.dryRun) {
+    const cache = options.cache ?? readCache();
+    if (isCached(cache, relPath, lang, sourceContent)) {
+      return {
+        lang,
+        sourcePath,
+        outputPath,
+        inputTokens: 0,
+        outputTokens: 0,
+        cached: true,
+      };
+    }
+  }
+
+  if (options.dryRun) {
+    return {
+      lang,
+      sourcePath,
+      outputPath,
+      inputTokens: 0,
+      outputTokens: 0,
+      cached: false,
+    };
+  }
+
+  // Translate
+  const { translated, inputTokens, outputTokens } = await translateContent(
+    sourceContent,
+    lang,
+    langConfig.name,
+    options.model,
+  );
+
+  // Rewrite internal links
+  const withLinks = rewriteInternalLinks(translated, lang);
+
+  // Write output
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, withLinks);
+
+  // Update cache — skip if caller manages the cache (batch write)
+  if (!options.cache) {
+    const cache = readCache();
+    setCacheEntry(cache, relPath, lang, sourceContent, inputTokens, outputTokens);
+    writeCache(cache);
+  }
+
+  return {
+    lang,
+    sourcePath,
+    outputPath,
+    inputTokens,
+    outputTokens,
+    cached: false,
+  };
+}
+
+/**
+ * Get all MDX page paths from the docs directory (English only, no language subdirs).
+ */
+export function getEnglishMdxPages(): string[] {
+  const results: string[] = [];
+
+  function walk(dir: string, prefix: string = "") {
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry);
+      const rel = prefix ? `${prefix}/${entry}` : entry;
+      if (statSync(full).isDirectory()) {
+        // Skip language directories at the top level
+        if (!prefix && isLanguageDir(entry)) continue;
+        // Skip non-doc directories like logo, i18n
+        if (!prefix && (entry === "logo" || entry === "i18n")) continue;
+        walk(full, rel);
+      } else if (entry.endsWith(".mdx")) {
+        results.push(full);
+      }
+    }
+  }
+
+  walk(DOCS_DIR);
+  return results.sort();
+}
+
+function isLanguageDir(name: string): boolean {
+  const langCodes = [
+    "zh", "ja", "ko", "es", "pt-br", "de", "fr",
+    "ru", "hi", "tr", "vi", "it", "ar", "he",
+  ];
+  return langCodes.includes(name);
+}

package/scripts/translate-docs/mintlify-nav.ts

@@ -0,0 +1,107 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { NAV_TRANSLATIONS, LANGUAGES } from "./config";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DOCS_JSON_PATH = join(__dirname, "..", "..", "docs", "docs.json");
+
+interface NavGroup {
+  group: string;
+  pages: string[];
+}
+
+interface NavTab {
+  tab: string;
+  groups: NavGroup[];
+}
+
+interface LanguageNav {
+  language: string;
+  tabs: NavTab[];
+}
+
+/**
+ * Build a navigation entry for a specific language by transforming the
+ * English navigation structure.
+ */
+export function buildLanguageNav(
+  englishTabs: NavTab[],
+  lang: string,
+): LanguageNav {
+  const t = NAV_TRANSLATIONS[lang];
+  if (!t) throw new Error(`No nav translations for language: ${lang}`);
+
+  const groupNameMap: Record<string, string> = {
+    "Getting Started": t.gettingStarted,
+    "Core Concepts": t.coreConcepts,
+    CLI: t.cli,
+    Tools: t.tools,
+    Advanced: t.advanced,
+    Examples: t.examples,
+  };
+
+  const tabNameMap: Record<string, string> = {
+    Docs: t.docs,
+    Examples: t.examples,
+  };
+
+  const tabs: NavTab[] = englishTabs.map((tab) => ({
+    tab: tabNameMap[tab.tab] || tab.tab,
+    groups: tab.groups.map((group) => ({
+      group: groupNameMap[group.group] || group.group,
+      pages: group.pages.map((page) => `${lang}/${page}`),
+    })),
+  }));
+
+  return { language: lang, tabs };
+}
+
+/**
+ * Read the current docs.json config.
+ */
+export function readDocsConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(DOCS_JSON_PATH, "utf-8"));
+}
+
+/**
+ * Generate the full languages array for docs.json from the English nav
+ * and a list of language codes.
+ */
+export function generateLanguagesArray(
+  englishTabs: NavTab[],
+  langCodes: string[],
+): LanguageNav[] {
+  // English first (default)
+  const english: LanguageNav = { language: "en", tabs: englishTabs };
+  const others = langCodes.map((code) => buildLanguageNav(englishTabs, code));
+  return [english, ...others];
+}
+
+/**
+ * Update docs.json to use the languages array structure.
+ */
+export function updateDocsJson(langCodes: string[]): void {
+  const config = readDocsConfig();
+  const nav = config.navigation as Record<string, unknown>;
+
+  // Extract existing English tabs
+  const englishTabs = nav.tabs as NavTab[];
+  if (!englishTabs) {
+    throw new Error("docs.json navigation.tabs not found — is this already using the languages format?");
+  }
+
+  // Build languages array
+  const languages = generateLanguagesArray(englishTabs, langCodes);
+
+  // Replace tabs with languages, preserve global
+  const newNav: Record<string, unknown> = {
+    languages,
+  };
+  if (nav.global) {
+    newNav.global = nav.global;
+  }
+
+  config.navigation = newNav;
+  writeFileSync(DOCS_JSON_PATH, JSON.stringify(config, null, 2) + "\n");
+}

package/scripts/translate-docs/readme-translator.ts

@@ -0,0 +1,154 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { LANGUAGES, getLanguageByCode } from "./config";
+import { translateContent } from "./translator";
+import { readCache, writeCache, isCached, setCacheEntry } from "./cache";
+import type { TranslationResult, TranslationCache } from "./types";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = join(__dirname, "..", "..");
+const README_PATH = join(ROOT_DIR, "README.md");
+const I18N_DIR = join(ROOT_DIR, "docs", "i18n");
+
+function buildLanguageSelector(currentLang: string): string {
+  const flags: Record<string, string> = {
+    en: "\ud83c\uddfa\ud83c\uddf8",
+    zh: "\ud83c\udde8\ud83c\uddf3",
+    ja: "\ud83c\uddef\ud83c\uddf5",
+    ko: "\ud83c\uddf0\ud83c\uddf7",
+    es: "\ud83c\uddea\ud83c\uddf8",
+    "pt-br": "\ud83c\udde7\ud83c\uddf7",
+    de: "\ud83c\udde9\ud83c\uddea",
+    fr: "\ud83c\uddeb\ud83c\uddf7",
+    ru: "\ud83c\uddf7\ud83c\uddfa",
+    hi: "\ud83c\uddee\ud83c\uddf3",
+    tr: "\ud83c\uddf9\ud83c\uddf7",
+    vi: "\ud83c\uddfb\ud83c\uddf3",
+    it: "\ud83c\uddee\ud83c\uddf9",
+    ar: "\ud83c\uddf8\ud83c\udde6",
+    he: "\ud83c\uddee\ud83c\uddf1",
+  };
+
+  const links: string[] = [];
+
+  // English link (to root README)
+  if (currentLang !== "en") {
+    links.push(`[${flags.en} English](../../README.md)`);
+  }
+
+  for (const lang of LANGUAGES) {
+    const flag = flags[lang.code] || "";
+    if (lang.code === currentLang) {
+      links.push(`**${flag} ${lang.nativeName}**`);
+    } else {
+      links.push(`[${flag} ${lang.nativeName}](README.${lang.code}.md)`);
+    }
+  }
+
+  return links.join(" | ");
+}
+
+export async function translateReadme(
+  lang: string,
+  options: { force?: boolean; dryRun?: boolean; model?: string; cache?: TranslationCache } = {},
+): Promise<TranslationResult> {
+  const outputPath = join(I18N_DIR, `README.${lang}.md`);
+  const sourceContent = readFileSync(README_PATH, "utf-8");
+
+  const langConfig = getLanguageByCode(lang);
+  if (!langConfig) throw new Error(`Unknown language: ${lang}`);
+
+  // Check cache — use provided cache object or read from disk
+  if (!options.force && !options.dryRun) {
+    const cache = options.cache ?? readCache();
+    if (isCached(cache, "README.md", lang, sourceContent)) {
+      return {
+        lang,
+        sourcePath: README_PATH,
+        outputPath,
+        inputTokens: 0,
+        outputTokens: 0,
+        cached: true,
+      };
+    }
+  }
+
+  if (options.dryRun) {
+    return {
+      lang,
+      sourcePath: README_PATH,
+      outputPath,
+      inputTokens: 0,
+      outputTokens: 0,
+      cached: false,
+    };
+  }
+
+  // Translate
+  const { translated, inputTokens, outputTokens } = await translateContent(
+    sourceContent,
+    lang,
+    langConfig.name,
+    options.model,
+  );
+
+  // Build the final output with header
+  const disclaimer = langConfig.rtl
+    ? `> **\u26a0\ufe0f** \u0647\u0630\u0647 \u062a\u0631\u062c\u0645\u0629 \u0622\u0644\u064a\u0629. \u0644\u0644\u0627\u0637\u0644\u0627\u0639 \u0639\u0644\u0649 \u0623\u062d\u062f\u062b \u0625\u0635\u062f\u0627\u0631\u060c \u0631\u0627\u062c\u0639 [English README](../../README.md).`
+    : `> **\u26a0\ufe0f** This is an auto-generated translation. For the latest version, see the [English README](../../README.md). Community corrections welcome!`;
+
+  const langSelector = buildLanguageSelector(lang);
+  const rtlOpen = langConfig.rtl ? `<div dir="rtl">\n\n` : "";
+  const rtlClose = langConfig.rtl ? `\n\n</div>` : "";
+
+  const output = `${disclaimer}\n\n${langSelector}\n\n---\n${rtlOpen}\n${translated}\n${rtlClose}`;
+
+  // Write output
+  mkdirSync(I18N_DIR, { recursive: true });
+  writeFileSync(outputPath, output);
+
+  // Update cache — skip if caller manages the cache (batch write)
+  if (!options.cache) {
+    const cache = readCache();
+    setCacheEntry(cache, "README.md", lang, sourceContent, inputTokens, outputTokens);
+    writeCache(cache);
+  }
+
+  return {
+    lang,
+    sourcePath: README_PATH,
+    outputPath,
+    inputTokens,
+    outputTokens,
+    cached: false,
+  };
+}
+
+/**
+ * Build the language selector line to add to the main README.
+ */
+export function buildMainReadmeLanguageLinks(): string {
+  const flags: Record<string, string> = {
+    zh: "\ud83c\udde8\ud83c\uddf3",
+    ja: "\ud83c\uddef\ud83c\uddf5",
+    ko: "\ud83c\uddf0\ud83c\uddf7",
+    es: "\ud83c\uddea\ud83c\uddf8",
+    "pt-br": "\ud83c\udde7\ud83c\uddf7",
+    de: "\ud83c\udde9\ud83c\uddea",
+    fr: "\ud83c\uddeb\ud83c\uddf7",
+    ru: "\ud83c\uddf7\ud83c\uddfa",
+    hi: "\ud83c\uddee\ud83c\uddf3",
+    tr: "\ud83c\uddf9\ud83c\uddf7",
+    vi: "\ud83c\uddfb\ud83c\uddf3",
+    it: "\ud83c\uddee\ud83c\uddf9",
+    ar: "\ud83c\uddf8\ud83c\udde6",
+    he: "\ud83c\uddee\ud83c\uddf1",
+  };
+
+  const links = LANGUAGES.map(
+    (l) => `[${flags[l.code] || ""} ${l.nativeName}](docs/i18n/README.${l.code}.md)`,
+  );
+
+  return `**Translations**: ${links.join(" | ")}`;
+}

package/scripts/translate-docs/translator.ts

@@ -0,0 +1,68 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { DO_NOT_TRANSLATE } from "./config";
+
+let client: Anthropic | null = null;
+
+function getClient(): Anthropic {
+  if (!client) {
+    client = new Anthropic();
+  }
+  return client;
+}
+
+const SYSTEM_PROMPT = `You are a professional technical documentation translator. Your task is to translate documentation content precisely and naturally into the target language.
+
+## Rules
+
+1. **Preserve all code blocks exactly as-is** — never translate content inside backtick-fenced code blocks (\`\`\`...\`\`\`) or inline code (\`...\`).
+2. **Preserve MDX component syntax** — tags like <Card>, <CardGroup>, <CodeGroup>, <Steps>, <Step>, <Note>, <Tip>, <Tabs>, <Tab>, <Warning> must remain unchanged. Their attribute names (title, icon, href, cols) must remain in English. Only translate the text content of the \`title\` attribute and the text body between tags.
+3. **Preserve YAML frontmatter keys** — only translate the string values of \`title\` and \`description\`. Keep the \`icon\` value unchanged.
+4. **Preserve all URLs and paths** — never modify href values, image paths, or links.
+5. **Preserve Markdown structure** — headers (#, ##), lists (-, *), tables (|), bold (**), italic (*), links ([text](url)) must keep their Markdown formatting.
+6. **Preserve badge/shield URLs** — any [![...](https://img.shields.io/...)](url) pattern must remain completely unchanged.
+
+## Do-not-translate list
+
+The following terms must NEVER be translated — keep them exactly as-is in the output:
+${DO_NOT_TRANSLATE.map((t) => `- ${t}`).join("\n")}
+
+## Translation quality
+
+- Use natural, idiomatic phrasing in the target language — do NOT produce word-for-word literal translations.
+- Technical documentation should read as if originally written in the target language by a native-speaking developer.
+- Maintain the same level of formality and tone as the source.
+- For languages that distinguish formal/informal registers, use a professional but approachable tone.
+
+## Output
+
+Return ONLY the translated content. Do not add explanations, notes, or commentary.`;
+
+export async function translateContent(
+  content: string,
+  targetLang: string,
+  targetLangName: string,
+  model: string = "claude-sonnet-4-6",
+): Promise<{ translated: string; inputTokens: number; outputTokens: number }> {
+  const anthropic = getClient();
+
+  const response = await anthropic.messages.create({
+    model,
+    max_tokens: 16384,
+    system: [{ type: "text", text: SYSTEM_PROMPT, cache_control: { type: "ephemeral" } }],
+    messages: [
+      {
+        role: "user",
+        content: `Translate the following documentation content into ${targetLangName} (${targetLang}).\n\n---\n\n${content}`,
+      },
+    ],
+  });
+
+  const translated =
+    response.content[0].type === "text" ? response.content[0].text : "";
+
+  return {
+    translated,
+    inputTokens: response.usage.input_tokens,
+    outputTokens: response.usage.output_tokens,
+  };
+}

package/scripts/translate-docs/types.ts

@@ -0,0 +1,43 @@
+export interface LanguageConfig {
+  code: string;
+  name: string;
+  nativeName: string;
+  tier: 1 | 2 | 3;
+  rtl?: boolean;
+}
+
+export interface CacheEntry {
+  sourceHash: string;
+  targetLang: string;
+  translatedAt: string;
+  inputTokens: number;
+  outputTokens: number;
+}
+
+export interface TranslationCache {
+  sourceHash: string;
+  lastUpdated: string;
+  translations: Record<string, CacheEntry>;
+}
+
+export interface TranslateOptions {
+  languages: string[];
+  tier?: number;
+  pagesFilter?: string[];
+  readmeOnly?: boolean;
+  docsOnly?: boolean;
+  dryRun?: boolean;
+  force?: boolean;
+  updateNav?: boolean;
+  validate?: boolean;
+  model?: string;
+}
+
+export interface TranslationResult {
+  lang: string;
+  sourcePath: string;
+  outputPath: string;
+  inputTokens: number;
+  outputTokens: number;
+  cached: boolean;
+}

package/src/hooks/manager.ts

@@ -267,7 +267,9 @@ export async function installHooks(
   }
 
   for (const eventType of HOOK_EVENT_TYPES) {
-    const command = `"${binaryPath}" --hook ${eventType}`;
+    const command = scope === "project"
+      ? `npx -y failproofai --hook ${eventType}`
+      : `"${binaryPath}" --hook ${eventType}`;
     const hookEntry: ClaudeHookEntry = {
       type: "command",
       command,
@@ -323,6 +325,7 @@ export async function installHooks(
       has_custom_hooks_path: !!(configToWrite.customPoliciesPath),
       has_policy_params: !!(configToWrite.policyParams && Object.keys(configToWrite.policyParams).length > 0),
       param_policy_names: configToWrite.policyParams ? Object.keys(configToWrite.policyParams) : [],
+      command_format: scope === "project" ? "npx" : "absolute",
     });
   } catch {
     // Telemetry is best-effort — never block the operation
@@ -330,7 +333,12 @@ export async function installHooks(
 
   console.log(`Failproof AI hooks installed for all ${HOOK_EVENT_TYPES.length} event types (scope: ${scope}).`);
   console.log(`Settings: ${settingsPath}`);
-  console.log(`Binary:   ${binaryPath}`);
+  if (scope === "project") {
+    console.log(`Command:  npx -y failproofai`);
+    console.log(`\nThis file can be committed to git — no machine-specific paths.`);
+  } else {
+    console.log(`Binary:   ${binaryPath}`);
+  }
 
   // Warn about duplicate-scope installations
   const otherScopes = deduplicateScopes(HOOK_SCOPES, cwd).filter((s) => s !== scope);

package/.next/standalone/.next/server/chunks/[root-of-the-server]__02nt~6d._.js

@@ -1,3 +0,0 @@
-module.exports=[2157,(e,t,i)=>{t.exports=e.x("node:fs",()=>require("node:fs"))},60526,(e,t,i)=>{t.exports=e.x("node:os",()=>require("node:os"))},50227,(e,t,i)=>{t.exports=e.x("node:path",()=>require("node:path"))},66680,(e,t,i)=>{t.exports=e.x("node:crypto",()=>require("node:crypto"))},74533,(e,t,i)=>{t.exports=e.x("node:child_process",()=>require("node:child_process"))},93133,(e,t,i)=>{t.exports={name:"failproofai",version:"0.0.2-beta.8",description:"The easiest way to manage policies that keep your AI agents reliable, on-task, and running autonomously — for Claude Code & the Agents SDK",bin:{failproofai:"./dist/cli.mjs"},files:["bin/","src/","scripts/","lib/",".next/standalone/","dist/","README.md"],engines:{node:">=20.9.0",bun:">=1.3.0"},scripts:{predev:"bun run build:cli && bun link",dev:"FAILPROOFAI_TELEMETRY_DISABLED=1 bun scripts/dev.ts --port 8020","build:cli":"bun build --target=node --format=esm --outfile=dist/cli.mjs bin/failproofai.mjs --external posthog-node && node -e \"const fs=require('fs');const c=fs.readFileSync('dist/cli.mjs','utf8');fs.writeFileSync('dist/cli.mjs',c.replace('#!/usr/bin/env bun','#!/usr/bin/env node').replace('// @bun\\n',''))\"",build:"bun build --target=node --format=cjs --outfile=dist/index.js src/index.ts && bun run build:cli && bun --bun next build && node -e \"const {cpSync}=require('fs');cpSync('.next/static','.next/standalone/.next/static',{recursive:true});\"",prestart:"bun run build:cli && bun link",start:"FAILPROOFAI_TELEMETRY_DISABLED=1 bun scripts/start.ts",test:"vitest","test:run":"vitest run",lint:"eslint . --config eslint.config.mjs",postinstall:"node scripts/postinstall.mjs",preuninstall:"node scripts/preuninstall.mjs",prepare:"bun run build","test:e2e":"vitest run --config vitest.config.e2e.mts","test:e2e:watch":"vitest --config vitest.config.e2e.mts"},keywords:["claude","claude-code","claude-agents-sdk","anthropic","ai-agent","agent-reliability","agent-monitoring","autonomous-agent","failure-prevention","developer-tools","devtools","cli","local-first","hooks","policies"],author:"ExosphereHost Inc. <failproofai@exosphere.host>",license:"SEE LICENSE IN LICENSE",homepage:"https://github.com/exospherehost/failproofai",repository:{type:"git",url:"https://github.com/exospherehost/failproofai.git"},bugs:{url:"https://github.com/exospherehost/failproofai/issues"},publishConfig:{access:"public"},devDependencies:{"@tailwindcss/postcss":"^4.1.18","@tanstack/react-virtual":"^3.13.18","@testing-library/jest-dom":"^6.9.1","@testing-library/react":"^16.3.2","@testing-library/user-event":"^14.6.1","@types/node":"^25.5.2","@types/react":"^19.2.13","@types/react-dom":"^19.2.3","@vitejs/plugin-react":"^6.0.1",clsx:"^2.1.1",eslint:"^10.2.0","eslint-config-next":"^16.2.2","happy-dom":"^20.7.0","lucide-react":"^1.0.1",next:"^16.2.2",react:"^19.2.4","react-dom":"^19.2.4","tailwind-merge":"^3.4.0",tailwindcss:"^4.1.18",typescript:"^6.0.2",vitest:"^4.0.18"},dependencies:{"posthog-node":"^5.28.11"}}},15855,e=>{"use strict";let t;var i=e.i(2157),s=e.i(50227),n=e.i(60526),r=e.i(66680);e.i(74533);let o=s.default.join(n.default.homedir(),".failproofai"),a=s.default.join(o,"instance-id");function l(e){return r.default.createHmac("sha256","failproofai-telemetry-v1").update(e).digest("hex")}e.s(["getInstanceId",0,function(){if(t)return t;let e=function(){try{for(let e of(n.default.platform(),["/etc/machine-id","/var/lib/dbus/machine-id"]))try{let t=i.default.readFileSync(e,"utf-8").trim();if(t)return t}catch{}}catch{}}();if(e)return t=l(e);let s=[n.default.hostname(),n.default.homedir(),n.default.platform(),n.default.arch(),n.default.cpus()[0]?.model??""].join(":");return t=s?l(s):function(){try{let e=i.default.readFileSync(a,"utf-8").trim();if(e)return e}catch{}let e=r.default.randomUUID();try{i.default.mkdirSync(o,{recursive:!0}),i.default.writeFileSync(a,e,"utf-8")}catch{}return e}()},"hashToId",0,l])},34324,e=>{"use strict";var t=e.i(15855),i=e.i(93133);async function s(e,t){for(let i=1;i<=5;i++){try{let{signal:i,...s}=t,n=await fetch(e,{...s,signal:AbortSignal.timeout(5e3)});if(n.ok)return n}catch{}if(i<5){let e=Math.min(1e3*2**(i-1),8e3);await new Promise(t=>setTimeout(t,e))}}return new Response("{}",{status:200})}function n(){return"1"!==process.env.FAILPROOFAI_TELEMETRY_DISABLED}async function r(){if(n()&&!globalThis.__FAILPROOFAI_POSTHOG__)try{let t=await e.A(37581),i=process.env.FAILPROOFAI_POSTHOG_KEY??"phc_Ac1Ww1GqKc0z1SyrRWbmatEeQdlOQIsDEEdP8l8JRgX",n=process.env.FAILPROOFAI_POSTHOG_HOST??"https://us.i.posthog.com";globalThis.__FAILPROOFAI_POSTHOG__=new t.PostHog(i,{host:n,flushAt:1,flushInterval:0,requestTimeout:5e3,fetchRetryCount:0,fetch:s});let r=()=>{globalThis.__FAILPROOFAI_POSTHOG__?.shutdown().catch(()=>{})};process.on("beforeExit",r),process.on("SIGTERM",r),process.on("SIGINT",r)}catch(e){console.warn("[failproofai:telemetry] PostHog init failed:",e instanceof Error?e.message:e)}}async function o(){let e=globalThis.__FAILPROOFAI_POSTHOG__;e&&await e.flush()}e.s(["flushTelemetry",0,o,"initTelemetry",0,r,"trackEvent",0,function(e,s){if(!n())return;let r=globalThis.__FAILPROOFAI_POSTHOG__;r&&r.capture({distinctId:(0,t.getInstanceId)(),event:e,properties:{...s,$lib:"failproofai",failproofai_version:i.version}})}],34324)},37581,e=>{e.v(t=>Promise.all(["server/chunks/[externals]__0-p9.k~._.js","server/chunks/node_modules_posthog-node_dist_entrypoints_index_node_mjs_05pz9._._.js"].map(t=>e.l(t))).then(()=>t(28864)))}];
-
-//# sourceMappingURL=%5Broot-of-the-server%5D__02nt~6d._.js.map