@vtriv/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1073 @@
+// src/errors.ts
+class VtrivError extends Error {
+  code;
+  details;
+  status;
+  constructor(message, options) {
+    super(message);
+    this.name = "VtrivError";
+    this.code = options?.code;
+    this.details = options?.details;
+    this.status = options?.status;
+  }
+  static fromResponse(response, status) {
+    return new VtrivError(response.error, {
+      code: response.code,
+      details: response.details,
+      status
+    });
+  }
+}
+
+class AuthenticationError extends VtrivError {
+  constructor(message = "Authentication required") {
+    super(message, { status: 401 });
+    this.name = "AuthenticationError";
+  }
+}
+
+class AuthorizationError extends VtrivError {
+  constructor(message = "Not authorized") {
+    super(message, { status: 403 });
+    this.name = "AuthorizationError";
+  }
+}
+
+class NotFoundError extends VtrivError {
+  constructor(message = "Resource not found") {
+    super(message, { status: 404 });
+    this.name = "NotFoundError";
+  }
+}
+
+class ValidationError extends VtrivError {
+  constructor(message, details) {
+    super(message, { status: 400, details });
+    this.name = "ValidationError";
+  }
+}
+
+class RateLimitError extends VtrivError {
+  constructor(message = "Rate limit exceeded") {
+    super(message, { status: 429 });
+    this.name = "RateLimitError";
+  }
+}
+
+class NetworkError extends VtrivError {
+  constructor(message = "Network request failed", cause) {
+    super(message, { details: cause?.message });
+    this.name = "NetworkError";
+    this.cause = cause;
+  }
+}
+
+class TokenExpiredError extends VtrivError {
+  constructor() {
+    super("Token expired", { status: 401, code: "TOKEN_EXPIRED" });
+    this.name = "TokenExpiredError";
+  }
+}
+function createErrorFromStatus(status, response) {
+  switch (status) {
+    case 401:
+      return new AuthenticationError(response.error);
+    case 402:
+    case 429:
+      return new RateLimitError(response.error);
+    case 403:
+      return new AuthorizationError(response.error);
+    case 404:
+      return new NotFoundError(response.error);
+    case 400:
+      return new ValidationError(response.error, response.details);
+    default:
+      return VtrivError.fromResponse(response, status);
+  }
+}
+
+// src/utils/fetch.ts
+async function request(ctx, path, options = {}) {
+  const url = `${ctx.baseUrl}${path}`;
+  const method = options.method || "GET";
+  const headers = {
+    ...options.headers
+  };
+  const authHeader = await ctx.getAuthHeader();
+  if (authHeader) {
+    headers.Authorization = authHeader;
+  }
+  if (options.body && typeof options.body === "object" && !headers["Content-Type"]) {
+    headers["Content-Type"] = "application/json";
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: options.body ? typeof options.body === "string" ? options.body : JSON.stringify(options.body) : undefined,
+      signal: options.signal
+    });
+  } catch (err) {
+    throw new NetworkError("Network request failed", err instanceof Error ? err : undefined);
+  }
+  const contentType = response.headers.get("Content-Type") || "";
+  if (!contentType.includes("application/json")) {
+    if (!response.ok) {
+      throw createErrorFromStatus(response.status, {
+        error: `Request failed with status ${response.status}`
+      });
+    }
+    return response;
+  }
+  let data;
+  try {
+    const text = await response.text();
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    throw new NetworkError("Failed to parse response");
+  }
+  if (!response.ok) {
+    const errorResponse = data;
+    throw createErrorFromStatus(response.status, errorResponse);
+  }
+  return data;
+}
+async function* requestStream(ctx, path, options = {}) {
+  const url = `${ctx.baseUrl}${path}`;
+  const method = options.method || "POST";
+  const headers = {
+    Accept: "text/event-stream",
+    ...options.headers
+  };
+  const authHeader = await ctx.getAuthHeader();
+  if (authHeader) {
+    headers.Authorization = authHeader;
+  }
+  if (options.body && typeof options.body === "object") {
+    headers["Content-Type"] = "application/json";
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: options.body ? JSON.stringify(options.body) : undefined,
+      signal: options.signal
+    });
+  } catch (err) {
+    throw new NetworkError("Network request failed", err instanceof Error ? err : undefined);
+  }
+  if (!response.ok) {
+    const text = await response.text();
+    let errorResponse;
+    try {
+      errorResponse = JSON.parse(text);
+    } catch {
+      errorResponse = { error: text || `Request failed with status ${response.status}` };
+    }
+    throw createErrorFromStatus(response.status, errorResponse);
+  }
+  if (!response.body) {
+    throw new NetworkError("No response body for stream");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]")
+            return;
+          yield data;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function uploadFile(ctx, path, file, contentType) {
+  const url = `${ctx.baseUrl}${path}`;
+  const headers = {};
+  const authHeader = await ctx.getAuthHeader();
+  if (authHeader) {
+    headers.Authorization = authHeader;
+  }
+  if (contentType) {
+    headers["Content-Type"] = contentType;
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "PUT",
+      headers,
+      body: file
+    });
+  } catch (err) {
+    throw new NetworkError("Upload failed", err instanceof Error ? err : undefined);
+  }
+  if (!response.ok) {
+    const text = await response.text();
+    let errorResponse;
+    try {
+      errorResponse = JSON.parse(text);
+    } catch {
+      errorResponse = { error: text || `Upload failed with status ${response.status}` };
+    }
+    throw createErrorFromStatus(response.status, errorResponse);
+  }
+  return response;
+}
+
+// src/services/ai.ts
+class AiService {
+  ctx;
+  aiBaseUrl;
+  constructor(ctx, options = {}) {
+    this.ctx = ctx;
+    this.aiBaseUrl = options.aiBaseUrl || ctx.baseUrl;
+  }
+  get aiCtx() {
+    return {
+      baseUrl: this.aiBaseUrl,
+      getAuthHeader: this.ctx.getAuthHeader
+    };
+  }
+  async chat(messages, options = {}) {
+    return request(this.aiCtx, "/v1/chat/completions", {
+      method: "POST",
+      body: {
+        ...options,
+        messages,
+        stream: false
+      }
+    });
+  }
+  async* chatStream(messages, options = {}) {
+    const stream = requestStream(this.aiCtx, "/v1/chat/completions", {
+      method: "POST",
+      body: {
+        ...options,
+        messages,
+        stream: true
+      }
+    });
+    for await (const data of stream) {
+      try {
+        const chunk = JSON.parse(data);
+        const content = chunk.choices[0]?.delta?.content;
+        if (content) {
+          yield content;
+        }
+      } catch {}
+    }
+  }
+  async* chatStreamRaw(messages, options = {}) {
+    const stream = requestStream(this.aiCtx, "/v1/chat/completions", {
+      method: "POST",
+      body: {
+        ...options,
+        messages,
+        stream: true
+      }
+    });
+    for await (const data of stream) {
+      try {
+        yield JSON.parse(data);
+      } catch {}
+    }
+  }
+  async embed(input, model) {
+    const body = { input };
+    if (model) {
+      body.model = model;
+    }
+    return request(this.aiCtx, "/v1/embeddings", {
+      method: "POST",
+      body
+    });
+  }
+  async getUsage(periodDays = 30) {
+    return request(this.aiCtx, `/usage/stats?period=${periodDays}d`);
+  }
+  async getConfig() {
+    return request(this.aiCtx, "/config");
+  }
+  async updateConfig(config) {
+    return request(this.aiCtx, "/config", {
+      method: "PUT",
+      body: config
+    });
+  }
+}
+
+// src/services/auth.ts
+class AuthService {
+  ctx;
+  tokenManager;
+  project;
+  authBaseUrl;
+  constructor(ctx, options = {}) {
+    this.ctx = ctx;
+    this.tokenManager = options.tokenManager || null;
+    this.project = options.project || null;
+    this.authBaseUrl = options.authBaseUrl || ctx.baseUrl;
+  }
+  get authCtx() {
+    return {
+      baseUrl: this.authBaseUrl,
+      getAuthHeader: this.ctx.getAuthHeader
+    };
+  }
+  get accounts() {
+    return {
+      create: async (name) => {
+        return request(this.authCtx, "/accounts", {
+          method: "POST",
+          body: { name }
+        });
+      },
+      list: async () => {
+        const res = await request(this.authCtx, "/accounts");
+        return res.accounts;
+      },
+      get: async (id) => {
+        return request(this.authCtx, `/accounts/${id}`);
+      },
+      delete: async (id) => {
+        return request(this.authCtx, `/accounts/${id}`, {
+          method: "DELETE"
+        });
+      }
+    };
+  }
+  get projects() {
+    return {
+      create: async (name, config) => {
+        const res = await request(this.authCtx, "/projects", {
+          method: "POST",
+          body: { name, config }
+        });
+        return res.project;
+      },
+      list: async () => {
+        const res = await request(this.authCtx, "/projects");
+        return res.projects;
+      },
+      get: async (name) => {
+        return request(this.authCtx, `/projects/${name}`);
+      },
+      update: async (name, config) => {
+        return request(this.authCtx, `/projects/${name}`, {
+          method: "PUT",
+          body: config
+        });
+      },
+      delete: async (name) => {
+        return request(this.authCtx, `/projects/${name}`, {
+          method: "DELETE"
+        });
+      }
+    };
+  }
+  users(projectName) {
+    const project = projectName || this.project;
+    if (!project) {
+      throw new Error("Project name required for user management");
+    }
+    return {
+      create: async (data) => {
+        return request(this.authCtx, `/${project}/users`, {
+          method: "POST",
+          body: data
+        });
+      },
+      list: async () => {
+        const res = await request(this.authCtx, `/${project}/users`);
+        return res.users;
+      },
+      get: async (id) => {
+        return request(this.authCtx, `/${project}/users/${id}`);
+      },
+      update: async (id, data) => {
+        return request(this.authCtx, `/${project}/users/${id}`, {
+          method: "PUT",
+          body: data
+        });
+      },
+      delete: async (id) => {
+        return request(this.authCtx, `/${project}/users/${id}`, {
+          method: "DELETE"
+        });
+      }
+    };
+  }
+  apiKeys(projectName) {
+    const project = projectName || this.project;
+    if (!project) {
+      throw new Error("Project name required for API key management");
+    }
+    return {
+      create: async (name) => {
+        return request(this.authCtx, `/${project}/api-keys`, {
+          method: "POST",
+          body: { name }
+        });
+      },
+      list: async () => {
+        const res = await request(this.authCtx, `/${project}/api-keys`);
+        return res.api_keys;
+      },
+      delete: async (id) => {
+        return request(this.authCtx, `/${project}/api-keys/${id}`, {
+          method: "DELETE"
+        });
+      }
+    };
+  }
+  async mintToken(req = {}) {
+    if (!this.project) {
+      throw new Error("Project name required for minting tokens");
+    }
+    const res = await request(this.authCtx, `/${this.project}/token`, {
+      method: "POST",
+      body: req
+    });
+    return res.token;
+  }
+  async register(data) {
+    if (!this.project) {
+      throw new Error("Project name required for registration");
+    }
+    return request(this.authCtx, `/${this.project}/register`, {
+      method: "POST",
+      body: data
+    });
+  }
+  async login(credentials) {
+    if (!this.project) {
+      throw new Error("Project name required for login");
+    }
+    const tokens = await request(this.authCtx, `/${this.project}/login`, {
+      method: "POST",
+      body: credentials
+    });
+    if (this.tokenManager) {
+      this.tokenManager.setTokens(tokens);
+    }
+    return tokens;
+  }
+  async requestMagicLink(email) {
+    if (!this.project) {
+      throw new Error("Project name required for magic link");
+    }
+    return request(this.authCtx, `/${this.project}/magic-link`, {
+      method: "POST",
+      body: { email }
+    });
+  }
+  async refresh(refreshToken) {
+    if (!this.project) {
+      throw new Error("Project name required for token refresh");
+    }
+    const tokens = await request(this.authCtx, `/${this.project}/refresh`, {
+      method: "POST",
+      body: { refresh_token: refreshToken }
+    });
+    if (this.tokenManager) {
+      this.tokenManager.setTokens(tokens);
+    }
+    return tokens;
+  }
+  logout() {
+    if (this.tokenManager) {
+      this.tokenManager.clearTokens();
+    }
+  }
+  get me() {
+    if (!this.project) {
+      throw new Error("Project name required for user operations");
+    }
+    const project = this.project;
+    return {
+      get: async () => {
+        return request(this.authCtx, `/${project}/me`);
+      },
+      updateProfile: async (profile) => {
+        return request(this.authCtx, `/${project}/me`, {
+          method: "PATCH",
+          body: { profile }
+        });
+      },
+      changePassword: async (password) => {
+        return request(this.authCtx, `/${project}/me/password`, {
+          method: "POST",
+          body: { password }
+        });
+      }
+    };
+  }
+  isLoggedIn() {
+    return this.tokenManager?.hasTokens() ?? false;
+  }
+}
+
+// src/services/blob.ts
+class BlobService {
+  ctx;
+  project;
+  blobBaseUrl;
+  constructor(ctx, project, options = {}) {
+    this.ctx = ctx;
+    this.project = project;
+    this.blobBaseUrl = options.blobBaseUrl || ctx.baseUrl;
+  }
+  get blobCtx() {
+    return {
+      baseUrl: this.blobBaseUrl,
+      getAuthHeader: this.ctx.getAuthHeader
+    };
+  }
+  async upload(path, file, contentType) {
+    const response = await uploadFile(this.blobCtx, `/${this.project}/${path}`, file, contentType);
+    return response.json();
+  }
+  async download(path) {
+    const response = await request(this.blobCtx, `/${this.project}/${path}`);
+    return response.blob();
+  }
+  async stat(path) {
+    try {
+      const response = await request(this.blobCtx, `/${this.project}/${path}`, {
+        method: "HEAD"
+      });
+      return {
+        size: Number(response.headers.get("Content-Length") || 0),
+        contentType: response.headers.get("Content-Type") || "application/octet-stream",
+        etag: response.headers.get("ETag") || undefined,
+        lastModified: response.headers.get("Last-Modified") || undefined
+      };
+    } catch {
+      return null;
+    }
+  }
+  async delete(path) {
+    return request(this.blobCtx, `/${this.project}/${path}`, {
+      method: "DELETE"
+    });
+  }
+  async getPresignedDownloadUrl(path, expiresIn = 3600) {
+    return request(this.blobCtx, `/${this.project}/${path}?presign=${expiresIn}`);
+  }
+  async getPresignedUploadUrl(path, options = {}) {
+    return request(this.blobCtx, `/${this.project}/${path}`, {
+      method: "POST",
+      body: {
+        expiresIn: options.expiresIn || 3600,
+        contentType: options.contentType || "application/octet-stream"
+      }
+    });
+  }
+}
+
+// src/services/cron.ts
+class CronService {
+  ctx;
+  project;
+  cronBaseUrl;
+  constructor(ctx, project, options = {}) {
+    this.ctx = ctx;
+    this.project = project;
+    this.cronBaseUrl = options.cronBaseUrl || ctx.baseUrl;
+  }
+  get cronCtx() {
+    return {
+      baseUrl: this.cronBaseUrl,
+      getAuthHeader: this.ctx.getAuthHeader
+    };
+  }
+  async listJobs() {
+    const res = await request(this.cronCtx, `/${this.project}/jobs`);
+    return res.jobs;
+  }
+  async setJobs(jobs) {
+    return request(this.cronCtx, `/${this.project}/jobs`, {
+      method: "PUT",
+      body: jobs
+    });
+  }
+  async triggerJob(jobId) {
+    return request(this.cronCtx, `/${this.project}/jobs/${jobId}/trigger`, { method: "POST" });
+  }
+  async uploadScript(name, content) {
+    const url = `${this.cronBaseUrl}/${this.project}/scripts/${name}`;
+    const authHeader = await this.ctx.getAuthHeader();
+    const headers = {
+      "Content-Type": "text/plain"
+    };
+    if (authHeader) {
+      headers.Authorization = authHeader;
+    }
+    const response = await fetch(url, {
+      method: "PUT",
+      headers,
+      body: content
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || "Upload failed");
+    }
+    return response.json();
+  }
+  async getScript(name) {
+    const url = `${this.cronBaseUrl}/${this.project}/scripts/${name}`;
+    const authHeader = await this.ctx.getAuthHeader();
+    const headers = {};
+    if (authHeader) {
+      headers.Authorization = authHeader;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || "Fetch failed");
+    }
+    return response.text();
+  }
+  async deleteScript(name) {
+    return request(this.cronCtx, `/${this.project}/scripts/${name}`, {
+      method: "DELETE"
+    });
+  }
+  async getRuns(options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit) {
+      params.set("limit", String(options.limit));
+    }
+    if (options.jobId) {
+      params.set("job_id", options.jobId);
+    }
+    const query = params.toString();
+    const path = query ? `/${this.project}/runs?${query}` : `/${this.project}/runs`;
+    const res = await request(this.cronCtx, path);
+    return res.runs;
+  }
+}
+
+// src/services/db.ts
+class DbService {
+  ctx;
+  project;
+  dbBaseUrl;
+  constructor(ctx, project, options = {}) {
+    this.ctx = ctx;
+    this.project = project;
+    this.dbBaseUrl = options.dbBaseUrl || ctx.baseUrl;
+  }
+  get dbCtx() {
+    return {
+      baseUrl: this.dbBaseUrl,
+      getAuthHeader: this.ctx.getAuthHeader
+    };
+  }
+  collection(name) {
+    const basePath = `/${this.project}/${name}`;
+    return {
+      list: async (options = {}) => {
+        const params = new URLSearchParams;
+        if (options.limit !== undefined) {
+          params.set("_limit", String(options.limit));
+        }
+        if (options.cursor) {
+          params.set("_cursor", options.cursor);
+        }
+        if (options.sort) {
+          params.set("_sort", options.sort);
+        }
+        if (options.filter) {
+          for (const [key, value] of Object.entries(options.filter)) {
+            params.set(key, String(value));
+          }
+        }
+        const query = params.toString();
+        const path = query ? `${basePath}?${query}` : basePath;
+        return request(this.dbCtx, path);
+      },
+      get: async (id) => {
+        return request(this.dbCtx, `${basePath}/${id}`);
+      },
+      create: async (data) => {
+        return request(this.dbCtx, basePath, {
+          method: "POST",
+          body: data
+        });
+      },
+      replace: async (id, data) => {
+        return request(this.dbCtx, `${basePath}/${id}`, {
+          method: "PUT",
+          body: data
+        });
+      },
+      patch: async (id, data) => {
+        return request(this.dbCtx, `${basePath}/${id}`, {
+          method: "PATCH",
+          body: data
+        });
+      },
+      delete: async (id) => {
+        return request(this.dbCtx, `${basePath}/${id}`, {
+          method: "DELETE"
+        });
+      },
+      getSchema: async () => {
+        return request(this.dbCtx, `${basePath}/_schema`);
+      },
+      setSchema: async (schema) => {
+        return request(this.dbCtx, `${basePath}/_schema`, {
+          method: "PUT",
+          body: schema
+        });
+      }
+    };
+  }
+  async batch(operations) {
+    return request(this.dbCtx, `/${this.project}/_batch`, {
+      method: "POST",
+      body: { ops: operations }
+    });
+  }
+}
+
+// src/services/search.ts
+class SearchService {
+  ctx;
+  project;
+  searchBaseUrl;
+  constructor(ctx, project, options = {}) {
+    this.ctx = ctx;
+    this.project = project;
+    this.searchBaseUrl = options.searchBaseUrl || ctx.baseUrl;
+  }
+  get searchCtx() {
+    return {
+      baseUrl: this.searchBaseUrl,
+      getAuthHeader: this.ctx.getAuthHeader
+    };
+  }
+  index(name) {
+    const basePath = `/${this.project}/${name}`;
+    return {
+      getConfig: async () => {
+        return request(this.searchCtx, `${basePath}/_config`);
+      },
+      setConfig: async (config) => {
+        return request(this.searchCtx, `${basePath}/_config`, {
+          method: "PUT",
+          body: config
+        });
+      },
+      delete: async () => {
+        return request(this.searchCtx, `${basePath}/_config`, {
+          method: "DELETE"
+        });
+      },
+      index: async (doc) => {
+        return request(this.searchCtx, basePath, {
+          method: "POST",
+          body: doc
+        });
+      },
+      deleteDocument: async (id) => {
+        return request(this.searchCtx, `${basePath}/${id}`, {
+          method: "DELETE"
+        });
+      },
+      search: async (query, options = {}) => {
+        const params = new URLSearchParams({ q: query });
+        if (options.limit !== undefined) {
+          params.set("limit", String(options.limit));
+        }
+        const res = await request(this.searchCtx, `${basePath}/search?${params.toString()}`);
+        return res.results;
+      }
+    };
+  }
+}
+
+// src/utils/token.ts
+var REFRESH_BUFFER_MS = 5000;
+function decodeJwt(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+      return null;
+    const payload = parts[1];
+    const decoded = typeof atob !== "undefined" ? atob(payload.replace(/-/g, "+").replace(/_/g, "/")) : Buffer.from(payload, "base64url").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function isTokenExpired(token, bufferMs = REFRESH_BUFFER_MS) {
+  const payload = decodeJwt(token);
+  if (!payload?.exp)
+    return true;
+  const expiresAt = payload.exp * 1000;
+  const now = Date.now();
+  return now >= expiresAt - bufferMs;
+}
+function getTokenExpiresIn(token) {
+  const payload = decodeJwt(token);
+  if (!payload?.exp)
+    return 0;
+  const expiresAt = payload.exp * 1000;
+  return Math.max(0, expiresAt - Date.now());
+}
+
+class TokenManager {
+  accessToken = null;
+  refreshToken = null;
+  refreshPromise = null;
+  refreshFn = null;
+  onRefresh = null;
+  constructor(options) {
+    this.accessToken = options?.accessToken || null;
+    this.refreshToken = options?.refreshToken || null;
+    this.refreshFn = options?.refreshFn || null;
+    this.onRefresh = options?.onRefresh || null;
+  }
+  setTokens(tokens) {
+    this.accessToken = tokens.access_token;
+    this.refreshToken = tokens.refresh_token;
+  }
+  clearTokens() {
+    this.accessToken = null;
+    this.refreshToken = null;
+  }
+  hasTokens() {
+    return this.accessToken !== null;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  async getValidAccessToken() {
+    if (!this.accessToken) {
+      throw new TokenExpiredError;
+    }
+    if (!isTokenExpired(this.accessToken)) {
+      return this.accessToken;
+    }
+    if (!this.refreshToken) {
+      throw new TokenExpiredError;
+    }
+    if (!this.refreshFn) {
+      throw new TokenExpiredError;
+    }
+    if (!this.refreshPromise) {
+      this.refreshPromise = this.doRefresh();
+    }
+    try {
+      const tokens = await this.refreshPromise;
+      return tokens.access_token;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  async doRefresh() {
+    if (!this.refreshToken || !this.refreshFn) {
+      throw new TokenExpiredError;
+    }
+    const tokens = await this.refreshFn(this.refreshToken);
+    this.setTokens(tokens);
+    if (this.onRefresh) {
+      this.onRefresh(tokens);
+    }
+    return tokens;
+  }
+  setRefreshFn(fn) {
+    this.refreshFn = fn;
+  }
+}
+
+// src/client.ts
+function isAdminConfig(config) {
+  return "adminKey" in config && !!config.adminKey;
+}
+function isBackendConfig(config) {
+  return "apiKey" in config && !!config.apiKey;
+}
+function isClientConfig(config) {
+  return "project" in config && !("apiKey" in config) && !("adminKey" in config);
+}
+
+class VtrivClient {
+  config;
+  tokenManager = null;
+  ctx;
+  serviceUrls;
+  _auth = null;
+  _db = null;
+  _blob = null;
+  _search = null;
+  _ai = null;
+  _cron = null;
+  constructor(config, serviceUrls = {}) {
+    this.config = config;
+    this.serviceUrls = serviceUrls;
+    if (isClientConfig(config)) {
+      this.tokenManager = new TokenManager({
+        accessToken: config.accessToken,
+        refreshToken: config.refreshToken,
+        onRefresh: config.onTokenRefresh
+      });
+    }
+    this.ctx = {
+      baseUrl: config.baseUrl,
+      getAuthHeader: this.getAuthHeader.bind(this)
+    };
+    if (this.tokenManager && isClientConfig(config)) {
+      this.tokenManager.setRefreshFn(async (refreshToken) => {
+        return this.auth.refresh(refreshToken);
+      });
+    }
+  }
+  async getAuthHeader() {
+    if (isAdminConfig(this.config)) {
+      return `Bearer ${this.config.adminKey}`;
+    }
+    if (isBackendConfig(this.config)) {
+      return `Bearer ${this.config.apiKey}`;
+    }
+    if (this.tokenManager) {
+      try {
+        const token = await this.tokenManager.getValidAccessToken();
+        return `Bearer ${token}`;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  get project() {
+    if (isBackendConfig(this.config) || isClientConfig(this.config)) {
+      return this.config.project;
+    }
+    return null;
+  }
+  get auth() {
+    if (!this._auth) {
+      this._auth = new AuthService(this.ctx, {
+        tokenManager: this.tokenManager || undefined,
+        project: this.project || undefined,
+        authBaseUrl: this.serviceUrls.auth
+      });
+    }
+    return this._auth;
+  }
+  get db() {
+    const project = this.project;
+    if (!project) {
+      throw new Error("DbService requires a project. Use backend or frontend mode.");
+    }
+    if (!this._db) {
+      this._db = new DbService(this.ctx, project, {
+        dbBaseUrl: this.serviceUrls.db
+      });
+    }
+    return this._db;
+  }
+  get blob() {
+    const project = this.project;
+    if (!project) {
+      throw new Error("BlobService requires a project. Use backend or frontend mode.");
+    }
+    if (!this._blob) {
+      this._blob = new BlobService(this.ctx, project, {
+        blobBaseUrl: this.serviceUrls.blob
+      });
+    }
+    return this._blob;
+  }
+  get search() {
+    const project = this.project;
+    if (!project) {
+      throw new Error("SearchService requires a project. Use backend or frontend mode.");
+    }
+    if (!this._search) {
+      this._search = new SearchService(this.ctx, project, {
+        searchBaseUrl: this.serviceUrls.search
+      });
+    }
+    return this._search;
+  }
+  get ai() {
+    if (!this._ai) {
+      this._ai = new AiService(this.ctx, {
+        aiBaseUrl: this.serviceUrls.ai
+      });
+    }
+    return this._ai;
+  }
+  get cron() {
+    const project = this.project;
+    if (!project) {
+      throw new Error("CronService requires a project. Use backend or frontend mode.");
+    }
+    if (!this._cron) {
+      this._cron = new CronService(this.ctx, project, {
+        cronBaseUrl: this.serviceUrls.cron
+      });
+    }
+    return this._cron;
+  }
+  setTokens(tokens) {
+    if (!this.tokenManager) {
+      throw new Error("Token management only available in frontend mode");
+    }
+    this.tokenManager.setTokens(tokens);
+  }
+  clearTokens() {
+    if (this.tokenManager) {
+      this.tokenManager.clearTokens();
+    }
+  }
+  isAuthenticated() {
+    if (isAdminConfig(this.config) || isBackendConfig(this.config)) {
+      return true;
+    }
+    return this.tokenManager?.hasTokens() ?? false;
+  }
+  getAccessToken() {
+    return this.tokenManager?.getAccessToken() ?? null;
+  }
+}
+export {
+  isTokenExpired,
+  getTokenExpiresIn,
+  decodeJwt,
+  VtrivError,
+  VtrivClient,
+  ValidationError,
+  TokenManager,
+  TokenExpiredError,
+  SearchService,
+  RateLimitError,
+  NotFoundError,
+  NetworkError,
+  DbService,
+  CronService,
+  BlobService,
+  AuthorizationError,
+  AuthenticationError,
+  AuthService,
+  AiService
+};