@sashabogi/foundation 0.1.5 → 0.1.7

package/dist/cli/test-connection.js

@@ -0,0 +1,697 @@
+/**
+ * Provider connection testing utilities for Foundation
+ * Tests connectivity to LLM providers
+ *
+ * Updated February 2026 to include all providers.
+ */
+import * as p from "@clack/prompts";
+import color from "picocolors";
+/**
+ * Test Anthropic API connection
+ */
+export async function testAnthropicConnection(apiKey, baseUrl = "https://api.anthropic.com/v1") {
+    const startTime = Date.now();
+    try {
+        // Anthropic doesn't have a /models endpoint, so we do a minimal completion test
+        const response = await fetch(`${baseUrl}/messages`, {
+            method: "POST",
+            headers: {
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 1,
+                messages: [{ role: "user", content: "Hi" }],
+            }),
+            signal: AbortSignal.timeout(15000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your Anthropic console";
+        }
+        else if (response.status === 403) {
+            errorMessage = "API key lacks permission - check your Anthropic console";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Anthropic server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Anthropic service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test OpenAI API connection
+ */
+export async function testOpenAIConnection(apiKey, baseUrl = "https://api.openai.com/v1") {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your OpenAI dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "OpenAI server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check OpenAI service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Google Gemini API connection
+ */
+export async function testGeminiConnection(apiKey, baseUrl = "https://generativelanguage.googleapis.com/v1beta") {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(`${baseUrl}/models?key=${apiKey}`, {
+            method: "GET",
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 400 || response.status === 403) {
+            errorMessage = "Invalid API key - check your Google AI Studio dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Gemini server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Google AI service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test DeepSeek API connection
+ */
+export async function testDeepSeekConnection(apiKey, baseUrl = "https://api.deepseek.com") {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your DeepSeek dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "DeepSeek server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check DeepSeek service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Z.AI (GLM) API connection
+ */
+export async function testZaiConnection(apiKey, baseUrl = "https://api.z.ai/api/paas/v4") {
+    const startTime = Date.now();
+    try {
+        // Z.AI uses a simple chat completion test
+        const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: "glm-4.7-flash",
+                messages: [{ role: "user", content: "Hi" }],
+                max_tokens: 1,
+            }),
+            signal: AbortSignal.timeout(15000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your Z.AI dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Z.AI server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Z.AI service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Moonshot (Kimi) API connection
+ */
+export async function testKimiConnection(apiKey, baseUrl = "https://api.moonshot.ai/v1") {
+    const startTime = Date.now();
+    try {
+        // Moonshot uses OpenAI-compatible API, test with models endpoint
+        const response = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your Moonshot console";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Moonshot server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Moonshot service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Kimi Code API connection
+ *
+ * Kimi Code is a separate endpoint from the regular Moonshot API.
+ * CRITICAL: Requires User-Agent: claude-code/1.0 header or requests are rejected.
+ */
+export async function testKimiCodeConnection(apiKey, baseUrl = "https://api.kimi.com/coding/v1") {
+    const startTime = Date.now();
+    try {
+        // Try the models endpoint first with required User-Agent header
+        const response = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "User-Agent": "claude-code/1.0",
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        // If models endpoint fails, try a minimal chat completion
+        if (response.status === 404) {
+            const chatResponse = await fetch(`${baseUrl}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                    "User-Agent": "claude-code/1.0",
+                },
+                body: JSON.stringify({
+                    model: "kimi-for-coding",
+                    messages: [{ role: "user", content: "Hi" }],
+                    max_tokens: 1,
+                }),
+                signal: AbortSignal.timeout(15000),
+            });
+            const chatLatencyMs = Date.now() - startTime;
+            if (chatResponse.ok) {
+                return { success: true, latencyMs: chatLatencyMs };
+            }
+            await chatResponse.text(); // Consume body
+            let errorMessage = `HTTP ${chatResponse.status}`;
+            if (chatResponse.status === 401) {
+                errorMessage = "Invalid API key - check your Kimi subscription";
+            }
+            else if (chatResponse.status === 403) {
+                errorMessage = "Access denied - ensure you have Kimi Code access";
+            }
+            else if (chatResponse.status === 429) {
+                errorMessage = "Rate limited - quota exceeded";
+            }
+            else if (chatResponse.status >= 500) {
+                errorMessage = "Kimi Code server error - try again later";
+            }
+            return { success: false, latencyMs: chatLatencyMs, error: errorMessage };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your Kimi subscription";
+        }
+        else if (response.status === 403) {
+            errorMessage = "Access denied - ensure you have Kimi Code access";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Kimi Code server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Kimi Code service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Perplexity API connection
+ * Note: Perplexity does NOT have a /models endpoint, so we use chat completion test
+ */
+export async function testPerplexityConnection(apiKey, baseUrl = "https://api.perplexity.ai") {
+    const startTime = Date.now();
+    try {
+        // Perplexity doesn't have a /models endpoint, so we do a minimal completion test
+        const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: "sonar",
+                messages: [{ role: "user", content: "Hi" }],
+                max_tokens: 1,
+            }),
+            signal: AbortSignal.timeout(15000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your Perplexity dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Perplexity server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Perplexity service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test OpenRouter API connection
+ */
+export async function testOpenRouterConnection(apiKey, baseUrl = "https://openrouter.ai/api/v1") {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your OpenRouter dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "OpenRouter server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check OpenRouter service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Groq API connection
+ */
+export async function testGroqConnection(apiKey, baseUrl = "https://api.groq.com/openai/v1") {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your Groq dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Groq server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Groq service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Together AI API connection
+ */
+export async function testTogetherConnection(apiKey, baseUrl = "https://api.together.xyz/v1") {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your Together AI dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Together AI server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Together AI service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Fireworks AI API connection
+ */
+export async function testFireworksConnection(apiKey, baseUrl = "https://api.fireworks.ai/inference/v1") {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            return { success: true, latencyMs };
+        }
+        await response.text(); // Consume body
+        let errorMessage = `HTTP ${response.status}`;
+        if (response.status === 401) {
+            errorMessage = "Invalid API key - check your Fireworks AI dashboard";
+        }
+        else if (response.status === 429) {
+            errorMessage = "Rate limited - quota exceeded";
+        }
+        else if (response.status >= 500) {
+            errorMessage = "Fireworks AI server error - try again later";
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - server not responding";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - check Fireworks AI service status";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Test Ollama connection and fetch available models
+ */
+export async function testOllamaConnection(baseUrl = "http://localhost:11434") {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(`${baseUrl}/api/tags`, {
+            method: "GET",
+            signal: AbortSignal.timeout(5000),
+        });
+        const latencyMs = Date.now() - startTime;
+        if (response.ok) {
+            const data = (await response.json());
+            const models = data.models?.map((m) => m.name) ?? [];
+            return { success: true, latencyMs, models };
+        }
+        return {
+            success: false,
+            latencyMs,
+            error: `HTTP ${response.status} - Ollama API error`,
+        };
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        let errorMessage = "Unknown error";
+        if (error instanceof Error) {
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                errorMessage = "Connection timeout - is Ollama running?";
+            }
+            else if (error.message.includes("ECONNREFUSED")) {
+                errorMessage = "Connection refused - start Ollama with: ollama serve";
+            }
+            else {
+                errorMessage = error.message;
+            }
+        }
+        return { success: false, latencyMs, error: errorMessage };
+    }
+}
+/**
+ * Display spinner while testing connection
+ */
+export async function testConnectionWithSpinner(providerName, testFn) {
+    const spinner = p.spinner();
+    spinner.start(`Testing ${providerName} connection...`);
+    const result = await testFn();
+    if (result.success) {
+        spinner.stop(color.green(`Connected to ${providerName}`) +
+            color.dim(` (${result.latencyMs}ms)`));
+    }
+    else {
+        spinner.stop(color.red(`Failed to connect to ${providerName}`));
+        p.log.error(color.dim(result.error ?? "Unknown error"));
+    }
+    return result;
+}
+//# sourceMappingURL=test-connection.js.map