@brokr/sdk 1.0.0

package/dist/runtime.mjs

@@ -0,0 +1,501 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  BrokrAuthClient: () => BrokrAuthClient,
+  authMiddleware: () => authMiddleware
+});
+function parseCookies(cookieHeader) {
+  const cookies = /* @__PURE__ */ new Map();
+  for (const pair of cookieHeader.split(";")) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx === -1) continue;
+    const name = pair.slice(0, eqIdx).trim();
+    const value = pair.slice(eqIdx + 1).trim();
+    if (name) cookies.set(name, value);
+  }
+  return cookies;
+}
+function authMiddleware(options) {
+  const { protectedRoutes = [], publicOnlyRoutes = [] } = options;
+  return async function middleware(request) {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    const isProtected = protectedRoutes.some((route) => pathname.startsWith(route));
+    const isPublicOnly = publicOnlyRoutes.some((route) => pathname.startsWith(route));
+    if (!isProtected && !isPublicOnly) return void 0;
+    const cookieHeader = request.headers.get("cookie") ?? "";
+    const cookies = parseCookies(cookieHeader);
+    const hasSession = cookies.has("better-auth.session_token");
+    if (isProtected && !hasSession) {
+      return Response.redirect(new URL("/sign-in", request.url).toString(), 302);
+    }
+    if (isPublicOnly && hasSession) {
+      return Response.redirect(new URL("/", request.url).toString(), 302);
+    }
+    return void 0;
+  };
+}
+var BrokrAuthClient;
+var init_auth = __esm({
+  "src/auth.ts"() {
+    "use strict";
+    init_runtime();
+    BrokrAuthClient = class {
+      constructor(token, gatewayUrl, appUrl) {
+        this._token = token;
+        this._gatewayUrl = gatewayUrl;
+        this._appUrl = appUrl ?? (typeof process !== "undefined" ? process.env.BETTER_AUTH_URL : void 0);
+      }
+      /**
+       * Get current user from an incoming request's cookies.
+       * Calls the local Better Auth API (runs inside your app).
+       */
+      async currentUser(request) {
+        const session = await this.getSession(request);
+        return session?.user ?? null;
+      }
+      /**
+       * Get the full session (user + metadata) from an incoming request.
+       * Calls the local Better Auth API.
+       */
+      async getSession(request) {
+        const appUrl = this._appUrl;
+        if (!appUrl) {
+          throw new BrokrError(
+            "[brokr] BETTER_AUTH_URL is not set. Auth may not be provisioned.",
+            "AUTH_NOT_CONFIGURED",
+            "auth"
+          );
+        }
+        const cookieHeader = request.headers.get("cookie") ?? "";
+        if (!cookieHeader) return null;
+        const res = await fetch(`${appUrl}/api/auth/get-session`, {
+          method: "GET",
+          headers: { cookie: cookieHeader }
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        if (!data?.user || !data?.session) return null;
+        return {
+          user: {
+            id: data.user.id,
+            email: data.user.email,
+            name: data.user.name ?? null,
+            avatarUrl: data.user.image ?? null,
+            emailVerified: data.user.emailVerified ? /* @__PURE__ */ new Date() : null
+          },
+          sessionId: data.session.id,
+          expiresAt: new Date(data.session.expiresAt)
+        };
+      }
+      /**
+       * Generate an OAuth authorization URL.
+       */
+      async getOAuthUrl(provider, options) {
+        const appUrl = this._appUrl;
+        if (!appUrl) {
+          throw new BrokrError("[brokr] BETTER_AUTH_URL is not set.", "AUTH_NOT_CONFIGURED", "auth");
+        }
+        const redirectTo = options?.redirectTo ?? "/";
+        if (!redirectTo.startsWith("/") || redirectTo.startsWith("//")) {
+          throw new BrokrError("[brokr] redirectTo must be a relative path (start with /)", "INVALID_REDIRECT", "auth");
+        }
+        const params = new URLSearchParams({ callbackURL: redirectTo });
+        return { redirectUrl: `${appUrl}/api/auth/sign-in/social?provider=${provider}&${params}` };
+      }
+      /**
+       * Send a magic link email (requires email capability).
+       */
+      async sendMagicLink(email, options) {
+        const appUrl = this._appUrl;
+        if (!appUrl) {
+          throw new BrokrError("[brokr] BETTER_AUTH_URL is not set.", "AUTH_NOT_CONFIGURED", "auth");
+        }
+        const res = await fetch(`${appUrl}/api/auth/magic-link/send`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email, callbackURL: options?.redirectTo ?? "/" })
+        });
+        if (!res.ok) {
+          const data = await res.json().catch(() => ({}));
+          throw new BrokrError(
+            data.message ?? `[brokr] Failed to send magic link (HTTP ${res.status})`,
+            "AUTH_MAGIC_LINK_FAILED",
+            "auth"
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/runtime.ts
+function resolveToken() {
+  return typeof process !== "undefined" ? process.env.BROKR_TOKEN : void 0;
+}
+function assertToken(token, capability) {
+  if (!token) {
+    let hint = "brokr env pull --stack <name>";
+    try {
+      if (typeof process !== "undefined") {
+        const fs = __require("fs");
+        const path = __require("path");
+        const brokrFile = path.join(process.cwd(), ".brokr");
+        if (fs.existsSync(brokrFile)) {
+          const data = JSON.parse(fs.readFileSync(brokrFile, "utf8"));
+          if (data?.stackName) hint = `brokr env pull --stack ${data.stackName}`;
+        }
+      }
+    } catch {
+    }
+    throw new BrokrAuthError(
+      `[brokr] BROKR_TOKEN is not set.
+Run: ${hint}`,
+      "BROKR_TOKEN_MISSING"
+    );
+  }
+}
+async function gatewayFetch(gatewayUrl, token, path, body, capability) {
+  let res;
+  try {
+    res = await fetch(`${gatewayUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    throw new BrokrNetworkError(
+      `[brokr] Could not reach Brokr gateway. Check your network.
+${err instanceof Error ? err.message : String(err)}`,
+      capability
+    );
+  }
+  if (res.status === 429) {
+    const retryAfter = parseInt(res.headers.get("Retry-After") ?? "60", 10);
+    const data = await res.json().catch(() => ({}));
+    throw new BrokrRateLimitError(
+      data.error ?? `[brokr] Rate limited (retry after ${retryAfter}s)`,
+      retryAfter,
+      capability
+    );
+  }
+  if (res.status === 401) {
+    throw new BrokrAuthError("[brokr] Invalid or expired BROKR_TOKEN.", "BROKR_TOKEN_INVALID");
+  }
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new BrokrError(
+      data.error ?? `[brokr] ${capability} request failed (HTTP ${res.status})`,
+      data.code ?? `${capability.toUpperCase()}_FAILED`,
+      capability
+    );
+  }
+  return res.json();
+}
+function createBrokr(options) {
+  return new BrokrRuntime(options);
+}
+var GATEWAY_URL, BrokrError, BrokrAuthError, BrokrRateLimitError, BrokrNetworkError, models, BrokrAIClient, BrokrStorageClient, BrokrEmailClient, BrokrRuntime;
+var init_runtime = __esm({
+  "src/runtime.ts"() {
+    GATEWAY_URL = "https://api.brokr.sh";
+    BrokrError = class extends Error {
+      constructor(message, code, capability, retryable = false) {
+        super(message);
+        this.code = code;
+        this.capability = capability;
+        this.retryable = retryable;
+        this.name = "BrokrError";
+      }
+    };
+    BrokrAuthError = class extends BrokrError {
+      constructor(message, code) {
+        super(message, code, "auth", false);
+        this.name = "BrokrAuthError";
+      }
+    };
+    BrokrRateLimitError = class extends BrokrError {
+      constructor(message, retryAfter, capability) {
+        super(message, "RATE_LIMITED", capability, true);
+        this.retryAfter = retryAfter;
+        this.name = "BrokrRateLimitError";
+      }
+    };
+    BrokrNetworkError = class extends BrokrError {
+      constructor(message, capability) {
+        super(message, "NETWORK_ERROR", capability, true);
+        this.name = "BrokrNetworkError";
+      }
+    };
+    models = {
+      /** Cheapest and fastest model (Deepseek Chat). */
+      FAST: "deepseek-chat",
+      /** Most capable model. */
+      SMART: "claude-sonnet-4-20250514",
+      /** Default balanced model (Deepseek Chat). */
+      BALANCED: "deepseek-chat"
+    };
+    BrokrAIClient = class {
+      constructor(_token, _gatewayUrl) {
+        this._token = _token;
+        this._gatewayUrl = _gatewayUrl;
+      }
+      /**
+       * Send a chat completion request.
+       *
+       * @example
+       * ```typescript
+       * const reply = await brokr.ai.chat([
+       *   { role: 'user', content: 'Explain quantum computing in one sentence.' }
+       * ]);
+       * console.log(reply.content);
+       * ```
+       */
+      async chat(messages, options) {
+        assertToken(this._token, "ai");
+        const data = await gatewayFetch(this._gatewayUrl, this._token, "/v1/chat/completions", {
+          messages,
+          model: options?.model,
+          max_tokens: options?.maxTokens,
+          temperature: options?.temperature
+        }, "ai");
+        return {
+          content: data.choices?.[0]?.message?.content ?? "",
+          model: data.model ?? "",
+          usage: {
+            promptTokens: data.usage?.prompt_tokens ?? 0,
+            completionTokens: data.usage?.completion_tokens ?? 0
+          }
+        };
+      }
+      /**
+       * Stream a chat completion. Yields text strings directly.
+       *
+       * @example
+       * ```typescript
+       * for await (const text of brokr.ai.stream(messages)) {
+       *   process.stdout.write(text);
+       * }
+       * ```
+       */
+      async *stream(messages, options) {
+        assertToken(this._token, "ai");
+        let res;
+        try {
+          res = await fetch(`${this._gatewayUrl}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${this._token}` },
+            body: JSON.stringify({ messages, stream: true, model: options?.model, max_tokens: options?.maxTokens })
+          });
+        } catch (err) {
+          throw new BrokrNetworkError(
+            `[brokr] Could not reach Brokr gateway.
+${err instanceof Error ? err.message : String(err)}`,
+            "ai"
+          );
+        }
+        if (res.status === 429) {
+          const retryAfter = parseInt(res.headers.get("Retry-After") ?? "60", 10);
+          throw new BrokrRateLimitError("[brokr] AI rate limited.", retryAfter, "ai");
+        }
+        if (res.status === 401) {
+          throw new BrokrAuthError("[brokr] Invalid or expired BROKR_TOKEN.", "BROKR_TOKEN_INVALID");
+        }
+        if (!res.ok || !res.body) {
+          throw new BrokrError(`[brokr] AI stream failed (HTTP ${res.status})`, "AI_STREAM_FAILED", "ai");
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (!line.startsWith("data: ")) continue;
+            const payload = line.slice(6).trim();
+            if (payload === "[DONE]") return;
+            try {
+              const parsed = JSON.parse(payload);
+              const delta = parsed.choices?.[0]?.delta?.content ?? "";
+              if (delta) yield delta;
+            } catch {
+            }
+          }
+        }
+      }
+      /**
+       * OpenAI-SDK compatible base URL.
+       *
+       * @example
+       * ```typescript
+       * const openai = new OpenAI({ baseURL: brokr.ai.baseURL, apiKey: brokr.ai.apiKey });
+       * ```
+       */
+      get baseURL() {
+        return `${this._gatewayUrl}/v1`;
+      }
+      /** Use as `apiKey` with the official OpenAI SDK to route through Brokr's gateway. */
+      get apiKey() {
+        assertToken(this._token, "ai");
+        return this._token;
+      }
+    };
+    BrokrStorageClient = class {
+      constructor(_token, _gatewayUrl) {
+        this._token = _token;
+        this._gatewayUrl = _gatewayUrl;
+      }
+      /**
+       * Get a presigned upload URL for browser-direct or streaming uploads.
+       *
+       * @example
+       * ```typescript
+       * const { url, key } = await brokr.storage.getUploadUrl('avatar.png', 'image/png');
+       * await fetch(url, { method: 'PUT', body: file });
+       * ```
+       */
+      async getUploadUrl(filename, contentType = "application/octet-stream") {
+        assertToken(this._token, "storage");
+        return gatewayFetch(
+          this._gatewayUrl,
+          this._token,
+          "/v1/storage/sign-upload",
+          { filename, contentType },
+          "storage"
+        );
+      }
+      /**
+       * Upload data to R2. Returns the stable object key.
+       *
+       * @example
+       * ```typescript
+       * const { key } = await brokr.storage.upload(fileBuffer, 'photo.jpg', 'image/jpeg');
+       * ```
+       */
+      async upload(data, filename, contentType = "application/octet-stream") {
+        const { url, key } = await this.getUploadUrl(filename, contentType);
+        const putRes = await fetch(url, {
+          method: "PUT",
+          headers: { "Content-Type": contentType },
+          body: data
+        });
+        if (!putRes.ok) {
+          throw new BrokrError(`[brokr] Upload failed (HTTP ${putRes.status})`, "STORAGE_UPLOAD_FAILED", "storage");
+        }
+        return { key };
+      }
+      /**
+       * Get a presigned download URL for a stored object.
+       *
+       * @example
+       * ```typescript
+       * const { url } = await brokr.storage.url('photos/avatar.jpg');
+       * // use url in <img src={url} /> or redirect
+       * ```
+       */
+      async url(key, options) {
+        assertToken(this._token, "storage");
+        return gatewayFetch(
+          this._gatewayUrl,
+          this._token,
+          "/v1/storage/sign-download",
+          { key, expiresIn: options?.expiresIn },
+          "storage"
+        );
+      }
+      /** @deprecated Use `url()` instead. */
+      async getUrl(key, options) {
+        return this.url(key, options);
+      }
+    };
+    BrokrEmailClient = class {
+      constructor(_token, _gatewayUrl) {
+        this._token = _token;
+        this._gatewayUrl = _gatewayUrl;
+      }
+      /**
+       * Send an email. The from address and API credentials are resolved server-side.
+       *
+       * @example
+       * ```typescript
+       * await brokr.email.send({
+       *   to: 'user@example.com',
+       *   subject: 'Welcome!',
+       *   html: '<h1>Welcome to the app</h1>',
+       * });
+       * ```
+       */
+      async send(params) {
+        assertToken(this._token, "email");
+        return gatewayFetch(
+          this._gatewayUrl,
+          this._token,
+          "/v1/email/send",
+          params,
+          "email"
+        );
+      }
+    };
+    BrokrRuntime = class {
+      constructor(options) {
+        this._token = options?.token ?? resolveToken();
+        this._gatewayUrl = options?.gatewayUrl ?? GATEWAY_URL;
+        this.ai = new BrokrAIClient(this._token, this._gatewayUrl);
+        this.storage = new BrokrStorageClient(this._token, this._gatewayUrl);
+        this.email = new BrokrEmailClient(this._token, this._gatewayUrl);
+      }
+      /** Auth client — lazily initialized to avoid pulling in auth deps when not needed. */
+      get auth() {
+        if (!this._auth) {
+          const { BrokrAuthClient: BrokrAuthClient2 } = (init_auth(), __toCommonJS(auth_exports));
+          this._auth = new BrokrAuthClient2(this._token, this._gatewayUrl);
+        }
+        return this._auth;
+      }
+    };
+  }
+});
+init_runtime();
+export {
+  BrokrAIClient,
+  BrokrAuthError,
+  BrokrEmailClient,
+  BrokrError,
+  BrokrNetworkError,
+  BrokrRateLimitError,
+  BrokrRuntime,
+  BrokrStorageClient,
+  GATEWAY_URL,
+  createBrokr,
+  models
+};

package/dist/src/auth.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Brokr Auth Client
+ *
+ * Server-side auth utilities for apps provisioned with `brokr add auth`.
+ * Wraps Better Auth's server-side API with Brokr's zero-config DX.
+ *
+ * Gateway verify: cross-service token verification via api.brokr.sh
+ * Local calls: session/user operations via the app's own Better Auth API
+ */
+export interface AuthUser {
+    id: string;
+    email: string;
+    name: string | null;
+    avatarUrl: string | null;
+    emailVerified: Date | null;
+}
+export interface AuthSession {
+    user: AuthUser;
+    sessionId: string;
+    expiresAt: Date;
+}
+export interface CreateUserInput {
+    email: string;
+    name?: string;
+    password?: string;
+}
+export interface UpdateUserInput {
+    name?: string;
+    avatarUrl?: string;
+}
+export interface OAuthUrlOptions {
+    redirectTo?: string;
+}
+export interface MagicLinkOptions {
+    redirectTo?: string;
+}
+export declare class BrokrAuthClient {
+    private readonly _token;
+    private readonly _gatewayUrl;
+    private readonly _appUrl;
+    constructor(token: string | undefined, gatewayUrl: string, appUrl?: string);
+    /**
+     * Get current user from an incoming request's cookies.
+     * Calls the local Better Auth API (runs inside your app).
+     */
+    currentUser(request: Request): Promise<AuthUser | null>;
+    /**
+     * Get the full session (user + metadata) from an incoming request.
+     * Calls the local Better Auth API.
+     */
+    getSession(request: Request): Promise<AuthSession | null>;
+    /**
+     * Generate an OAuth authorization URL.
+     */
+    getOAuthUrl(provider: string, options?: OAuthUrlOptions): Promise<{
+        redirectUrl: string;
+    }>;
+    /**
+     * Send a magic link email (requires email capability).
+     */
+    sendMagicLink(email: string, options?: MagicLinkOptions): Promise<void>;
+}
+/**
+ * Create auth middleware for Next.js route protection.
+ */
+export declare function authMiddleware(options: {
+    protectedRoutes?: string[];
+    publicOnlyRoutes?: string[];
+}): (request: Request) => Promise<Response | undefined>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/src/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,aAAa,EAAE,IAAI,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAMD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAG3C,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM;IAOjB;;;OAGG;IACG,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAK7D;;;OAGG;IACG,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAwC/D;;OAEG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAehG;;OAEG;IACG,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;CAqB9E;AAiBD;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE;IACtC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B,IAGkC,SAAS,OAAO,KAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAuBlF"}

package/dist/src/management.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Brokr SDK - Management Client
+ *
+ * For CLI and provisioning tools that manage stacks and providers
+ * via the Brokr tRPC API.
+ *
+ * @packageDocumentation
+ */
+import type { CreateStackInput, StackResponse, AddProviderInput, ProviderResponse } from '../types';
+/**
+ * Configuration options for the Brokr management client
+ */
+export interface BrokrConfig {
+    /** Base URL for the Brokr API */
+    apiUrl: string;
+    /** JWT access token for authentication */
+    accessToken: string;
+    /** Optional: Request timeout in milliseconds */
+    timeout?: number;
+    /** Optional: Custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Brokr management client for stack and provider operations.
+ */
+export declare class BrokrClient {
+    private config;
+    constructor(config: BrokrConfig);
+    /** Create a new stack with default providers. */
+    create(input: CreateStackInput): Promise<StackResponse>;
+    /** List all stacks for the current user. */
+    listStacks(): Promise<StackResponse[]>;
+    /** Get a specific stack by ID. */
+    getStack(id: string): Promise<StackResponse>;
+    /** Update a stack. */
+    updateStack(id: string, input: Partial<CreateStackInput>): Promise<StackResponse>;
+    /** Delete a stack. */
+    deleteStack(id: string): Promise<{
+        success: boolean;
+    }>;
+    /** Add a provider to a stack. */
+    add(provider: string, input?: AddProviderInput): Promise<ProviderResponse>;
+    /** Refresh the access token. */
+    refreshToken(refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    /** Update the access token. */
+    setAccessToken(accessToken: string): void;
+}
+/**
+ * Factory function to create a Brokr management client.
+ *
+ * @example
+ * ```typescript
+ * import { createBrokrClient } from '@brokr/sdk';
+ *
+ * const client = createBrokrClient({
+ *   apiUrl: 'https://brokr.sh',
+ *   accessToken: process.env.BROKR_ACCESS_TOKEN!,
+ * });
+ *
+ * const stack = await client.create({ stack: 'web-app', name: 'my-app' });
+ * ```
+ */
+export default function createBrokrClient(config: BrokrConfig): BrokrClient;
+export declare const create: typeof createBrokrClient;
+//# sourceMappingURL=management.d.ts.map

package/dist/src/management.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"management.d.ts","sourceRoot":"","sources":["../../src/management.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,UAAU,CAAC;AA4BlB;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAc;gBAEhB,MAAM,EAAE,WAAW;IAI/B,iDAAiD;IAC3C,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC;IAI7D,4CAA4C;IACtC,UAAU,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IAI5C,kCAAkC;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAIlD,sBAAsB;IAChB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAIvF,sBAAsB;IAChB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAI5D,iCAAiC;IAC3B,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIhF,gCAAgC;IAC1B,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAIhG,+BAA+B;IAC/B,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;CAG1C;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE1E;AAED,eAAO,MAAM,MAAM,0BAAoB,CAAC"}

package/dist/src/react/auth.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Brokr Auth React Components + Hooks
+ *
+ * Wraps Better Auth's React client with Brokr's DX.
+ *
+ * @example
+ * import { BrokrAuth, useUser, useAuth, SignIn, SignUp, UserButton } from '@brokr/sdk/react'
+ */
+import React from 'react';
+export interface AuthClientUser {
+    id: string;
+    email: string;
+    name: string | null;
+    avatarUrl: string | null;
+    emailVerified: boolean;
+}
+interface SignInRenderProps {
+    action: (formData: FormData) => Promise<void>;
+    error: string | null;
+    pending: boolean;
+}
+interface SignUpRenderProps {
+    action: (formData: FormData) => Promise<void>;
+    error: string | null;
+    pending: boolean;
+}
+export declare function BrokrAuth({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useUser(): {
+    user: AuthClientUser | null;
+    isLoaded: boolean;
+};
+export declare function useAuth(): {
+    signIn: (email: string, password: string) => Promise<void>;
+    signUp: (email: string, password: string, name?: string) => Promise<void>;
+    signOut: () => Promise<void>;
+    isSigningOut: boolean;
+};
+export declare function SignIn({ redirectTo, children, }: {
+    redirectTo?: string;
+    children?: (props: SignInRenderProps) => React.ReactNode;
+}): React.JSX.Element;
+export declare function SignUp({ redirectTo, children, }: {
+    redirectTo?: string;
+    children?: (props: SignUpRenderProps) => React.ReactNode;
+}): React.JSX.Element;
+export declare function UserButton(): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=auth.d.ts.map