@bandeira-tech/b3nd-web 0.2.5 → 0.2.6

package/dist/{chunk-S7NJA6B6.js → chunk-FVLXYKYS.js}

@@ -1,3 +1,15 @@
+import {
+  WalletServerCore
+} from "./chunk-F3W5GZU6.js";
+import {
+  exportPrivateKeyPem,
+  generateEncryptionKeyPair,
+  generateSigningKeyPair
+} from "./chunk-JN75UL5C.js";
+import {
+  MemoryClient
+} from "./chunk-GIMIWVPX.js";
+
 // wallet/client.ts
 var WalletClient = class {
   constructor(config) {
@@ -381,6 +393,365 @@ var WalletClient = class {
   }
 };
 
+// wallet/memory-client.ts
+async function generateTestServerKeys() {
+  const identityKeyPair = await generateSigningKeyPair();
+  const encryptionKeyPair = await generateEncryptionKeyPair();
+  const identityPrivateKeyPem = await exportPrivateKeyPem(
+    identityKeyPair.privateKey,
+    "PRIVATE KEY"
+  );
+  const encryptionPrivateKeyBytes = new Uint8Array(
+    await crypto.subtle.exportKey("pkcs8", encryptionKeyPair.privateKey)
+  );
+  const encryptionBase64 = btoa(
+    String.fromCharCode(...encryptionPrivateKeyBytes)
+  );
+  const encryptionPrivateKeyPem = `-----BEGIN PRIVATE KEY-----
+${encryptionBase64.match(/.{1,64}/g)?.join("\n")}
+-----END PRIVATE KEY-----`;
+  return {
+    identityKey: {
+      privateKeyPem: identityPrivateKeyPem,
+      publicKeyHex: identityKeyPair.publicKeyHex
+    },
+    encryptionKey: {
+      privateKeyPem: encryptionPrivateKeyPem,
+      publicKeyHex: encryptionKeyPair.publicKeyHex
+    }
+  };
+}
+function createWalletMemoryClient() {
+  return new MemoryClient({
+    schema: {
+      "immutable://accounts": async () => ({ valid: true }),
+      "mutable://accounts": async () => ({ valid: true })
+    }
+  });
+}
+var MemoryWalletClient = class _MemoryWalletClient {
+  constructor(server) {
+    this.currentSession = null;
+    this.apiBasePath = "/api/v1";
+    this.server = server;
+    this.handler = server.getFetchHandler();
+  }
+  /**
+   * Create a new MemoryWalletClient
+   * Use this factory method instead of constructor (async key generation)
+   */
+  static async create(config = {}) {
+    const serverKeys = config.serverKeys || await generateTestServerKeys();
+    const storageClient = config.storageClient || createWalletMemoryClient();
+    const serverConfig = {
+      serverKeys,
+      jwtSecret: config.jwtSecret || "test-jwt-secret-for-memory-wallet-client!!",
+      jwtExpirationSeconds: config.jwtExpirationSeconds || 3600,
+      deps: {
+        credentialClient: storageClient,
+        proxyClient: storageClient,
+        logger: {
+          log: () => {
+          },
+          warn: () => {
+          },
+          error: () => {
+          }
+        }
+      }
+    };
+    const server = new WalletServerCore(serverConfig);
+    return new _MemoryWalletClient(server);
+  }
+  /**
+   * Make a request to the embedded server
+   */
+  async request(method, path, body, headers) {
+    const url = `http://memory-wallet${this.apiBasePath}${path}`;
+    const requestHeaders = {
+      ...headers
+    };
+    if (body) {
+      requestHeaders["Content-Type"] = "application/json";
+    }
+    const request = new Request(url, {
+      method,
+      headers: requestHeaders,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return await this.handler(request);
+  }
+  /**
+   * Make an authenticated request
+   */
+  async authRequest(method, path, body) {
+    if (!this.currentSession) {
+      throw new Error("Not authenticated. Please login first.");
+    }
+    return this.request(method, path, body, {
+      Authorization: `Bearer ${this.currentSession.token}`
+    });
+  }
+  // ============================================================
+  // Session Management (same as WalletClient)
+  // ============================================================
+  getSession() {
+    return this.currentSession;
+  }
+  setSession(session) {
+    this.currentSession = session;
+  }
+  isAuthenticated() {
+    return this.currentSession !== null;
+  }
+  getUsername() {
+    return this.currentSession?.username || null;
+  }
+  getToken() {
+    return this.currentSession?.token || null;
+  }
+  logout() {
+    this.currentSession = null;
+  }
+  // ============================================================
+  // Health & Server Info
+  // ============================================================
+  async health() {
+    const response = await this.request("GET", "/health");
+    if (!response.ok) {
+      throw new Error(`Health check failed: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  async getServerKeys() {
+    const response = await this.request("GET", "/server-keys");
+    if (!response.ok) {
+      throw new Error(`Failed to get server keys: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new Error(data.error || "Failed to get server keys");
+    }
+    return {
+      identityPublicKeyHex: data.identityPublicKeyHex,
+      encryptionPublicKeyHex: data.encryptionPublicKeyHex
+    };
+  }
+  // ============================================================
+  // Authentication
+  // ============================================================
+  async signup(_credentials) {
+    throw new Error("Use signupWithToken(appKey, credentials) \u2014 app token required");
+  }
+  async login(_credentials) {
+    throw new Error("Use loginWithTokenSession(appKey, session, credentials) \u2014 app token + session required");
+  }
+  async signupWithToken(appKey, tokenOrCredentials, maybeCredentials) {
+    const credentials = typeof tokenOrCredentials === "string" ? maybeCredentials : tokenOrCredentials;
+    if (!credentials) throw new Error("credentials are required");
+    const response = await this.request("POST", `/auth/signup/${appKey}`, {
+      token: typeof tokenOrCredentials === "string" ? tokenOrCredentials : void 0,
+      type: "password",
+      username: credentials.username,
+      password: credentials.password
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Signup failed: ${response.statusText}`);
+    }
+    return {
+      username: data.username,
+      token: data.token,
+      expiresIn: data.expiresIn
+    };
+  }
+  async loginWithTokenSession(appKey, tokenOrSession, sessionOrCredentials, maybeCredentials) {
+    const session = typeof sessionOrCredentials === "string" && maybeCredentials ? sessionOrCredentials : tokenOrSession;
+    const credentials = maybeCredentials || sessionOrCredentials;
+    if (!session || typeof session !== "string") throw new Error("session is required");
+    const response = await this.request("POST", `/auth/login/${appKey}`, {
+      token: typeof tokenOrSession === "string" && maybeCredentials ? tokenOrSession : void 0,
+      session,
+      type: "password",
+      username: credentials.username,
+      password: credentials.password
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Login failed: ${response.statusText}`);
+    }
+    return {
+      username: data.username,
+      token: data.token,
+      expiresIn: data.expiresIn
+    };
+  }
+  // ============================================================
+  // Password Management
+  // ============================================================
+  async changePassword(appKey, oldPassword, newPassword) {
+    const response = await this.authRequest(
+      "POST",
+      `/auth/credentials/change-password/${appKey}`,
+      { oldPassword, newPassword }
+    );
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Change password failed: ${response.statusText}`);
+    }
+  }
+  async requestPasswordReset(_username) {
+    throw new Error("Use requestPasswordResetWithToken(appKey, username)");
+  }
+  async resetPassword(_username, _resetToken, _newPassword) {
+    throw new Error("Use resetPasswordWithToken(appKey, username, resetToken, newPassword)");
+  }
+  async requestPasswordResetWithToken(appKey, tokenOrUsername, maybeUsername) {
+    const username = maybeUsername || tokenOrUsername;
+    const response = await this.request(
+      "POST",
+      `/auth/credentials/request-password-reset/${appKey}`,
+      { username }
+    );
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Request password reset failed: ${response.statusText}`);
+    }
+    return {
+      resetToken: data.resetToken,
+      expiresIn: data.expiresIn
+    };
+  }
+  async resetPasswordWithToken(appKey, _tokenOrUsername, usernameOrReset, resetToken, newPassword) {
+    const username = usernameOrReset;
+    if (!resetToken || !newPassword) {
+      throw new Error("resetToken and newPassword are required");
+    }
+    const response = await this.request(
+      "POST",
+      `/auth/credentials/reset-password/${appKey}`,
+      { username, resetToken, newPassword }
+    );
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Reset password failed: ${response.statusText}`);
+    }
+    return {
+      username: data.username,
+      token: data.token,
+      expiresIn: data.expiresIn
+    };
+  }
+  // ============================================================
+  // Public Keys
+  // ============================================================
+  async getPublicKeys(appKey) {
+    if (!appKey || typeof appKey !== "string") {
+      throw new Error("appKey is required");
+    }
+    const response = await this.authRequest("GET", `/auth/public-keys/${appKey}`);
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Get public keys failed: ${response.statusText}`);
+    }
+    return {
+      accountPublicKeyHex: data.accountPublicKeyHex,
+      encryptionPublicKeyHex: data.encryptionPublicKeyHex
+    };
+  }
+  async getMyPublicKeys(appKey) {
+    return this.getPublicKeys(appKey);
+  }
+  // ============================================================
+  // Proxy Operations
+  // ============================================================
+  async proxyWrite(request) {
+    const response = await this.authRequest("POST", "/proxy/write", {
+      uri: request.uri,
+      data: request.data,
+      encrypt: request.encrypt
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Proxy write failed: ${response.statusText}`);
+    }
+    return data;
+  }
+  async proxyRead(request) {
+    const url = `/proxy/read?uri=${encodeURIComponent(request.uri)}`;
+    const response = await this.authRequest("GET", url);
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Proxy read failed: ${response.statusText}`);
+    }
+    return data;
+  }
+  // ============================================================
+  // Google OAuth (for completeness - may not work without real Google)
+  // ============================================================
+  async signupWithGoogle(appKey, token, googleIdToken) {
+    if (!token) throw new Error("token is required");
+    if (!googleIdToken) throw new Error("googleIdToken is required");
+    const response = await this.request("POST", `/auth/signup/${appKey}`, {
+      token,
+      type: "google",
+      googleIdToken
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Google signup failed: ${response.statusText}`);
+    }
+    return {
+      username: data.username,
+      token: data.token,
+      expiresIn: data.expiresIn,
+      email: data.email,
+      name: data.name,
+      picture: data.picture
+    };
+  }
+  async loginWithGoogle(appKey, token, session, googleIdToken) {
+    if (!token) throw new Error("token is required");
+    if (!session) throw new Error("session is required");
+    if (!googleIdToken) throw new Error("googleIdToken is required");
+    const response = await this.request("POST", `/auth/login/${appKey}`, {
+      token,
+      session,
+      type: "google",
+      googleIdToken
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Google login failed: ${response.statusText}`);
+    }
+    return {
+      username: data.username,
+      token: data.token,
+      expiresIn: data.expiresIn,
+      email: data.email,
+      name: data.name,
+      picture: data.picture
+    };
+  }
+  // ============================================================
+  // Testing Utilities
+  // ============================================================
+  /**
+   * Get the underlying WalletServerCore (for testing/inspection)
+   */
+  getServer() {
+    return this.server;
+  }
+  /**
+   * Get server's public keys directly (convenience method)
+   */
+  getServerPublicKeys() {
+    return this.server.getServerKeys();
+  }
+};
+
 export {
-  WalletClient
+  WalletClient,
+  generateTestServerKeys,
+  MemoryWalletClient
 };

package/dist/chunk-GIMIWVPX.js

@@ -0,0 +1,202 @@
+// clients/memory/mod.ts
+function target(uri, schema, storage) {
+  const url = URL.parse(uri);
+  const program = `${url.protocol}//${url.hostname}`;
+  if (!schema[program]) {
+    return { success: false, error: "Program not found" };
+  }
+  const node = storage.get(program);
+  if (!node) {
+    return { success: false, error: "Storage not initialized for program" };
+  }
+  const parts = url.pathname.substring(1).split("/");
+  return {
+    success: true,
+    program,
+    path: url.pathname,
+    node,
+    parts
+  };
+}
+var MemoryClient = class {
+  constructor(config) {
+    this.schema = config.schema;
+    this.storage = config.storage || /* @__PURE__ */ new Map();
+    this.cleanup();
+  }
+  async write(uri, payload) {
+    const result = target(uri, this.schema, this.storage);
+    if (!result.success) {
+      return result;
+    }
+    const { program, node, parts } = result;
+    const validator = this.schema[program];
+    const validation = await validator({ uri, value: payload, read: this.read.bind(this) });
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: validation.error || "Validation failed"
+      };
+    }
+    const record = {
+      ts: Date.now(),
+      data: payload
+    };
+    let prev = node;
+    parts.filter(Boolean).forEach((ns) => {
+      if (!prev.children) prev.children = /* @__PURE__ */ new Map();
+      if (!prev.children.get(ns)) {
+        const newnode = {};
+        prev.children.set(ns, newnode);
+        prev = newnode;
+      } else {
+        prev = prev.children.get(ns);
+      }
+    });
+    prev.value = record;
+    return {
+      success: true,
+      record
+    };
+  }
+  read(uri) {
+    const result = target(uri, this.schema, this.storage);
+    if (!result.success) {
+      return Promise.resolve(result);
+    }
+    const { node, parts } = result;
+    let current = node;
+    for (const part of parts.filter(Boolean)) {
+      current = current?.children?.get(part);
+      if (!current) {
+        return Promise.resolve({
+          success: false,
+          error: `Path not found: ${part}`
+        });
+      }
+    }
+    if (!current.value) {
+      return Promise.resolve({
+        success: false,
+        error: "Not found"
+      });
+    }
+    return Promise.resolve({
+      success: true,
+      record: current.value
+    });
+  }
+  list(uri, options) {
+    const result = target(uri, this.schema, this.storage);
+    if (!result.success) {
+      return Promise.resolve(result);
+    }
+    const { node, parts, program, path } = result;
+    let current = node;
+    const filteredParts = parts.filter(Boolean);
+    for (const part of filteredParts) {
+      current = current?.children?.get(part);
+      if (!current) {
+        return Promise.resolve({
+          success: false,
+          error: `Path not found: ${part}`
+        });
+      }
+    }
+    if (!current.children?.size) {
+      return Promise.resolve({
+        success: true,
+        data: [],
+        pagination: {
+          page: options?.page ?? 1,
+          limit: options?.limit ?? 50,
+          total: 0
+        }
+      });
+    }
+    let items = Array.from(current.children.entries()).map(([key, child]) => ({
+      uri: path.endsWith("/") ? `${program}://${path}${key}` : `${program}://${path}/${key}`,
+      type: child.value ? "file" : "directory"
+    }));
+    if (options?.pattern) {
+      const regex = new RegExp(options.pattern);
+      items = items.filter((item) => regex.test(item.uri));
+    }
+    if (options?.sortBy === "name") {
+      items.sort((a, b) => a.uri.localeCompare(b.uri));
+    } else if (options?.sortBy === "timestamp") {
+      items.sort((a, b) => {
+        const aTs = current.children?.get(a.uri.split("/").pop())?.value?.ts ?? 0;
+        const bTs = current.children?.get(b.uri.split("/").pop())?.value?.ts ?? 0;
+        return aTs - bTs;
+      });
+    }
+    if (options?.sortOrder === "desc") {
+      items.reverse();
+    }
+    const page = options?.page ?? 1;
+    const limit = options?.limit ?? 50;
+    const offset = (page - 1) * limit;
+    const paginated = items.slice(offset, offset + limit);
+    return Promise.resolve({
+      success: true,
+      data: paginated,
+      pagination: { page, limit, total: items.length }
+    });
+  }
+  health() {
+    return Promise.resolve({
+      status: "healthy"
+    });
+  }
+  getSchema() {
+    return Promise.resolve(Object.keys(this.schema));
+  }
+  cleanup() {
+    Object.keys(this.schema).forEach((program) => {
+      if (!this.storage.get(program)) {
+        this.storage.set(program, { children: /* @__PURE__ */ new Map() });
+      }
+    });
+    return Promise.resolve();
+  }
+  delete(uri) {
+    const result = target(uri, this.schema, this.storage);
+    if (!result.success) {
+      return Promise.resolve(result);
+    }
+    const { node, parts } = result;
+    const filteredParts = parts.filter(Boolean);
+    if (filteredParts.length === 0) {
+      return Promise.resolve({
+        success: false,
+        error: "Cannot delete root path"
+      });
+    }
+    let current = node;
+    const lastPart = filteredParts.pop();
+    for (const part of filteredParts) {
+      current = current?.children?.get(part);
+      if (!current) {
+        return Promise.resolve({
+          success: false,
+          error: `Path not found: ${part}`
+        });
+      }
+    }
+    if (!current.children?.has(lastPart)) {
+      return Promise.resolve({
+        success: false,
+        error: `Item not found: ${lastPart}`
+      });
+    }
+    current.children.delete(lastPart);
+    return Promise.resolve({
+      success: true
+    });
+  }
+};
+
+export {
+  MemoryClient
+};