@lumerahq/ui 0.5.0

package/README.md

@@ -0,0 +1,69 @@
+# @lumerahq/ui
+
+React component library and utilities for building Lumera custom applications.
+
+## Installation
+
+```bash
+npm install @lumerahq/ui
+```
+
+## Features
+
+- **UI Components** - Buttons, cards, tables, modals, sidebar, and more (built on shadcn/ui)
+- **Data Table** - Full-featured table with filtering, sorting, and pagination
+- **Bridge Module** - Parent-iframe communication for embedded apps
+- **API Utilities** - PocketBase client with SQL, CRUD, file, and email operations
+- **Automation Runner** - Start and monitor automation runs
+- **React Query Integration** - Data fetching hooks
+
+## Usage
+
+### Components
+
+```tsx
+import { Button, Card, DataTable } from '@lumerahq/ui';
+```
+
+### API Utilities
+
+```tsx
+import { pbSql, pbList, pbGet, pbCreate } from '@lumerahq/ui/lib';
+
+// SQL queries
+const result = await pbSql<{ id: string; name: string }>({
+  sql: 'SELECT id, name FROM users WHERE active = true'
+});
+
+// CRUD operations
+const items = await pbList<User>('users', { filter: 'active = true' });
+const user = await pbGet<User>('users', 'user-id');
+```
+
+### Automation Runner
+
+```tsx
+import { createRun, pollRun } from '@lumerahq/ui/lib';
+
+const run = await createRun({
+  automationId: 'my-automation-id',
+  inputs: { param: 'value' },
+});
+
+const result = await pollRun(run.id);
+```
+
+## Standalone Development
+
+For developing outside of a Lumera iframe, create a `.env.local` file:
+
+```bash
+cp .env.example .env.local
+# Edit .env.local with your credentials
+```
+
+Get your auth token by running `lumera login` and copying from `.lumera/credentials.json`.
+
+## License
+
+MIT

package/dist/api-BNY_eNKa.js

@@ -0,0 +1,262 @@
+import { p as parentApiRequest, B as BridgeError } from "./automations-DU4weMpK.js";
+const API_PREFIX = "/api";
+const buildUrl = (path) => {
+  const normalized = path.startsWith("/") ? path : `/${path}`;
+  return normalized.startsWith(API_PREFIX) ? normalized : `${API_PREFIX}${normalized}`;
+};
+const request = async (path, options) => {
+  const response = await parentApiRequest({
+    ...options,
+    url: buildUrl(path)
+  });
+  if (!response.ok) {
+    const message = extractErrorMessage(response);
+    throw new BridgeError(message, response.status, response);
+  }
+  return parseResponseBody(response);
+};
+const extractErrorMessage = (response) => {
+  if (typeof response.error === "string" && response.error.trim()) {
+    return response.error;
+  }
+  if (typeof response.body === "string" && response.body.trim()) {
+    return response.body;
+  }
+  return `Request failed (${response.status})`;
+};
+const parseResponseBody = (response) => {
+  if (typeof response.body === "string") {
+    try {
+      return JSON.parse(response.body);
+    } catch {
+      return response.body;
+    }
+  }
+  return response.body;
+};
+const validateSql = (req) => {
+  const trimmed = req.sql?.trim();
+  if (!trimmed) {
+    throw new Error("SQL string is required");
+  }
+  if (req.params && req.args) {
+    throw new Error("Use either named params or positional args, not both");
+  }
+  return trimmed;
+};
+const fileToBase64 = (file) => new Promise((resolve, reject) => {
+  const reader = new FileReader();
+  reader.onloadend = () => {
+    const result = reader.result;
+    resolve(result.split(",")[1]);
+  };
+  reader.onerror = reject;
+  reader.readAsDataURL(file);
+});
+async function pbSql(req) {
+  const sql = validateSql(req);
+  return request("/pb/sql", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: { ...req, sql }
+  });
+}
+async function pbGet(collection, id, expand) {
+  if (!collection) throw new Error("Collection is required for pbGet");
+  if (!id) throw new Error("Record ID is required for pbGet");
+  const params = expand ? `?expand=${encodeURIComponent(expand)}` : "";
+  return request(`/pb/collections/${encodeURIComponent(collection)}/records/${encodeURIComponent(id)}${params}`, {
+    method: "GET"
+  });
+}
+async function pbList(collection, options = {}) {
+  if (!collection) throw new Error("Collection is required for pbList");
+  const { page = 1, perPage = 20, filter, sort, expand } = options;
+  if (page < 1) throw new Error("Page must be >= 1");
+  if (perPage < 1 || perPage > 500) throw new Error("perPage must be between 1 and 500");
+  const params = new URLSearchParams({
+    page: String(page),
+    perPage: String(perPage)
+  });
+  if (filter) params.set("filter", filter);
+  if (sort) params.set("sort", sort);
+  if (expand) params.set("expand", expand);
+  return request(`/pb/collections/${encodeURIComponent(collection)}/records?${params}`, {
+    method: "GET"
+  });
+}
+async function pbSearch(collection, query, options = {}) {
+  if (!collection) throw new Error("Collection is required");
+  const { page = 1, perPage = 20, sort, expand } = options;
+  const params = new URLSearchParams({
+    q: query,
+    page: String(page),
+    perPage: String(perPage)
+  });
+  if (sort) params.set("sort", sort);
+  if (expand) params.set("expand", expand);
+  return request(`/pb/collections/${encodeURIComponent(collection)}/search?${params}`, {
+    method: "GET"
+  });
+}
+async function pbCreate(collection, data) {
+  if (!collection) throw new Error("Collection is required");
+  return request(`/pb/collections/${encodeURIComponent(collection)}/records`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: data
+  });
+}
+async function pbUpdate(collection, id, data) {
+  if (!collection) throw new Error("Collection is required");
+  if (!id) throw new Error("Record ID is required");
+  return request(`/pb/collections/${encodeURIComponent(collection)}/records/${encodeURIComponent(id)}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: data
+  });
+}
+async function pbDelete(collection, id) {
+  if (!collection) throw new Error("Collection is required");
+  if (!id) throw new Error("Record ID is required");
+  await request(`/pb/collections/${encodeURIComponent(collection)}/records/${encodeURIComponent(id)}`, {
+    method: "DELETE"
+  });
+}
+const MAX_BULK_SIZE = 1e3;
+async function pbBulkUpdate(collection, records) {
+  if (!collection) throw new Error("Collection is required for pbBulkUpdate");
+  if (!records.length) return { succeeded: 0, failed: 0, errors: [] };
+  if (records.length > MAX_BULK_SIZE) {
+    throw new Error(`Bulk update limited to ${MAX_BULK_SIZE} records. Consider batching larger operations.`);
+  }
+  return request(`/pb/collections/${encodeURIComponent(collection)}/records/bulk/update`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: { records, transaction: true }
+  });
+}
+async function pbBulkDelete(collection, ids) {
+  if (!collection) throw new Error("Collection is required for pbBulkDelete");
+  if (!ids.length) return { succeeded: 0, failed: 0, errors: [] };
+  if (ids.length > MAX_BULK_SIZE) {
+    throw new Error(`Bulk delete limited to ${MAX_BULK_SIZE} records. Consider batching larger operations.`);
+  }
+  return request(`/pb/collections/${encodeURIComponent(collection)}/records/bulk/delete`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: { ids }
+  });
+}
+async function pbUpsert(collection, data) {
+  if (!collection) throw new Error("Collection is required");
+  if (!data.external_id) throw new Error("external_id is required for upsert");
+  return request(`/pb/collections/${encodeURIComponent(collection)}/records/upsert`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: data
+  });
+}
+async function getUploadUrl(filename, contentType, options) {
+  if (!filename) throw new Error("Filename is required");
+  if (!options.collectionId) throw new Error("Collection ID is required");
+  if (!options.fieldName) throw new Error("Field name is required");
+  return request("/pb/uploads/presign", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: {
+      collection_id: options.collectionId,
+      field_name: options.fieldName,
+      filename,
+      content_type: contentType
+    }
+  });
+}
+const DEFAULT_UPLOAD_TIMEOUT_MS = 6e4;
+async function uploadFile(file, options) {
+  const { object_key, upload_url } = await getUploadUrl(file.name, file.type || "application/octet-stream", options);
+  if (!upload_url) {
+    throw new Error("Missing upload URL in response");
+  }
+  const base64 = await fileToBase64(file);
+  const contentType = file.type || "application/octet-stream";
+  const response = await parentApiRequest({
+    method: "PUT",
+    url: upload_url,
+    headers: { "Content-Type": contentType },
+    body: base64,
+    isBase64: true,
+    timeout: options.timeout ?? DEFAULT_UPLOAD_TIMEOUT_MS
+  });
+  if (!response.ok) {
+    throw new BridgeError(`Upload failed: ${response.error || response.status}`, response.status);
+  }
+  const descriptor = {
+    object_key,
+    original_name: file.name,
+    size: file.size,
+    content_type: contentType,
+    uploaded_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return { objectKey: object_key, descriptor };
+}
+async function getDownloadUrl(objectKey) {
+  if (!objectKey) throw new Error("Object key is required");
+  const response = await request("/pb/uploads/download", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: { object_key: objectKey }
+  });
+  if (!response?.download_url) {
+    throw new Error("Missing download URL in response");
+  }
+  return response.download_url;
+}
+async function sendEmail(options) {
+  if (!options.to || Array.isArray(options.to) && options.to.length === 0) {
+    throw new Error("At least one recipient is required");
+  }
+  if (!options.subject?.trim()) {
+    throw new Error("Subject is required");
+  }
+  if (!options.body_html && !options.body_text) {
+    throw new Error("At least one of body_html or body_text is required");
+  }
+  const payload = {
+    to: Array.isArray(options.to) ? options.to : [options.to],
+    subject: options.subject
+  };
+  if (options.body_html) payload.body_html = options.body_html;
+  if (options.body_text) payload.body_text = options.body_text;
+  if (options.cc) payload.cc = Array.isArray(options.cc) ? options.cc : [options.cc];
+  if (options.bcc) payload.bcc = Array.isArray(options.bcc) ? options.bcc : [options.bcc];
+  if (options.from_address) payload.from = options.from_address;
+  if (options.from_name) payload.from_name = options.from_name;
+  if (options.reply_to) payload.reply_to = options.reply_to;
+  if (options.tags) payload.tags = options.tags;
+  return request("/email/send", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: payload
+  });
+}
+async function pbUpdateRecord(collectionId, recordId, data) {
+  return pbUpdate(collectionId, recordId, data);
+}
+export {
+  getUploadUrl as a,
+  pbBulkUpdate as b,
+  pbCreate as c,
+  pbDelete as d,
+  pbGet as e,
+  pbList as f,
+  getDownloadUrl as g,
+  pbSearch as h,
+  pbSql as i,
+  pbUpdate as j,
+  pbUpdateRecord as k,
+  pbUpsert as l,
+  pbBulkDelete as p,
+  sendEmail as s,
+  uploadFile as u
+};

package/dist/automations-DU4weMpK.js

@@ -0,0 +1,369 @@
+const DEFAULT_TIMEOUT_MS = 15e3;
+const EXPECTED_PARENT_ORIGIN = "https://*.lumerahq.com";
+class BridgeError extends Error {
+  status;
+  response;
+  constructor(message, status, response) {
+    super(message);
+    this.name = "BridgeError";
+    this.status = status;
+    this.response = response;
+  }
+}
+const pendingRequests = /* @__PURE__ */ new Map();
+const initListeners = /* @__PURE__ */ new Set();
+let listenerAttached = false;
+const log = (...args) => {
+};
+const generateId = () => {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+};
+const isAllowedOrigin = (origin) => {
+  if (!origin || !EXPECTED_PARENT_ORIGIN) return false;
+  if (origin === EXPECTED_PARENT_ORIGIN) return true;
+  if (origin.startsWith("http://localhost:")) return true;
+  if (EXPECTED_PARENT_ORIGIN.includes("*")) {
+    try {
+      const originUrl = new URL(origin);
+      const hostnameSuffix = EXPECTED_PARENT_ORIGIN.replace(/^https?:\/\//, "").replace(/^\*\./, "");
+      const expectedProtocol = EXPECTED_PARENT_ORIGIN.startsWith("https") ? "https:" : "http:";
+      const hostMatches = originUrl.hostname === hostnameSuffix || originUrl.hostname.endsWith(`.${hostnameSuffix}`);
+      const protocolMatches = originUrl.protocol === expectedProtocol;
+      return hostMatches && protocolMatches;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+};
+const handleMessage = (event) => {
+  if (event.source !== window.parent) {
+    return;
+  }
+  if (!isAllowedOrigin(event.origin)) {
+    log("Ignoring message from unexpected origin", {
+      expected: EXPECTED_PARENT_ORIGIN,
+      received: event.origin
+    });
+    return;
+  }
+  const { type, payload } = event.data ?? {};
+  if (type === "init") {
+    initListeners.forEach((listener) => listener(payload));
+    return;
+  }
+  if (type === "response") {
+    const response = payload;
+    if (response?.id && pendingRequests.has(response.id)) {
+      pendingRequests.get(response.id)?.(response);
+      pendingRequests.delete(response.id);
+    } else {
+      log("No pending request found for response id", response?.id);
+    }
+  }
+};
+const ensureListener = () => {
+  if (listenerAttached || typeof window === "undefined") return;
+  listenerAttached = true;
+  window.addEventListener("message", handleMessage);
+};
+const isEmbedded = () => typeof window !== "undefined" && window.self !== window.top;
+const postReadyMessage = () => {
+  if (typeof window === "undefined") return;
+  ensureListener();
+  window.parent.postMessage({ type: "ready" }, "*");
+};
+const onInitMessage = (listener) => {
+  ensureListener();
+  initListeners.add(listener);
+  return () => initListeners.delete(listener);
+};
+const parentApiRequest = async (request2) => {
+  if (typeof window === "undefined" || !isEmbedded()) {
+    throw new BridgeError("App must be embedded in the Lumera host to make API requests");
+  }
+  ensureListener();
+  const id = generateId();
+  const timeout = request2.timeout ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      pendingRequests.delete(id);
+      reject(new BridgeError(`Request timed out after ${timeout}ms`, 408));
+    }, timeout);
+    pendingRequests.set(id, (payload) => {
+      clearTimeout(timeoutId);
+      resolve(payload);
+    });
+    window.parent.postMessage(
+      {
+        type: "request",
+        payload: {
+          id,
+          method: request2.method,
+          url: request2.url,
+          headers: request2.headers,
+          body: request2.body,
+          isBase64: request2.isBase64
+        }
+      },
+      "*"
+    );
+  });
+};
+const API_PREFIX = "/api";
+const TERMINAL_STATUSES = ["succeeded", "failed", "cancelled"];
+const ACTIVE_STATUSES = ["preparing", "queued", "running", "cancelling"];
+const isTerminalStatus = (status) => TERMINAL_STATUSES.includes(status);
+const isActiveStatus = (status) => ACTIVE_STATUSES.includes(status);
+const automationIdCache = /* @__PURE__ */ new Map();
+function clearAutomationCache(externalId) {
+  if (externalId) {
+    automationIdCache.delete(externalId);
+  } else {
+    automationIdCache.clear();
+  }
+}
+const buildUrl = (path) => {
+  const normalized = path.startsWith("/") ? path : `/${path}`;
+  return normalized.startsWith(API_PREFIX) ? normalized : `${API_PREFIX}${normalized}`;
+};
+const extractErrorMessage = (response) => {
+  if (typeof response.error === "string" && response.error.trim()) {
+    return response.error;
+  }
+  if (typeof response.body === "string" && response.body.trim()) {
+    return response.body;
+  }
+  return `Request failed (${response.status})`;
+};
+const parseResponseBody = (response) => {
+  if (typeof response.body === "string") {
+    try {
+      return JSON.parse(response.body);
+    } catch {
+      return response.body;
+    }
+  }
+  return response.body;
+};
+const request = async (path, options) => {
+  const response = await parentApiRequest({
+    ...options,
+    url: buildUrl(path)
+  });
+  if (!response.ok) {
+    const message = extractErrorMessage(response);
+    throw new BridgeError(message, response.status, response);
+  }
+  return parseResponseBody(response);
+};
+async function getAutomationByExternalId(externalId) {
+  if (!externalId) throw new Error("External ID is required");
+  const cached = automationIdCache.get(externalId);
+  if (cached) return cached;
+  const response = await request(
+    `/automations?external_id=${encodeURIComponent(externalId)}&limit=1`,
+    { method: "GET" }
+  );
+  const automation = response.automations?.[0];
+  if (!automation?.id) {
+    throw new Error(`Automation not found with external_id: ${externalId}`);
+  }
+  automationIdCache.set(externalId, automation.id);
+  return automation.id;
+}
+async function resolveAutomationId(automationId) {
+  if (automationId.includes(":")) {
+    return getAutomationByExternalId(automationId);
+  }
+  return automationId;
+}
+async function createRun(options) {
+  const { automationId, inputs, externalId, trigger, metadata } = options;
+  if (!automationId) throw new Error("Automation ID is required");
+  const resolvedId = await resolveAutomationId(automationId);
+  return request("/automation-runs", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: {
+      automation_id: resolvedId,
+      inputs: JSON.stringify(inputs ?? {}),
+      external_id: externalId,
+      trigger,
+      metadata
+    }
+  });
+}
+async function getRun(runId) {
+  if (!runId) throw new Error("Run ID is required");
+  return request(`/automation-runs/${encodeURIComponent(runId)}`, {
+    method: "GET"
+  });
+}
+async function listRuns(options = {}) {
+  const { automationId, externalId, limit = 10, offset = 0, dir = "desc" } = options;
+  const params = new URLSearchParams({
+    limit: String(limit),
+    offset: String(offset),
+    dir
+  });
+  if (automationId) {
+    const resolvedId = await resolveAutomationId(automationId);
+    params.set("automation_id", resolvedId);
+  }
+  if (externalId) params.set("external_id", externalId);
+  const response = await request(`/automation-runs?${params}`, { method: "GET" });
+  return response.data ?? [];
+}
+async function cancelRun(runId) {
+  if (!runId) throw new Error("Run ID is required");
+  return request(`/automation-runs/${encodeURIComponent(runId)}/cancel`, {
+    method: "POST"
+  });
+}
+async function pollRun(runId, options = {}) {
+  const { intervalMs = 2e3, timeoutMs = 5 * 60 * 1e3, onUpdate, signal } = options;
+  if (!runId) throw new Error("Run ID is required");
+  const startedAt = Date.now();
+  let lastRun = null;
+  const poll = async () => {
+    if (signal?.aborted) {
+      throw new Error("Polling aborted");
+    }
+    if (Date.now() - startedAt > timeoutMs) {
+      const error = new Error("Polling timed out before run completed");
+      if (lastRun) error.run = lastRun;
+      throw error;
+    }
+    const run = await getRun(runId);
+    lastRun = run;
+    onUpdate?.(run);
+    if (isTerminalStatus(run.status)) {
+      return run;
+    }
+    await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(resolve, intervalMs);
+      if (signal) {
+        signal.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(timeoutId);
+            reject(new Error("Polling aborted"));
+          },
+          { once: true }
+        );
+      }
+    });
+    return poll();
+  };
+  return poll();
+}
+async function ensureRun(options) {
+  const { automationId, externalId } = options;
+  const existing = await listRuns({
+    automationId,
+    externalId,
+    limit: 1
+  });
+  const active = existing.find((run) => isActiveStatus(run.status));
+  if (active) return active;
+  const succeeded = existing.find((run) => run.status === "succeeded");
+  if (succeeded) return succeeded;
+  return createRun(options);
+}
+async function getRunFiles(runId) {
+  if (!runId) throw new Error("Run ID is required");
+  const response = await request(
+    `/automation-runs/${encodeURIComponent(runId)}/files`,
+    { method: "GET" }
+  );
+  return response.files ?? [];
+}
+async function getRunFileUrl(runId, filename) {
+  if (!runId) throw new Error("Run ID is required");
+  if (!filename) throw new Error("Filename is required");
+  const response = await request(
+    `/automation-runs/${encodeURIComponent(runId)}/files/download-url?name=${encodeURIComponent(filename)}`,
+    { method: "GET" }
+  );
+  if (!response.download_url) {
+    throw new Error("Missing download URL in response");
+  }
+  return response.download_url;
+}
+const automationStatuses = {
+  TERMINAL_STATUSES,
+  ACTIVE_STATUSES,
+  isTerminal: isTerminalStatus,
+  isActive: isActiveStatus
+};
+async function createAutomationRun(options) {
+  return createRun({
+    automationId: options.agentId,
+    inputs: options.inputs,
+    externalId: options.externalId,
+    trigger: options.trigger,
+    metadata: options.metadata
+  });
+}
+const getAutomationRun = getRun;
+const cancelAutomationRun = cancelRun;
+async function ensureAutomationRun(options) {
+  return ensureRun({
+    automationId: options.agentId,
+    inputs: options.inputs,
+    externalId: options.externalId,
+    trigger: options.trigger,
+    metadata: options.metadata
+  });
+}
+const pollAutomationRun = pollRun;
+const listAutomationRunFiles = getRunFiles;
+const getAutomationRunFileDownloadUrl = getRunFileUrl;
+async function listRunsByAgent(params) {
+  return listRuns({
+    automationId: params.agentId,
+    limit: params.limit,
+    offset: params.offset
+  });
+}
+async function listRunsByExternalId(params) {
+  return listRuns({
+    automationId: params.agentId,
+    externalId: params.externalId,
+    limit: params.limit
+  });
+}
+export {
+  BridgeError as B,
+  EXPECTED_PARENT_ORIGIN as E,
+  postReadyMessage as a,
+  automationStatuses as b,
+  cancelAutomationRun as c,
+  cancelRun as d,
+  clearAutomationCache as e,
+  createAutomationRun as f,
+  createRun as g,
+  ensureAutomationRun as h,
+  isEmbedded as i,
+  ensureRun as j,
+  getAutomationByExternalId as k,
+  getAutomationRun as l,
+  getAutomationRunFileDownloadUrl as m,
+  getRun as n,
+  onInitMessage as o,
+  parentApiRequest as p,
+  getRunFiles as q,
+  getRunFileUrl as r,
+  isActiveStatus as s,
+  isTerminalStatus as t,
+  listAutomationRunFiles as u,
+  listRuns as v,
+  listRunsByAgent as w,
+  listRunsByExternalId as x,
+  pollAutomationRun as y,
+  pollRun as z
+};

package/dist/components/ApiDemo.d.ts

@@ -0,0 +1,2 @@
+export declare function ApiDemo(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ApiDemo.d.ts.map

package/dist/components/ApiDemo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiDemo.d.ts","sourceRoot":"","sources":["../../src/components/ApiDemo.tsx"],"names":[],"mappings":"AAYA,wBAAgB,OAAO,4CAoGtB"}