@brokr/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,568 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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, BrokrAIClient, BrokrStorageClient, BrokrEmailClient, BrokrRuntime;
+var init_runtime = __esm({
+  "src/runtime.ts"() {
+    "use strict";
+    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";
+      }
+    };
+    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;
+      }
+    };
+  }
+});
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  BrokrAIClient: () => BrokrAIClient,
+  BrokrClient: () => BrokrClient,
+  BrokrEmailClient: () => BrokrEmailClient,
+  BrokrError: () => BrokrError,
+  BrokrRuntime: () => BrokrRuntime,
+  BrokrStorageClient: () => BrokrStorageClient,
+  authMiddleware: () => authMiddleware,
+  create: () => create,
+  createBrokr: () => createBrokr,
+  createBrokrClient: () => createBrokrClient
+});
+module.exports = __toCommonJS(index_exports);
+init_runtime();
+init_auth();
+
+// src/management.ts
+async function trpcRequest(config, procedure, input) {
+  const url = new URL(`${config.apiUrl}/api/trpc/${procedure}`);
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${config.accessToken}`,
+      ...config.headers
+    },
+    body: JSON.stringify(input),
+    signal: config.timeout ? AbortSignal.timeout(config.timeout) : void 0
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: "Request failed" }));
+    throw new Error(error.message || `HTTP ${response.status}`);
+  }
+  const result = await response.json();
+  return result.data;
+}
+var BrokrClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /** Create a new stack with default providers. */
+  async create(input) {
+    return trpcRequest(this.config, "v1.stack.create", input);
+  }
+  /** List all stacks for the current user. */
+  async listStacks() {
+    return trpcRequest(this.config, "v1.stack.list", {});
+  }
+  /** Get a specific stack by ID. */
+  async getStack(id) {
+    return trpcRequest(this.config, "v1.stack.get", { id });
+  }
+  /** Update a stack. */
+  async updateStack(id, input) {
+    return trpcRequest(this.config, "v1.stack.update", { id, ...input });
+  }
+  /** Delete a stack. */
+  async deleteStack(id) {
+    return trpcRequest(this.config, "v1.stack.delete", { id });
+  }
+  /** Add a provider to a stack. */
+  async add(provider, input) {
+    return trpcRequest(this.config, "v1.provider.add", { provider, ...input });
+  }
+  /** Refresh the access token. */
+  async refreshToken(refreshToken) {
+    return trpcRequest(this.config, "v1.auth.refresh", { refreshToken });
+  }
+  /** Update the access token. */
+  setAccessToken(accessToken) {
+    this.config.accessToken = accessToken;
+  }
+};
+function createBrokrClient(config) {
+  return new BrokrClient(config);
+}
+var create = createBrokrClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrokrAIClient,
+  BrokrClient,
+  BrokrEmailClient,
+  BrokrError,
+  BrokrRuntime,
+  BrokrStorageClient,
+  authMiddleware,
+  create,
+  createBrokr,
+  createBrokrClient
+});