brigent-sdk 0.1.0

package/dist/events.js

@@ -0,0 +1,145 @@
+// SDK helper for consuming SSE deployment event streams.
+import { BrigentApiError } from "./errors.js";
+/**
+ * Stream deployment events via SSE.
+ * Returns an async iterable that yields DeploymentEvent objects.
+ * Supports auto-reconnect with exponential backoff.
+ *
+ * Usage:
+ * ```typescript
+ * for await (const event of streamDeploymentEvents(baseUrl, apiKey, "dep_123")) {
+ *   console.log(event.status);
+ *   if (event.status === "live") break;
+ * }
+ * ```
+ */
+export async function* streamDeploymentEvents(baseUrl, apiKey, deploymentId, options = {}) {
+    const maxAttempts = options.maxReconnectAttempts ?? 5;
+    const baseDelay = options.reconnectDelayMs ?? 1000;
+    let reconnectCount = 0;
+    while (reconnectCount <= maxAttempts) {
+        // Check if aborted before connecting
+        if (options.signal?.aborted)
+            return;
+        const url = `${baseUrl}/v1/deployments/${deploymentId}/events`;
+        let response;
+        try {
+            response = await fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    Accept: "text/event-stream",
+                },
+                signal: options.signal,
+            });
+        }
+        catch (err) {
+            // Network error during fetch
+            if (err instanceof Error && err.name === "AbortError")
+                return;
+            if (reconnectCount >= maxAttempts)
+                throw err;
+            reconnectCount++;
+            yield {
+                deployment_id: deploymentId,
+                status: "reconnecting",
+                timestamp: new Date().toISOString(),
+            };
+            await delay(baseDelay * Math.pow(2, reconnectCount - 1));
+            continue;
+        }
+        if (!response.ok) {
+            throw new BrigentApiError(response.status, {
+                error: {
+                    code: "SSE_CONNECTION_FAILED",
+                    message: `SSE connection failed: ${response.status} ${response.statusText}`,
+                    suggested_action: "Check the deployment ID and API key.",
+                    documentation_url: "https://docs.brigent.io/sse",
+                },
+                request_id: "",
+            });
+        }
+        if (!response.body) {
+            throw new BrigentApiError(0, {
+                error: {
+                    code: "SSE_NO_BODY",
+                    message: "SSE response has no body",
+                    suggested_action: "Unexpected response from server.",
+                    documentation_url: "https://docs.brigent.io/sse",
+                },
+                request_id: "",
+            });
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let streamEnded = false;
+        try {
+            while (true) {
+                let result;
+                try {
+                    result = await reader.read();
+                }
+                catch (err) {
+                    // Read error (network disconnect)
+                    if (err instanceof Error && err.name === "AbortError")
+                        return;
+                    streamEnded = true;
+                    break;
+                }
+                if (result.done) {
+                    streamEnded = true;
+                    break;
+                }
+                buffer += decoder.decode(result.value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                let currentEvent = "";
+                let currentData = "";
+                for (const line of lines) {
+                    if (line.startsWith("event: ")) {
+                        currentEvent = line.slice(7).trim();
+                    }
+                    else if (line.startsWith("data: ")) {
+                        currentData = line.slice(6).trim();
+                    }
+                    else if (line === "" && currentEvent && currentData) {
+                        if (currentEvent === "status" && currentData) {
+                            try {
+                                const event = JSON.parse(currentData);
+                                yield event;
+                                // Reset reconnect counter on successful event
+                                reconnectCount = 0;
+                            }
+                            catch {
+                                // Skip malformed events
+                            }
+                        }
+                        currentEvent = "";
+                        currentData = "";
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // Stream ended — attempt reconnect
+        if (streamEnded && reconnectCount < maxAttempts) {
+            if (options.signal?.aborted)
+                return;
+            reconnectCount++;
+            yield {
+                deployment_id: deploymentId,
+                status: "reconnecting",
+                timestamp: new Date().toISOString(),
+            };
+            await delay(baseDelay * Math.pow(2, reconnectCount - 1));
+            continue;
+        }
+        // Max reconnects exhausted or clean exit
+        break;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/http.d.ts

@@ -0,0 +1,17 @@
+export interface HttpClientOptions {
+    baseUrl: string;
+    apiKey: string;
+    timeout: number;
+    maxRetries: number;
+}
+export declare class HttpClient {
+    private readonly options;
+    constructor(options: HttpClientOptions);
+    get baseUrl(): string;
+    get apiKey(): string;
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete(path: string): Promise<void>;
+}

package/dist/http.js

@@ -0,0 +1,93 @@
+import { BrigentApiError } from "./errors.js";
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+export class HttpClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get baseUrl() {
+        return this.options.baseUrl;
+    }
+    get apiKey() {
+        return this.options.apiKey;
+    }
+    async request(method, path, body) {
+        const url = `${this.options.baseUrl}${path}`;
+        let lastError;
+        for (let attempt = 0; attempt <= this.options.maxRetries; attempt++) {
+            if (attempt > 0) {
+                const delayMs = Math.min(1000 * Math.pow(2, attempt - 1), 30000);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+            try {
+                const headers = {
+                    "Authorization": `Bearer ${this.options.apiKey}`,
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                };
+                const response = await fetch(url, {
+                    method,
+                    headers,
+                    body: body ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    let errorBody;
+                    try {
+                        errorBody = (await response.json());
+                    }
+                    catch {
+                        errorBody = {
+                            error: {
+                                code: "UNKNOWN",
+                                message: response.statusText || `HTTP ${response.status}`,
+                                suggested_action: "Check the API status.",
+                                documentation_url: "https://docs.brigent.io",
+                            },
+                            request_id: "unknown",
+                        };
+                    }
+                    const apiError = new BrigentApiError(response.status, errorBody);
+                    if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.options.maxRetries) {
+                        lastError = apiError;
+                        continue;
+                    }
+                    throw apiError;
+                }
+                // 204 No Content
+                if (response.status === 204) {
+                    return undefined;
+                }
+                return (await response.json());
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                if (error instanceof BrigentApiError) {
+                    throw error;
+                }
+                // Network / timeout errors
+                if (attempt < this.options.maxRetries) {
+                    lastError = error instanceof Error ? error : new Error(String(error));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw lastError ?? new Error("Request failed after retries");
+    }
+    async get(path) {
+        return this.request("GET", path);
+    }
+    async post(path, body) {
+        return this.request("POST", path, body);
+    }
+    async patch(path, body) {
+        return this.request("PATCH", path, body);
+    }
+    async delete(path) {
+        await this.request("DELETE", path);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { BrigentClient } from "./client.js";
+export { BrigentApiError } from "./errors.js";
+export { HttpClient } from "./http.js";
+export { DeploymentMonitor } from "./monitor.js";
+export { verifyWebhookSignature } from "./webhooks.js";
+export { estimateCost } from "./cost.js";
+export { streamDeploymentEvents } from "./events.js";
+export type { ListDeploymentsOptions, GetLogsOptions } from "./client.js";
+export type { WaitForLiveOptions } from "./monitor.js";
+export type { EstimateOptions } from "./cost.js";
+export type { StreamEventsOptions } from "./events.js";
+export type { DeployRequest, DeploymentType, SourceMethod, Runtime, DurationMode, BudgetAction, Region, ScaleConfig, ApiKeyCreateParams, WebhookCreateParams, WebhookUpdateParams, DeployResponse, DeploymentDetail, DeploymentListItem, DeploymentStatus, ResourceStatus, PaginatedResponse, CostEstimate, CostLineItem, BudgetStatus, CostResponse, BillingEvent, LogEntry, ApiKeyResponse, ApiKeyListItem, WebhookResponse, WebhookListItem, HealthResponse, ReadinessResponse, BrigentClientOptions, BrigentErrorBody, ErrorCode, ServerErrorCode, SdkErrorCode, AnalyticsOverview, DeploymentMetrics, MetricsSnapshot, UsageMetrics, AuditLogEntry, AuditLogOptions, BillingSummary, BillingSummaryOptions, TemplateCreateParams, TemplateResponse, CustomDomainResponse, DeploymentEvent, WebhookDeliveryItem, PricingTier, PricingResponse, TierResponse, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { BrigentClient } from "./client.js";
+export { BrigentApiError } from "./errors.js";
+export { HttpClient } from "./http.js";
+export { DeploymentMonitor } from "./monitor.js";
+export { verifyWebhookSignature } from "./webhooks.js";
+export { estimateCost } from "./cost.js";
+export { streamDeploymentEvents } from "./events.js";

package/dist/monitor.d.ts

@@ -0,0 +1,15 @@
+import { HttpClient } from "./http.js";
+import type { DeploymentDetail } from "./types.js";
+export interface WaitForLiveOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+export declare class DeploymentMonitor {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Poll a deployment until it reaches "live" status.
+     * Throws BrigentApiError on timeout, failure, or termination.
+     */
+    waitForLive(deploymentId: string, options?: WaitForLiveOptions): Promise<DeploymentDetail>;
+}

package/dist/monitor.js

@@ -0,0 +1,58 @@
+import { BrigentApiError } from "./errors.js";
+const DEFAULT_TIMEOUT_MS = 300_000; // 5 minutes
+const DEFAULT_POLL_INTERVAL_MS = 3_000; // 3 seconds
+const TERMINAL_STATUSES = new Set(["live", "failed", "terminated"]);
+export class DeploymentMonitor {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Poll a deployment until it reaches "live" status.
+     * Throws BrigentApiError on timeout, failure, or termination.
+     */
+    async waitForLive(deploymentId, options) {
+        const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const pollIntervalMs = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const detail = await this.http.get(`/v1/deployments/${deploymentId}`);
+            if (detail.status === "live") {
+                return detail;
+            }
+            if (detail.status === "failed") {
+                throw new BrigentApiError(422, {
+                    error: {
+                        code: "DEPLOYMENT_FAILED",
+                        message: detail.failure_reason ?? "Deployment failed",
+                        suggested_action: "Check deployment logs for details.",
+                        documentation_url: "https://docs.brigent.io/errors/DEPLOYMENT_FAILED",
+                    },
+                    request_id: "monitor",
+                });
+            }
+            if (detail.status === "terminated") {
+                throw new BrigentApiError(410, {
+                    error: {
+                        code: "DEPLOYMENT_TERMINATED",
+                        message: "Deployment was terminated before reaching live status",
+                        suggested_action: "Create a new deployment.",
+                        documentation_url: "https://docs.brigent.io/errors/DEPLOYMENT_TERMINATED",
+                    },
+                    request_id: "monitor",
+                });
+            }
+            // Wait before next poll
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
+        throw new BrigentApiError(408, {
+            error: {
+                code: "MONITOR_TIMEOUT",
+                message: `Deployment did not become live within ${timeoutMs}ms`,
+                suggested_action: "Increase the timeout or check deployment status manually.",
+                documentation_url: "https://docs.brigent.io/errors/MONITOR_TIMEOUT",
+            },
+            request_id: "monitor",
+        });
+    }
+}