@bandeira-tech/b3nd-web 0.2.0

package/dist/chunk-G6JDROB4.js

@@ -0,0 +1,327 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// encrypt/mod.ts
+var mod_exports = {};
+__export(mod_exports, {
+  createAuthenticatedMessage: () => createAuthenticatedMessage,
+  createSignedEncryptedMessage: () => createSignedEncryptedMessage,
+  decrypt: () => decrypt,
+  decryptWithHex: () => decryptWithHex,
+  encrypt: () => encrypt,
+  generateEncryptionKeyPair: () => generateEncryptionKeyPair,
+  generateNonce: () => generateNonce,
+  generateRandomData: () => generateRandomData,
+  generateSigningKeyPair: () => generateSigningKeyPair,
+  sign: () => sign,
+  signWithHex: () => signWithHex,
+  verify: () => verify,
+  verifyAndDecrypt: () => verifyAndDecrypt
+});
+
+// shared/encoding.ts
+function encodeHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function decodeHex(hex) {
+  if (hex.length % 2 !== 0) {
+    throw new Error("Invalid hex input");
+  }
+  const buffer = new ArrayBuffer(hex.length / 2);
+  const bytes = new Uint8Array(buffer);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+function encodeBase64(bytes) {
+  if (typeof btoa === "function") {
+    let binary = "";
+    bytes.forEach((b) => binary += String.fromCharCode(b));
+    return btoa(binary);
+  }
+  return Buffer.from(bytes).toString("base64");
+}
+function decodeBase64(b64) {
+  if (typeof atob === "function") {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  return new Uint8Array(Buffer.from(b64, "base64"));
+}
+
+// encrypt/mod.ts
+async function generateSigningKeyPair() {
+  const keyPair = await crypto.subtle.generateKey(
+    {
+      name: "Ed25519",
+      namedCurve: "Ed25519"
+    },
+    true,
+    ["sign", "verify"]
+  );
+  const publicKeyBytes = await crypto.subtle.exportKey("raw", keyPair.publicKey);
+  const privateKeyBytes = await crypto.subtle.exportKey(
+    "pkcs8",
+    keyPair.privateKey
+  );
+  return {
+    publicKey: keyPair.publicKey,
+    privateKey: keyPair.privateKey,
+    publicKeyHex: encodeHex(new Uint8Array(publicKeyBytes)),
+    privateKeyHex: encodeHex(new Uint8Array(privateKeyBytes))
+  };
+}
+async function generateEncryptionKeyPair() {
+  const keyPair = await crypto.subtle.generateKey(
+    {
+      name: "X25519",
+      namedCurve: "X25519"
+    },
+    true,
+    ["deriveBits"]
+  );
+  const publicKeyBytes = await crypto.subtle.exportKey("raw", keyPair.publicKey);
+  return {
+    publicKey: keyPair.publicKey,
+    privateKey: keyPair.privateKey,
+    publicKeyHex: encodeHex(new Uint8Array(publicKeyBytes))
+  };
+}
+async function sign(privateKey, payload) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(JSON.stringify(payload));
+  const signature = await crypto.subtle.sign("Ed25519", privateKey, data);
+  return encodeHex(new Uint8Array(signature));
+}
+async function signWithHex(privateKeyHex, payload) {
+  const privateKeyBytes = decodeHex(privateKeyHex).buffer;
+  const privateKey = await crypto.subtle.importKey(
+    "pkcs8",
+    privateKeyBytes,
+    {
+      name: "Ed25519",
+      namedCurve: "Ed25519"
+    },
+    false,
+    ["sign"]
+  );
+  return await sign(privateKey, payload);
+}
+async function verify(publicKeyHex, signatureHex, payload) {
+  try {
+    const publicKeyBytes = decodeHex(publicKeyHex).buffer;
+    const publicKey = await crypto.subtle.importKey(
+      "raw",
+      publicKeyBytes,
+      {
+        name: "Ed25519",
+        namedCurve: "Ed25519"
+      },
+      false,
+      ["verify"]
+    );
+    const encoder = new TextEncoder();
+    const data = encoder.encode(JSON.stringify(payload));
+    const signatureBytes = decodeHex(signatureHex).buffer;
+    return await crypto.subtle.verify(
+      "Ed25519",
+      publicKey,
+      signatureBytes,
+      data
+    );
+  } catch (error) {
+    console.error("Verification error:", error);
+    return false;
+  }
+}
+async function encrypt(data, recipientPublicKeyHex) {
+  const ephemeralKeyPair = await generateEncryptionKeyPair();
+  const recipientPublicKeyBytes = decodeHex(recipientPublicKeyHex).buffer;
+  const recipientPublicKey = await crypto.subtle.importKey(
+    "raw",
+    recipientPublicKeyBytes,
+    {
+      name: "X25519",
+      namedCurve: "X25519"
+    },
+    false,
+    []
+  );
+  const sharedSecret = await crypto.subtle.deriveBits(
+    {
+      name: "X25519",
+      public: recipientPublicKey
+    },
+    ephemeralKeyPair.privateKey,
+    256
+  );
+  const aesKey = await crypto.subtle.importKey(
+    "raw",
+    sharedSecret,
+    {
+      name: "AES-GCM",
+      length: 256
+    },
+    false,
+    ["encrypt"]
+  );
+  const nonce = crypto.getRandomValues(new Uint8Array(12));
+  const encoder = new TextEncoder();
+  const plaintext = encoder.encode(JSON.stringify(data));
+  const ciphertext = await crypto.subtle.encrypt(
+    {
+      name: "AES-GCM",
+      iv: nonce
+    },
+    aesKey,
+    plaintext
+  );
+  return {
+    data: encodeBase64(new Uint8Array(ciphertext)),
+    nonce: encodeBase64(nonce),
+    ephemeralPublicKey: ephemeralKeyPair.publicKeyHex
+  };
+}
+async function decrypt(encryptedPayload, recipientPrivateKey) {
+  if (!encryptedPayload.ephemeralPublicKey) {
+    throw new Error("Missing ephemeral public key");
+  }
+  const ephemeralPublicKeyBytes = decodeHex(
+    encryptedPayload.ephemeralPublicKey
+  ).buffer;
+  const ephemeralPublicKey = await crypto.subtle.importKey(
+    "raw",
+    ephemeralPublicKeyBytes,
+    {
+      name: "X25519",
+      namedCurve: "X25519"
+    },
+    false,
+    []
+  );
+  const sharedSecret = await crypto.subtle.deriveBits(
+    {
+      name: "X25519",
+      public: ephemeralPublicKey
+    },
+    recipientPrivateKey,
+    256
+  );
+  const aesKey = await crypto.subtle.importKey(
+    "raw",
+    sharedSecret,
+    {
+      name: "AES-GCM",
+      length: 256
+    },
+    false,
+    ["decrypt"]
+  );
+  const ciphertext = new Uint8Array(decodeBase64(encryptedPayload.data));
+  const nonce = new Uint8Array(decodeBase64(encryptedPayload.nonce));
+  const plaintext = await crypto.subtle.decrypt(
+    {
+      name: "AES-GCM",
+      iv: nonce
+    },
+    aesKey,
+    ciphertext
+  );
+  const decoder = new TextDecoder();
+  const json = decoder.decode(plaintext);
+  return JSON.parse(json);
+}
+async function decryptWithHex(encryptedPayload, recipientPrivateKeyHex) {
+  const privateKeyBytes = decodeHex(recipientPrivateKeyHex).buffer;
+  const privateKey = await crypto.subtle.importKey(
+    "raw",
+    privateKeyBytes,
+    {
+      name: "X25519",
+      namedCurve: "X25519"
+    },
+    false,
+    ["deriveBits"]
+  );
+  return await decrypt(encryptedPayload, privateKey);
+}
+async function createAuthenticatedMessage(payload, signers) {
+  const auth = await Promise.all(
+    signers.map(async (signer) => {
+      const signature = await sign(signer.privateKey, payload);
+      return {
+        pubkey: signer.publicKeyHex,
+        signature
+      };
+    })
+  );
+  return {
+    auth,
+    payload
+  };
+}
+async function createSignedEncryptedMessage(data, signers, recipientPublicKeyHex) {
+  const encrypted = await encrypt(data, recipientPublicKeyHex);
+  const auth = await Promise.all(
+    signers.map(async (signer) => {
+      const signature = await sign(signer.privateKey, encrypted);
+      return {
+        pubkey: signer.publicKeyHex,
+        signature
+      };
+    })
+  );
+  return {
+    auth,
+    payload: encrypted
+  };
+}
+async function verifyAndDecrypt(message, recipientPrivateKey) {
+  const verificationResults = await Promise.all(
+    message.auth.map(async (authEntry) => {
+      const verified2 = await verify(
+        authEntry.pubkey,
+        authEntry.signature,
+        message.payload
+      );
+      return { pubkey: authEntry.pubkey, verified: verified2 };
+    })
+  );
+  const verified = verificationResults.every((r) => r.verified);
+  const signers = verificationResults.filter((r) => r.verified).map((r) => r.pubkey);
+  const data = await decrypt(message.payload, recipientPrivateKey);
+  return {
+    data,
+    verified,
+    signers
+  };
+}
+function generateNonce(length = 12) {
+  return crypto.getRandomValues(new Uint8Array(length));
+}
+function generateRandomData(size) {
+  return crypto.getRandomValues(new Uint8Array(size));
+}
+
+export {
+  generateSigningKeyPair,
+  generateEncryptionKeyPair,
+  sign,
+  signWithHex,
+  verify,
+  encrypt,
+  decrypt,
+  decryptWithHex,
+  createAuthenticatedMessage,
+  createSignedEncryptedMessage,
+  verifyAndDecrypt,
+  generateNonce,
+  generateRandomData,
+  mod_exports
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-PMBS2GFA.js

@@ -0,0 +1,223 @@
+// clients/http/mod.ts
+var HttpClient = class {
+  baseUrl;
+  headers;
+  timeout;
+  constructor(config) {
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.headers = config.headers || {};
+    this.timeout = config.timeout || 3e4;
+  }
+  /**
+   * Make an HTTP request with timeout
+   */
+  async request(path, options = {}) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const url = `${this.baseUrl}${path}`;
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.headers,
+          ...options.headers
+        },
+        signal: controller.signal
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Parse URI into components
+   * Example: "users://alice/profile" -> { protocol: "users", domain: "alice", path: "/profile" }
+   */
+  parseUri(uri) {
+    const url = new URL(uri);
+    return {
+      protocol: url.protocol.replace(":", ""),
+      domain: url.hostname,
+      path: url.pathname
+    };
+  }
+  async write(uri, value) {
+    try {
+      const { protocol, domain, path } = this.parseUri(uri);
+      const requestPath = `/api/v1/write/${protocol}/${domain}${path}`;
+      const response = await this.request(requestPath, {
+        method: "POST",
+        body: JSON.stringify({ value })
+      });
+      const result = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `Write failed: ${result.error || response.statusText}`
+        };
+      }
+      return {
+        success: true,
+        record: result.record
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async read(uri) {
+    try {
+      const { protocol, domain, path } = this.parseUri(uri);
+      const requestPath = `/api/v1/read/${protocol}/${domain}${path}`;
+      const response = await this.request(requestPath, {
+        method: "GET"
+      });
+      if (!response.ok) {
+        await response.text();
+        if (response.status === 404) {
+          return {
+            success: false,
+            error: "Not found"
+          };
+        }
+        return {
+          success: false,
+          error: `Read failed: ${response.statusText}`
+        };
+      }
+      const result = await response.json();
+      return {
+        success: true,
+        record: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async list(uri, options) {
+    try {
+      const { protocol, domain, path } = this.parseUri(uri);
+      const params = new URLSearchParams();
+      if (options == null ? void 0 : options.page) {
+        params.set("page", options.page.toString());
+      }
+      if (options == null ? void 0 : options.limit) {
+        params.set("limit", options.limit.toString());
+      }
+      if (options == null ? void 0 : options.pattern) {
+        params.set("pattern", options.pattern);
+      }
+      if (options == null ? void 0 : options.sortBy) {
+        params.set("sortBy", options.sortBy);
+      }
+      if (options == null ? void 0 : options.sortOrder) {
+        params.set("sortOrder", options.sortOrder);
+      }
+      const queryString = params.toString();
+      const pathPart = path === "/" ? "" : path;
+      const requestPath = `/api/v1/list/${protocol}/${domain}${pathPart}${queryString ? `?${queryString}` : ""}`;
+      const response = await this.request(requestPath, {
+        method: "GET"
+      });
+      if (!response.ok) {
+        return {
+          success: true,
+          data: [],
+          pagination: {
+            page: (options == null ? void 0 : options.page) || 1,
+            limit: (options == null ? void 0 : options.limit) || 50
+          }
+        };
+      }
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      return {
+        success: true,
+        data: [],
+        pagination: {
+          page: (options == null ? void 0 : options.page) || 1,
+          limit: (options == null ? void 0 : options.limit) || 50
+        }
+      };
+    }
+  }
+  async delete(uri) {
+    try {
+      const { protocol, domain, path } = this.parseUri(uri);
+      const requestPath = `/api/v1/delete/${protocol}/${domain}${path}`;
+      const response = await this.request(requestPath, {
+        method: "DELETE"
+      });
+      const result = response.ok ? await response.json() : { error: await response.text() };
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `Delete failed: ${result.error}`
+        };
+      }
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async health() {
+    try {
+      const response = await this.request("/api/v1/health", {
+        method: "GET"
+      });
+      if (!response.ok) {
+        return {
+          status: "unhealthy",
+          message: "Health check failed"
+        };
+      }
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async getSchema() {
+    try {
+      const response = await this.request("/api/v1/schema", {
+        method: "GET"
+      });
+      if (!response.ok) {
+        return [];
+      }
+      const result = await response.json();
+      if (result.schema && Array.isArray(result.schema)) {
+        return result.schema;
+      }
+      return [];
+    } catch (error) {
+      return [];
+    }
+  }
+  async cleanup() {
+  }
+};
+
+export {
+  HttpClient
+};

package/dist/chunk-QHDBFVLU.js

@@ -0,0 +1,87 @@
+// apps/mod.ts
+var AppsClient = class {
+  base;
+  api;
+  f;
+  authToken;
+  constructor(cfg) {
+    if (!cfg.appServerUrl) throw new Error("appServerUrl is required");
+    if (!cfg.apiBasePath) throw new Error("apiBasePath is required");
+    this.base = cfg.appServerUrl.replace(/\/$/, "");
+    this.api = (cfg.apiBasePath.startsWith("/") ? cfg.apiBasePath : `/${cfg.apiBasePath}`).replace(/\/$/, "");
+    if (cfg.authToken) this.authToken = cfg.authToken;
+    if (cfg.fetch) {
+      this.f = cfg.fetch;
+    } else if (typeof window !== "undefined" && typeof window.fetch === "function") {
+      this.f = window.fetch.bind(window);
+    } else {
+      this.f = fetch;
+    }
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  async health() {
+    const r = await this.f(`${this.base}${this.api}/health`);
+    if (!r.ok) throw new Error(`health failed: ${r.statusText}`);
+    return r.json();
+  }
+  async registerApp(reg) {
+    const r = await this.f(`${this.base}${this.api}/apps/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} },
+      body: JSON.stringify(reg)
+    });
+    const j = await r.json();
+    if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
+    return j;
+  }
+  async updateSchema(appKey, actions) {
+    const r = await this.f(`${this.base}${this.api}/apps/${encodeURIComponent(appKey)}/schema`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} },
+      body: JSON.stringify(actions)
+    });
+    const j = await r.json();
+    if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
+    return j;
+  }
+  async getSchema(appKey) {
+    const r = await this.f(`${this.base}${this.api}/apps/${encodeURIComponent(appKey)}/schema`, { headers: { ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} } });
+    const j = await r.json();
+    if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
+    return j;
+  }
+  async createSession(appKey, token) {
+    const r = await this.f(`${this.base}${this.api}/app/${encodeURIComponent(appKey)}/session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token })
+    });
+    const j = await r.json();
+    if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
+    return j;
+  }
+  async invokeAction(appKey, action, payload, origin) {
+    const r = await this.f(`${this.base}${this.api}/app/${encodeURIComponent(appKey)}/${encodeURIComponent(action)}`, {
+      method: "POST",
+      headers: { "Content-Type": "text/plain", ...origin ? { Origin: origin } : {} },
+      body: payload
+    });
+    const j = await r.json();
+    if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
+    return j;
+  }
+  async read(appKey, uri) {
+    const u = new URL(`${this.base}${this.api}/app/${encodeURIComponent(appKey)}/read`);
+    u.searchParams.set("uri", uri);
+    const r = await this.f(u.toString());
+    const j = await r.json();
+    if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
+    return j;
+  }
+};
+
+export {
+  AppsClient
+};