@amplitude/wizard 1.0.0-beta.0

package/dist/src/lib/detect-amplitude.js

@@ -0,0 +1,407 @@
+"use strict";
+/**
+ * detect-amplitude — Static heuristics to check if Amplitude is already
+ * installed in the project directory, without calling any APIs or AI.
+ *
+ * Checks (in order of confidence):
+ *   1. package.json — Amplitude npm packages in dependencies
+ *   2. Python requirements files — amplitude-analytics
+ *   3. Swift — Podfile or Package.resolved
+ *   4. Android / Java — build.gradle / build.gradle.kts
+ *   5. Flutter — pubspec.yaml
+ *   6. Go — go.mod
+ *   7. Unreal Engine — Config/DefaultEngine.ini or Plugins/AmplitudeUnreal/
+ *   8. Unity — Packages/manifest.json
+ *   9. Source code imports — grep for amplitude import statements
+ *
+ * Returns a confidence level so callers can decide how to act:
+ *   'high'   — package file explicitly lists an Amplitude SDK
+ *   'low'    — import found in source but no package file entry
+ *   'none'   — no evidence found
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAmplitudeInProject = detectAmplitudeInProject;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+// ── npm packages ─────────────────────────────────────────────────────
+const AMPLITUDE_NPM_PACKAGES = [
+    '@amplitude/analytics-browser',
+    '@amplitude/analytics-node',
+    '@amplitude/analytics-react-native',
+    '@amplitude/unified',
+    'amplitude-js', // legacy browser SDK
+];
+function checkPackageJson(dir) {
+    const pkgPath = path.join(dir, 'package.json');
+    try {
+        const raw = fs.readFileSync(pkgPath, 'utf-8');
+        const pkg = JSON.parse(raw);
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        for (const name of AMPLITUDE_NPM_PACKAGES) {
+            if (allDeps[name]) {
+                return { confidence: 'high', reason: `${name} found in package.json` };
+            }
+        }
+    }
+    catch {
+        // No package.json or invalid JSON — not a JS project
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Python requirements ──────────────────────────────────────────────
+/** Matches `amplitude-analytics` with optional version specifier */
+const PYTHON_AMPLITUDE_RE = /^\s*amplitude[-_]analytics\b/im;
+function checkPythonRequirements(dir) {
+    const candidates = [
+        'requirements.txt',
+        'requirements-dev.txt',
+        'requirements/base.txt',
+        'requirements/common.txt',
+    ];
+    for (const rel of candidates) {
+        try {
+            const content = fs.readFileSync(path.join(dir, rel), 'utf-8');
+            if (PYTHON_AMPLITUDE_RE.test(content)) {
+                return {
+                    confidence: 'high',
+                    reason: `amplitude-analytics found in ${rel}`,
+                };
+            }
+        }
+        catch {
+            // File doesn't exist — skip
+        }
+    }
+    // pyproject.toml
+    try {
+        const content = fs.readFileSync(path.join(dir, 'pyproject.toml'), 'utf-8');
+        if (PYTHON_AMPLITUDE_RE.test(content)) {
+            return {
+                confidence: 'high',
+                reason: 'amplitude-analytics found in pyproject.toml',
+            };
+        }
+    }
+    catch {
+        // Not a Python project or no pyproject.toml
+    }
+    // setup.cfg / setup.py
+    for (const file of ['setup.cfg', 'setup.py']) {
+        try {
+            const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+            if (PYTHON_AMPLITUDE_RE.test(content)) {
+                return {
+                    confidence: 'high',
+                    reason: `amplitude-analytics found in ${file}`,
+                };
+            }
+        }
+        catch {
+            // Skip
+        }
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Swift (CocoaPods / Swift Package Manager) ────────────────────────
+function checkSwiftPackages(dir) {
+    // CocoaPods Podfile
+    try {
+        const podfile = fs.readFileSync(path.join(dir, 'Podfile'), 'utf-8');
+        if (/pod\s+['"]AmplitudeUnified['"]/i.test(podfile)) {
+            return {
+                confidence: 'high',
+                reason: 'AmplitudeUnified found in Podfile',
+            };
+        }
+    }
+    catch {
+        // No Podfile
+    }
+    // Swift Package Manager — Package.resolved (locked dependency graph)
+    for (const rel of [
+        'Package.resolved',
+        '.package/checkouts/.resolved',
+        '.build/workspace-state.json', // fallback
+    ]) {
+        try {
+            const content = fs.readFileSync(path.join(dir, rel), 'utf-8');
+            if (content.includes('AmplitudeUnified-Swift') ||
+                content.includes('amplitude/AmplitudeUnified')) {
+                return {
+                    confidence: 'high',
+                    reason: `AmplitudeUnified found in ${rel}`,
+                };
+            }
+        }
+        catch {
+            // Skip
+        }
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Android / Java (Gradle) ──────────────────────────────────────────
+const GRADLE_AMPLITUDE_RE = /com\.amplitude:(analytics-android|java-sdk)/;
+function checkGradleFiles(dir) {
+    const candidates = [
+        'build.gradle',
+        'build.gradle.kts',
+        'app/build.gradle',
+        'app/build.gradle.kts',
+    ];
+    for (const rel of candidates) {
+        try {
+            const content = fs.readFileSync(path.join(dir, rel), 'utf-8');
+            if (GRADLE_AMPLITUDE_RE.test(content)) {
+                return {
+                    confidence: 'high',
+                    reason: `Amplitude dependency found in ${rel}`,
+                };
+            }
+        }
+        catch {
+            // Skip
+        }
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Flutter (pubspec.yaml) ───────────────────────────────────────────
+function checkPubspecYaml(dir) {
+    try {
+        const content = fs.readFileSync(path.join(dir, 'pubspec.yaml'), 'utf-8');
+        if (/^\s*amplitude_flutter\s*:/m.test(content)) {
+            return {
+                confidence: 'high',
+                reason: 'amplitude_flutter found in pubspec.yaml',
+            };
+        }
+    }
+    catch {
+        // No pubspec.yaml
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Go (go.mod) ──────────────────────────────────────────────────────
+function checkGoMod(dir) {
+    try {
+        const content = fs.readFileSync(path.join(dir, 'go.mod'), 'utf-8');
+        if (content.includes('github.com/amplitude/analytics-go')) {
+            return {
+                confidence: 'high',
+                reason: 'github.com/amplitude/analytics-go found in go.mod',
+            };
+        }
+    }
+    catch {
+        // No go.mod
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Unreal Engine ────────────────────────────────────────────────────
+function checkUnrealConfig(dir) {
+    // Config/DefaultEngine.ini with Amplitude analytics provider
+    try {
+        const content = fs.readFileSync(path.join(dir, 'Config', 'DefaultEngine.ini'), 'utf-8');
+        if (/AmplitudeApiKey\s*=|ProviderModuleName\s*=\s*Amplitude/i.test(content)) {
+            return {
+                confidence: 'high',
+                reason: 'Amplitude configured in Config/DefaultEngine.ini',
+            };
+        }
+    }
+    catch {
+        // No config
+    }
+    // Plugin already extracted into Plugins/
+    if (fs.existsSync(path.join(dir, 'Plugins', 'AmplitudeUnreal', 'Amplitude.uplugin'))) {
+        return {
+            confidence: 'high',
+            reason: 'AmplitudeUnreal plugin found in Plugins/',
+        };
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Unity ────────────────────────────────────────────────────────────
+function checkUnityManifest(dir) {
+    // UPM manifest
+    try {
+        const content = fs.readFileSync(path.join(dir, 'Packages', 'manifest.json'), 'utf-8');
+        if (content.includes('amplitude/unity-plugin')) {
+            return {
+                confidence: 'high',
+                reason: 'amplitude/unity-plugin found in Packages/manifest.json',
+            };
+        }
+    }
+    catch {
+        // No manifest
+    }
+    // Manual .unitypackage import lands under Assets/Amplitude/
+    if (fs.existsSync(path.join(dir, 'Assets', 'Amplitude'))) {
+        return {
+            confidence: 'high',
+            reason: 'Amplitude assets found in Assets/Amplitude/',
+        };
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Source-code import grep ──────────────────────────────────────────
+const JS_AMPLITUDE_IMPORT_RE = /from\s+['"]@?amplitude\b|require\s*\(\s*['"]@?amplitude\b/;
+const PY_AMPLITUDE_IMPORT_RE = /^\s*(from\s+amplitude\b|import\s+amplitude\b)/m;
+const SWIFT_AMPLITUDE_IMPORT_RE = /import\s+AmplitudeUnified|Amplitude\s*\(\s*apiKey:/;
+const KOTLIN_JAVA_AMPLITUDE_RE = /com\.amplitude\b/;
+const GO_AMPLITUDE_IMPORT_RE = /["']github\.com\/amplitude\/analytics-go/;
+const DART_AMPLITUDE_IMPORT_RE = /amplitude_flutter|amplitude\.track\b/;
+const CSHARP_AMPLITUDE_RE = /Amplitude\.getInstance\b|Amplitude\.Instance\b/;
+const IGNORE_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.next',
+    'dist',
+    'build',
+    '.turbo',
+    '.cache',
+    '__pycache__',
+    '.venv',
+    'venv',
+    'env',
+    // Native build output dirs
+    '.build',
+    'Pods',
+    'DerivedData',
+    '.gradle',
+    'Library', // Unity Library cache
+]);
+const JS_EXTS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+const PY_EXTS = new Set(['.py']);
+const SWIFT_EXTS = new Set(['.swift']);
+const KOTLIN_JAVA_EXTS = new Set(['.kt', '.java']);
+const GO_EXTS = new Set(['.go']);
+const DART_EXTS = new Set(['.dart']);
+const CSHARP_EXTS = new Set(['.cs']);
+function getImportRegex(ext) {
+    if (JS_EXTS.has(ext))
+        return JS_AMPLITUDE_IMPORT_RE;
+    if (PY_EXTS.has(ext))
+        return PY_AMPLITUDE_IMPORT_RE;
+    if (SWIFT_EXTS.has(ext))
+        return SWIFT_AMPLITUDE_IMPORT_RE;
+    if (KOTLIN_JAVA_EXTS.has(ext))
+        return KOTLIN_JAVA_AMPLITUDE_RE;
+    if (GO_EXTS.has(ext))
+        return GO_AMPLITUDE_IMPORT_RE;
+    if (DART_EXTS.has(ext))
+        return DART_AMPLITUDE_IMPORT_RE;
+    if (CSHARP_EXTS.has(ext))
+        return CSHARP_AMPLITUDE_RE;
+    return null;
+}
+const ALL_SCANNED_EXTS = new Set([
+    ...JS_EXTS,
+    ...PY_EXTS,
+    ...SWIFT_EXTS,
+    ...KOTLIN_JAVA_EXTS,
+    ...GO_EXTS,
+    ...DART_EXTS,
+    ...CSHARP_EXTS,
+]);
+function grepSourceFiles(dir, maxFiles = 200) {
+    let checked = 0;
+    function walk(current) {
+        if (checked >= maxFiles)
+            return null;
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            return null;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (IGNORE_DIRS.has(entry.name))
+                    continue;
+                const found = walk(path.join(current, entry.name));
+                if (found)
+                    return found;
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (!ALL_SCANNED_EXTS.has(ext))
+                    continue;
+                checked++;
+                try {
+                    const content = fs.readFileSync(path.join(current, entry.name), 'utf-8');
+                    const re = getImportRegex(ext);
+                    if (re && re.test(content)) {
+                        return path.relative(dir, path.join(current, entry.name));
+                    }
+                }
+                catch {
+                    // Unreadable file — skip
+                }
+            }
+        }
+        return null;
+    }
+    const hit = walk(dir);
+    if (hit) {
+        return { confidence: 'low', reason: `Amplitude import found in ${hit}` };
+    }
+    return { confidence: 'none', reason: null };
+}
+// ── Public API ───────────────────────────────────────────────────────
+/**
+ * Run all static checks in priority order.
+ * Returns the first non-'none' result, or 'none' if nothing found.
+ */
+function detectAmplitudeInProject(installDir) {
+    const checks = [
+        checkPackageJson,
+        checkPythonRequirements,
+        checkSwiftPackages,
+        checkGradleFiles,
+        checkPubspecYaml,
+        checkGoMod,
+        checkUnrealConfig,
+        checkUnityManifest,
+    ];
+    for (const check of checks) {
+        const result = check(installDir);
+        if (result.confidence !== 'none')
+            return result;
+    }
+    return grepSourceFiles(installDir);
+}

package/dist/src/lib/framework-config.d.ts

@@ -0,0 +1,188 @@
+import type { Integration } from './constants';
+import type { WizardOptions } from '../utils/types';
+import type { PackageManagerDetector } from './package-manager-detection';
+/**
+ * A setup question that the SetupScreen renders for framework disambiguation.
+ * If detect() returns a value, the question is auto-resolved and not shown.
+ */
+export interface SetupQuestion {
+    /** Stored in session.frameworkContext[key] */
+    key: string;
+    /** Displayed to user, e.g. "Which router are you using?" */
+    message: string;
+    /** Picker options */
+    options: Array<{
+        label: string;
+        value: string;
+        hint?: string;
+    }>;
+    /** Auto-detect; null = ask the user */
+    detect: (options: Pick<WizardOptions, 'installDir'>) => Promise<string | null>;
+}
+/**
+ * Configuration interface for framework-specific agent integrations.
+ * Each framework exports a FrameworkConfig that the universal runner uses.
+ *
+ * The TContext generic represents the framework-specific context gathered
+ * before the agent runs (e.g., router type for Next.js, project type for Django).
+ * The runner threads this opaquely — all framework-specific logic stays inside the config.
+ */
+export interface FrameworkConfig<TContext extends Record<string, unknown> = Record<string, unknown>> {
+    metadata: FrameworkMetadata<TContext>;
+    detection: FrameworkDetection;
+    environment: EnvironmentConfig;
+    analytics: AnalyticsConfig<TContext>;
+    prompts: PromptConfig<TContext>;
+    ui: UIConfig<TContext>;
+}
+/**
+ * Basic framework information and documentation
+ */
+export interface FrameworkMetadata<TContext extends Record<string, unknown> = Record<string, unknown>> {
+    /** Display name (e.g., "Next.js", "React") */
+    name: string;
+    /** Integration type from constants */
+    integration: Integration;
+    /** URL to framework-specific Amplitude docs */
+    docsUrl: string;
+    /**
+     * Optional URL to docs for users with unsupported framework versions.
+     * If not provided, defaults to docsUrl.
+     */
+    unsupportedVersionDocsUrl?: string;
+    /** If true, shows a beta notice before running the wizard. */
+    beta?: boolean;
+    /** Optional notice shown before the agent runs (e.g., "Close Xcode before proceeding"). */
+    preRunNotice?: string;
+    /**
+     * Optional function to gather framework-specific context before agent runs.
+     * For Next.js: detects router type
+     * For React Native: detects Expo vs bare
+     */
+    gatherContext?: (options: WizardOptions) => Promise<TContext>;
+    /** Optional additional MCP servers for this framework (e.g., Svelte MCP). */
+    additionalMcpServers?: Record<string, {
+        url: string;
+    }>;
+    /**
+     * Setup questions for framework disambiguation.
+     * The SetupScreen iterates unresolved questions and renders a PickerMenu for each.
+     * If all questions are auto-resolved (or none defined), the screen is skipped.
+     */
+    setup?: {
+        questions: SetupQuestion[];
+    };
+}
+/**
+ * Framework detection and version handling
+ */
+export interface FrameworkDetection {
+    /** Package name to check in package.json (e.g., "next", "react") */
+    packageName: string;
+    /** Human-readable name for error messages (e.g., "Next.js") */
+    packageDisplayName: string;
+    /** Extract version from package.json */
+    getVersion: (packageJson: unknown) => string | undefined;
+    /** Optional: Convert version to analytics bucket (e.g., "15.x") */
+    getVersionBucket?: (version: string) => string;
+    /**
+     * Whether this framework uses package.json (Node.js/JavaScript).
+     * If false, skips package.json checks (for Python, Go, etc.)
+     * Defaults to true if not specified.
+     */
+    usesPackageJson?: boolean;
+    /** Minimum supported version. If set, runner checks before proceeding. */
+    minimumVersion?: string;
+    /** Get the currently installed version. Called by runner for version check. */
+    getInstalledVersion?: (options: WizardOptions) => Promise<string | undefined>;
+    /** Detect whether this framework is present in the project. */
+    detect: (options: Pick<WizardOptions, 'installDir'>) => Promise<boolean>;
+    /** Detect the project's package manager(s). Used by the in-process MCP tool. */
+    detectPackageManager: PackageManagerDetector;
+}
+/**
+ * Environment variable configuration
+ */
+export interface EnvironmentConfig {
+    /** Whether to upload env vars to hosting providers post-agent */
+    uploadToHosting: boolean;
+    /**
+     * Build the environment variables object for this framework.
+     * Returns the exact variable names and values to upload to hosting providers.
+     */
+    getEnvVars: (apiKey: string, host: string) => Record<string, string>;
+}
+/**
+ * Analytics configuration
+ */
+export interface AnalyticsConfig<TContext extends Record<string, unknown> = Record<string, unknown>> {
+    /** Generate tags from context (e.g., { 'nextjs-version': '15.x', 'router': 'app' }) */
+    getTags: (context: TContext) => Record<string, string>;
+    /** Optional: Additional event properties */
+    getEventProperties?: (context: TContext) => Record<string, string>;
+}
+/**
+ * Default package installation instruction used when frameworks don't
+ * provide their own. Frameworks with specific needs (e.g., Swift SPM,
+ * Composer) override this in their config.
+ */
+export declare const DEFAULT_PACKAGE_INSTALLATION = "Use the detect_package_manager tool to determine the package manager. Do not manually edit package.json; the package manager handles it automatically.";
+export declare const PYTHON_PACKAGE_INSTALLATION = "Use the detect_package_manager tool to determine the package manager. If the detected tool manages dependencies directly (e.g. uv add, poetry add), use it \u2014 it will update the manifest automatically. If using pip, you must also add the dependency to requirements.txt or the appropriate manifest file.";
+/**
+ * Prompt configuration
+ */
+export interface PromptConfig<TContext extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Optional: Completely replace the default MCP-skills prompt.
+     * When provided, none of the other PromptConfig fields are used for the prompt.
+     * Receives the same context that buildIntegrationPrompt receives.
+     */
+    buildPrompt?: (context: {
+        projectApiKey: string;
+        host: string;
+        projectId: number;
+        typescript: boolean;
+        frameworkVersion: string;
+        frameworkContext: TContext;
+    }) => string;
+    /**
+     * Optional: Additional context lines to append to base prompt
+     * For Next.js: "- Router: app"
+     * For React Native: "- Platform: Expo"
+     */
+    getAdditionalContextLines?: (context: TContext) => string[];
+    /**
+     * How to detect the project type for this framework.
+     * Included in the agent prompt as project context.
+     * e.g., "Look for package.json and lockfiles" or "Look for requirements.txt and manage.py"
+     */
+    projectTypeDetection: string;
+    /**
+     * How to install packages for this framework.
+     * Included in the agent prompt as project context.
+     * Defaults to DEFAULT_PACKAGE_INSTALLATION. Only override if the framework
+     * has specific installation guidance (e.g., Swift SPM, Composer).
+     */
+    packageInstallation?: string;
+}
+/**
+ * UI messaging configuration
+ */
+export interface UIConfig<TContext extends Record<string, unknown> = Record<string, unknown>> {
+    /** Success message when agent completes */
+    successMessage: string;
+    /** Estimated time for agent to complete (in minutes) */
+    estimatedDurationMinutes: number;
+    /** Generate "What the agent did" bullets from context */
+    getOutroChanges: (context: TContext) => string[];
+    /** Generate "Next steps" bullets from context */
+    getOutroNextSteps: (context: TContext) => string[];
+}
+/**
+ * Generate welcome message from framework name
+ */
+export declare function getWelcomeMessage(frameworkName: string): string;
+/**
+ * Shared spinner message for all frameworks
+ */
+export declare const SPINNER_MESSAGE = "Writing your Amplitude setup with events, error capture and more...";

package/dist/src/lib/framework-config.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPINNER_MESSAGE = exports.PYTHON_PACKAGE_INSTALLATION = exports.DEFAULT_PACKAGE_INSTALLATION = void 0;
+exports.getWelcomeMessage = getWelcomeMessage;
+/**
+ * Default package installation instruction used when frameworks don't
+ * provide their own. Frameworks with specific needs (e.g., Swift SPM,
+ * Composer) override this in their config.
+ */
+exports.DEFAULT_PACKAGE_INSTALLATION = 'Use the detect_package_manager tool to determine the package manager. Do not manually edit package.json; the package manager handles it automatically.';
+exports.PYTHON_PACKAGE_INSTALLATION = 'Use the detect_package_manager tool to determine the package manager. If the detected tool manages dependencies directly (e.g. uv add, poetry add), use it — it will update the manifest automatically. If using pip, you must also add the dependency to requirements.txt or the appropriate manifest file.';
+/**
+ * Generate welcome message from framework name
+ */
+function getWelcomeMessage(frameworkName) {
+    return `Amplitude ${frameworkName} wizard (agent-powered)`;
+}
+/**
+ * Shared spinner message for all frameworks
+ */
+exports.SPINNER_MESSAGE = 'Writing your Amplitude setup with events, error capture and more...';

package/dist/src/lib/health-checks/endpoints.d.ts

@@ -0,0 +1,3 @@
+import { type BaseHealthResult } from './types';
+export declare const checkLlmGatewayHealth: () => Promise<BaseHealthResult>;
+export declare const checkMcpHealth: () => Promise<BaseHealthResult>;

package/dist/src/lib/health-checks/endpoints.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMcpHealth = exports.checkLlmGatewayHealth = void 0;
+const types_1 = require("./types");
+// ---------------------------------------------------------------------------
+// Direct endpoint health checks
+//
+// These ping Amplitude-owned services directly (no Statuspage intermediary).
+// A non-expected HTTP status or any network error is treated as Down.
+//
+// LLM Gateway – FastAPI service
+//   Source: amplitude/services/llm-gateway/src/llm_gateway/api/health.py
+//   GET /_liveness → 200 {"status":"alive"}
+//
+// MCP – Cloudflare Worker
+//   Source: amplitude/services/mcp/src/index.ts
+//   GET / → 200 (HTML landing page)
+// ---------------------------------------------------------------------------
+function downResult(error) {
+    return { status: types_1.ServiceHealthStatus.Down, error };
+}
+async function fetchEndpointHealth(url, timeoutMs = 5000, expectedStatus = 200) {
+    try {
+        const controller = new AbortController();
+        const tid = setTimeout(() => controller.abort(), timeoutMs);
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(tid);
+        if (res.status === expectedStatus) {
+            return {
+                status: types_1.ServiceHealthStatus.Healthy,
+                rawIndicator: `HTTP ${res.status}`,
+            };
+        }
+        return downResult(`HTTP ${res.status}`);
+    }
+    catch (e) {
+        if (e instanceof Error && e.name === 'AbortError')
+            return downResult('Request timed out');
+        return downResult(e instanceof Error ? e.message : 'Unknown error');
+    }
+}
+const checkLlmGatewayHealth = () => fetchEndpointHealth('https://gateway.us.amplitude.com/_liveness');
+exports.checkLlmGatewayHealth = checkLlmGatewayHealth;
+const checkMcpHealth = () => fetchEndpointHealth('https://mcp.amplitude.com/');
+exports.checkMcpHealth = checkMcpHealth;

package/dist/src/lib/health-checks/index.d.ts

@@ -0,0 +1,4 @@
+export { ServiceHealthStatus, type BaseHealthResult, type ComponentStatus, type ComponentHealthResult, type AllServicesHealth, type HealthCheckKey, } from './types';
+export { checkAnthropicHealth, checkAmplitudeOverallHealth, checkAmplitudeComponentHealth, checkGithubHealth, checkNpmOverallHealth, checkNpmComponentHealth, checkCloudflareOverallHealth, checkCloudflareComponentHealth, } from './statuspage';
+export { checkLlmGatewayHealth, checkMcpHealth } from './endpoints';
+export { type WizardReadinessConfig, DEFAULT_WIZARD_READINESS_CONFIG, checkAllExternalServices, WizardReadiness, type WizardReadinessResult, evaluateWizardReadiness, } from './readiness';