@bandeira-tech/b3nd-web 0.2.5 → 0.2.6

package/dist/client-B0Ekm99R.d.ts

@@ -0,0 +1,354 @@
+/**
+ * Wallet Client Types
+ *
+ * Type definitions for the B3nd Wallet Client that interacts with wallet servers.
+ */
+/**
+ * Configuration for wallet client
+ */
+interface WalletClientConfig {
+    /**
+     * Wallet server URL (e.g., "http://localhost:3001")
+     */
+    walletServerUrl: string;
+    /**
+     * API base path prefix (e.g., "/api/v1"). Must be provided explicitly.
+     */
+    apiBasePath: string;
+    /**
+     * Optional fetch implementation (for custom HTTP handling)
+     */
+    fetch?: typeof fetch;
+}
+/**
+ * User credentials for authentication
+ */
+interface UserCredentials {
+    username: string;
+    password: string;
+}
+/**
+ * Authenticated session with JWT token
+ */
+interface AuthSession {
+    username: string;
+    token: string;
+    expiresIn: number;
+}
+/**
+ * User's public keys
+ */
+interface UserPublicKeys {
+    accountPublicKeyHex: string;
+    encryptionPublicKeyHex: string;
+}
+/**
+ * Password reset token
+ */
+interface PasswordResetToken {
+    resetToken: string;
+    expiresIn: number;
+}
+/**
+ * Write proxy request
+ */
+interface ProxyWriteRequest {
+    uri: string;
+    data: unknown;
+    encrypt?: boolean;
+}
+/**
+ * Write proxy response
+ */
+interface ProxyWriteResponse {
+    success: boolean;
+    uri: string;
+    resolvedUri?: string;
+    data: unknown;
+    record?: {
+        data: unknown;
+        ts: number;
+    };
+}
+/**
+ * Read proxy request
+ */
+interface ProxyReadRequest {
+    uri: string;
+}
+/**
+ * Read proxy response
+ */
+interface ProxyReadResponse {
+    success: boolean;
+    uri: string;
+    record?: {
+        data: unknown;
+        ts: number;
+    };
+    decrypted?: unknown;
+    error?: string;
+}
+/**
+ * API response wrapper
+ */
+interface ApiResponse {
+    success: boolean;
+    error?: string;
+    [key: string]: unknown;
+}
+/**
+ * Signup response
+ */
+interface SignupResponse extends ApiResponse {
+    username: string;
+    token: string;
+    expiresIn: number;
+}
+/**
+ * Login response
+ */
+interface LoginResponse extends ApiResponse {
+    username: string;
+    token: string;
+    expiresIn: number;
+}
+/**
+ * Public keys response
+ */
+interface PublicKeysResponse extends ApiResponse {
+    accountPublicKeyHex: string;
+    encryptionPublicKeyHex: string;
+}
+/**
+ * Change password response
+ */
+interface ChangePasswordResponse extends ApiResponse {
+    message: string;
+}
+/**
+ * Request password reset response
+ */
+interface RequestPasswordResetResponse extends ApiResponse {
+    message: string;
+    resetToken: string;
+    expiresIn: number;
+}
+/**
+ * Reset password response
+ */
+interface ResetPasswordResponse extends ApiResponse {
+    message: string;
+    username: string;
+    token: string;
+    expiresIn: number;
+}
+/**
+ * Health check response
+ */
+interface HealthResponse extends ApiResponse {
+    status: string;
+    server: string;
+    timestamp: string;
+}
+/**
+ * Google OAuth session (extended AuthSession with Google profile info)
+ */
+interface GoogleAuthSession extends AuthSession {
+    email: string;
+    name?: string;
+    picture?: string;
+}
+/**
+ * Google signup response
+ */
+interface GoogleSignupResponse extends ApiResponse {
+    username: string;
+    email: string;
+    name?: string;
+    picture?: string;
+    token: string;
+    expiresIn: number;
+}
+/**
+ * Google login response
+ */
+interface GoogleLoginResponse extends ApiResponse {
+    username: string;
+    email: string;
+    name?: string;
+    picture?: string;
+    token: string;
+    expiresIn: number;
+}
+
+/**
+ * B3nd Wallet Client
+ *
+ * Client library for interacting with B3nd wallet servers.
+ * Provides authentication, key management, and write proxying functionality.
+ *
+ * Works in both Deno and browser environments.
+ */
+
+/**
+ * B3nd Wallet Client
+ *
+ * Manages authentication with a wallet server and provides methods
+ * for user management, key retrieval, and proxied writes.
+ *
+ * @example
+ * ```typescript
+ * const wallet = new WalletClient({
+ *   walletServerUrl: "http://localhost:3001",
+ *   apiBasePath: "/api/v1",
+ * });
+ *
+ * // Sign up a new user
+ * const session = await wallet.signup({
+ *   username: "alice",
+ *   password: "secure-password-123"
+ * });
+ *
+ * // Activate the session
+ * wallet.setSession(session);
+ *
+ * // Write data through proxy
+ * await wallet.proxyWrite({
+ *   uri: "mutable://data/my-app/profile",
+ *   data: { name: "Alice" },
+ *   encrypt: true
+ * });
+ * ```
+ */
+declare class WalletClient {
+    private walletServerUrl;
+    private apiBasePath;
+    private fetchImpl;
+    private currentSession;
+    constructor(config: WalletClientConfig);
+    private buildUrl;
+    private buildAppKeyUrl;
+    /**
+     * Get the current authenticated session
+     */
+    getSession(): AuthSession | null;
+    /**
+     * Set the current session (useful for restoring from storage)
+     */
+    setSession(session: AuthSession | null): void;
+    /**
+     * Check if user is currently authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Get current username (if authenticated)
+     */
+    getUsername(): string | null;
+    /**
+     * Get current JWT token (if authenticated)
+     */
+    getToken(): string | null;
+    /**
+     * Clear current session (logout)
+     */
+    logout(): void;
+    /**
+     * Check wallet server health
+     */
+    health(): Promise<HealthResponse>;
+    /**
+     * Sign up a new user
+     * Returns session data - call setSession() to activate it
+     */
+    signup(_credentials: UserCredentials): Promise<AuthSession>;
+    /**
+     * Login existing user
+     * Returns session data - call setSession() to activate it
+     */
+    login(_credentials: UserCredentials): Promise<AuthSession>;
+    /**
+     * Change password for current user
+     * Requires active authentication session
+     */
+    changePassword(appKey: string, oldPassword: string, newPassword: string): Promise<void>;
+    /**
+     * Request a password reset token
+     * Does not require authentication
+     */
+    requestPasswordReset(_username: string): Promise<PasswordResetToken>;
+    /**
+     * Reset password using a reset token
+     * Returns session data - call setSession() to activate it
+     */
+    resetPassword(_username: string, _resetToken: string, _newPassword: string): Promise<AuthSession>;
+    /**
+     * Sign up with app token (scoped to an app)
+     */
+    signupWithToken(appKey: string, tokenOrCredentials: string | UserCredentials, maybeCredentials?: UserCredentials): Promise<AuthSession>;
+    /**
+     * Login with app token and session (scoped to an app)
+     */
+    loginWithTokenSession(appKey: string, tokenOrSession: string, sessionOrCredentials: string | UserCredentials, maybeCredentials?: UserCredentials): Promise<AuthSession>;
+    /**
+     * Request password reset scoped to app token
+     */
+    requestPasswordResetWithToken(appKey: string, tokenOrUsername: string, maybeUsername?: string): Promise<PasswordResetToken>;
+    /**
+     * Reset password scoped to an app
+     */
+    resetPasswordWithToken(appKey: string, _tokenOrUsername: string, usernameOrReset: string, resetToken?: string, newPassword?: string): Promise<AuthSession>;
+    /**
+     * Get public keys for the current authenticated user.
+     * Requires an active authentication session.
+     */
+    getPublicKeys(appKey: string): Promise<UserPublicKeys>;
+    /**
+     * Proxy a write request through the wallet server
+     * The server signs the write with its identity key
+     * Requires active authentication session
+     */
+    proxyWrite(request: ProxyWriteRequest): Promise<ProxyWriteResponse>;
+    /**
+     * Proxy a read request through the wallet server
+     * The server decrypts encrypted data using user's encryption key
+     * Requires active authentication session
+     */
+    proxyRead(request: ProxyReadRequest): Promise<ProxyReadResponse>;
+    /**
+     * Convenience method: Get current user's public keys
+     * Requires active authentication session
+     */
+    getMyPublicKeys(appKey: string): Promise<UserPublicKeys>;
+    /**
+     * Get server's public keys
+     *
+     * @returns Server's identity and encryption public keys
+     * @throws Error if request fails
+     */
+    getServerKeys(): Promise<{
+        identityPublicKeyHex: string;
+        encryptionPublicKeyHex: string;
+    }>;
+    /**
+     * Sign up with Google OAuth (scoped to app token)
+     * Returns session data with Google profile info - call setSession() to activate it
+     *
+     * @param token - App token from app server
+     * @param googleIdToken - Google ID token from Google Sign-In
+     * @returns GoogleAuthSession with username, JWT token, and Google profile info
+     */
+    signupWithGoogle(appKey: string, token: string, googleIdToken: string): Promise<GoogleAuthSession>;
+    /**
+     * Login with Google OAuth (scoped to app token and session)
+     * Returns session data with Google profile info - call setSession() to activate it
+     *
+     * @param token - App token from app server
+     * @param session - Session key from app server
+     * @param googleIdToken - Google ID token from Google Sign-In
+     * @returns GoogleAuthSession with username, JWT token, and Google profile info
+     */
+    loginWithGoogle(appKey: string, token: string, session: string, googleIdToken: string): Promise<GoogleAuthSession>;
+}
+
+export { type AuthSession as A, type ChangePasswordResponse as C, type GoogleAuthSession as G, type HealthResponse as H, type LoginResponse as L, type PasswordResetToken as P, type RequestPasswordResetResponse as R, type SignupResponse as S, type UserCredentials as U, WalletClient as W, type UserPublicKeys as a, type ProxyWriteRequest as b, type ProxyWriteResponse as c, type ProxyReadRequest as d, type ProxyReadResponse as e, type WalletClientConfig as f, type ApiResponse as g, type PublicKeysResponse as h, type ResetPasswordResponse as i, type GoogleSignupResponse as j, type GoogleLoginResponse as k };

package/dist/clients/memory/mod.d.ts

@@ -1,4 +1,4 @@
-import { S as Schema, N as NodeProtocolInterface, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, H as HealthStatus, D as DeleteResult } from '../../types-oQCx3U-_.js';
+import { N as NodeProtocolInterface, S as Schema, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, H as HealthStatus, D as DeleteResult } from '../../types-oQCx3U-_.js';
 
 type MemoryClientStorageNode<T> = {
     value?: T;

package/dist/clients/memory/mod.js

@@ -1,203 +1,7 @@
+import {
+  MemoryClient
+} from "../../chunk-GIMIWVPX.js";
 import "../../chunk-MLKGABMK.js";
-
-// 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
 };

package/dist/src/mod.web.d.ts

@@ -2,6 +2,6 @@ export { C as ClientError, D as DeleteResult, H as HealthStatus, a as HttpClient
 export { HttpClient } from '../clients/http/mod.js';
 export { WebSocketClient } from '../clients/websocket/mod.js';
 export { LocalStorageClient } from '../clients/local-storage/mod.js';
-export { WalletClient } from '../wallet/mod.js';
+export { W as WalletClient } from '../client-B0Ekm99R.js';
 export { AppsClient } from '../apps/mod.js';
 export { m as encrypt } from '../mod-CII9wqu2.js';

package/dist/src/mod.web.js

@@ -4,18 +4,20 @@ import {
 import {
   AppsClient
 } from "../chunk-VAZUCGED.js";
+import {
+  WalletClient
+} from "../chunk-FVLXYKYS.js";
+import "../chunk-F3W5GZU6.js";
 import {
   mod_exports
 } from "../chunk-JN75UL5C.js";
-import {
-  WalletClient
-} from "../chunk-S7NJA6B6.js";
 import {
   HttpClient
 } from "../chunk-LFUC4ETD.js";
 import {
   LocalStorageClient
 } from "../chunk-7U5JDFQW.js";
+import "../chunk-GIMIWVPX.js";
 import "../chunk-MLKGABMK.js";
 export {
   AppsClient,