@flashbacktech/flashbackclient 0.1.74 → 0.1.76

package/dist/api/client.d.ts

@@ -6,6 +6,7 @@ import { NodeInfo } from './types/bridge';
 import { QuotaResponse } from './types/quota';
 import { DeviceListResponse, DeviceDetailsResponse, SessionListResponse, TrustDeviceRequest, TrustDeviceResponse, UntrustDeviceResponse, RemoveDeviceResponse, RevokeSessionResponse, RevokeAllSessionsResponse, SessionHeartbeatResponse, DeviceInfo } from './types/device';
 import { BuySubscriptionRequest, BuySubscriptionResponse, GetSubscriptionsResponse, MySubscriptionResponse, PaymentsListResponse, PaymentsQueryParams, CancelSubscriptionResponse } from './types/subscriptions';
+import { MFAMethodsResponse, MFASetupRequest, MFASetupResponse, MFAStatusResponse, MFAVerificationSetupRequest, MFAVerificationSetupResponse, MFAEnableRequest, MFAEnableResponse, MFADisableResponse, MFAPrimaryRequest, MFAPrimaryResponse, MFAResetResponse, MFAOrganizationEnforceRequest, MFAOrganizationEnforceResponse, MagicLinkSendResponse, PasskeyAuthOptionsResult, PasskeyCompleteRegistrationRequest, PasskeyCompleteRegistrationResponse } from './types/mfa';
 interface ErrorResponse {
     message?: string;
     [key: string]: any;
@@ -120,5 +121,17 @@ export declare class ApiClient implements IApiClient {
     revokeSession: (sessionId: string) => Promise<RevokeSessionResponse>;
     revokeAllSessions: () => Promise<RevokeAllSessionsResponse>;
     updateSessionHeartbeat: (sessionId: string) => Promise<SessionHeartbeatResponse>;
+    getMFAStatus: () => Promise<MFAStatusResponse>;
+    getAvailableMethods: () => Promise<MFAMethodsResponse>;
+    setupMFA: (request: MFASetupRequest) => Promise<MFASetupResponse>;
+    verifyMFASetup: (request: MFAVerificationSetupRequest) => Promise<MFAVerificationSetupResponse>;
+    enableMFA: (request: MFAEnableRequest) => Promise<MFAEnableResponse>;
+    disableMFA: (request: MFAEnableRequest) => Promise<MFADisableResponse>;
+    setPrimaryMFA: (request: MFAPrimaryRequest) => Promise<MFAPrimaryResponse>;
+    resetMFA: () => Promise<MFAResetResponse>;
+    enforceOrganizationMFA: (request: MFAOrganizationEnforceRequest) => Promise<MFAOrganizationEnforceResponse>;
+    sendMagicLink: () => Promise<MagicLinkSendResponse>;
+    getPasskeyAuthOptions: () => Promise<PasskeyAuthOptionsResult>;
+    completePasskeyRegistration: (request: PasskeyCompleteRegistrationRequest) => Promise<PasskeyCompleteRegistrationResponse>;
 }
 export {};

package/dist/api/client.js

@@ -334,6 +334,48 @@ class ApiClient {
         this.updateSessionHeartbeat = async (sessionId) => {
             return this.makeRequest(`sessions/${sessionId}/heartbeat`, 'POST', null);
         };
+        ////// MFA Status & Methods API
+        this.getMFAStatus = async () => {
+            return this.makeRequest('mfa/status', 'GET', null);
+        };
+        this.getAvailableMethods = async () => {
+            return this.makeRequest('mfa/methods', 'GET', null);
+        };
+        ////// MFA Setup & Verification API
+        this.setupMFA = async (request) => {
+            return this.makeRequest('mfa/setup', 'POST', request);
+        };
+        this.verifyMFASetup = async (request) => {
+            return this.makeRequest('mfa/verify-setup', 'POST', request);
+        };
+        ////// MFA Management API
+        this.enableMFA = async (request) => {
+            return this.makeRequest('mfa/enable', 'POST', request);
+        };
+        this.disableMFA = async (request) => {
+            return this.makeRequest('mfa/disable', 'POST', request);
+        };
+        this.setPrimaryMFA = async (request) => {
+            return this.makeRequest('mfa/primary', 'POST', request);
+        };
+        this.resetMFA = async () => {
+            return this.makeRequest('mfa/reset', 'POST', null);
+        };
+        ////// Organization MFA API
+        this.enforceOrganizationMFA = async (request) => {
+            return this.makeRequest('mfa/organization/enforce', 'POST', request);
+        };
+        ////// Magic Link MFA API
+        this.sendMagicLink = async () => {
+            return this.makeRequest('mfa/magic-link/send', 'POST', null);
+        };
+        ////// Passkey MFA API
+        this.getPasskeyAuthOptions = async () => {
+            return this.makeRequest('mfa/passkey/auth-options', 'POST', null);
+        };
+        this.completePasskeyRegistration = async (request) => {
+            return this.makeRequest('mfa/passkey/complete-registration', 'POST', request);
+        };
         this.baseURL = baseURL;
         this.headers = {};
         this.debug = false;

package/dist/api/index.d.ts

@@ -8,4 +8,5 @@ import * as EmailTypes from './types/email';
 import * as QuotaTypes from './types/quota';
 import * as SubscriptionTypes from './types/subscriptions';
 import * as DeviceTypes from './types/device';
-export { ApiClient, ApiTypes, AuthTypes, StatsTypes, ApiInterfaces, HttpError, BridgeTypes, EmailTypes, QuotaTypes, SubscriptionTypes, DeviceTypes };
+import * as MFATypes from './types/mfa';
+export { ApiClient, ApiTypes, AuthTypes, StatsTypes, ApiInterfaces, HttpError, BridgeTypes, EmailTypes, QuotaTypes, SubscriptionTypes, DeviceTypes, MFATypes };

package/dist/api/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceTypes = exports.SubscriptionTypes = exports.QuotaTypes = exports.EmailTypes = exports.BridgeTypes = exports.HttpError = exports.ApiInterfaces = exports.StatsTypes = exports.AuthTypes = exports.ApiTypes = exports.ApiClient = void 0;
+exports.MFATypes = exports.DeviceTypes = exports.SubscriptionTypes = exports.QuotaTypes = exports.EmailTypes = exports.BridgeTypes = exports.HttpError = exports.ApiInterfaces = exports.StatsTypes = exports.AuthTypes = exports.ApiTypes = exports.ApiClient = void 0;
 const client_1 = require("./client");
 Object.defineProperty(exports, "ApiClient", { enumerable: true, get: function () { return client_1.ApiClient; } });
 Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return client_1.HttpError; } });
@@ -55,3 +55,5 @@ const SubscriptionTypes = __importStar(require("./types/subscriptions"));
 exports.SubscriptionTypes = SubscriptionTypes;
 const DeviceTypes = __importStar(require("./types/device"));
 exports.DeviceTypes = DeviceTypes;
+const MFATypes = __importStar(require("./types/mfa"));
+exports.MFATypes = MFATypes;

package/dist/api/types/auth.d.ts

@@ -59,7 +59,7 @@ export interface RegisterBody {
     website?: string;
     isBusiness: boolean;
 }
-export interface LoginBody {
+export interface LoginBody extends LoginDeviceInfo {
     email: string;
     password: string;
 }

package/dist/api/types/mfa.d.ts

@@ -0,0 +1,232 @@
+import { DeviceInfo } from "./device";
+export declare enum MFAType {
+    GOOGLE_AUTH = "GOOGLE_AUTH",
+    MAGIC_LINK = "MAGIC_LINK",
+    PASSKEY = "PASSKEY"
+}
+export declare enum MFAAttemptType {
+    VERIFICATION = "VERIFICATION",
+    SETUP = "SETUP",
+    DISABLE = "DISABLE"
+}
+export interface PasskeyCredential {
+    id: string;
+    rawId: string;
+    response: {
+        clientDataJSON: string;
+        authenticatorData: string;
+        signature: string;
+        userHandle?: string;
+    };
+    type: 'public-key';
+}
+export interface PasskeyRegistrationCredential {
+    id: string;
+    rawId: string;
+    response: {
+        clientDataJSON: string;
+        attestationObject: string;
+    };
+    type: 'public-key';
+}
+export interface PasskeyAuthenticationCredential {
+    id: string;
+    rawId: string;
+    response: {
+        clientDataJSON: string;
+        authenticatorData: string;
+        signature: string;
+        userHandle?: string;
+    };
+    type: 'public-key';
+}
+export interface PasskeyChallengeOptions {
+    challenge: string;
+    rpId: string;
+    userVerification?: 'required' | 'preferred' | 'discouraged';
+    timeout?: number;
+}
+export interface PasskeyRegistrationOptions extends PasskeyChallengeOptions {
+    rp: {
+        name: string;
+        id: string;
+    };
+    user: {
+        id: string;
+        name: string;
+        displayName: string;
+    };
+    pubKeyCredParams: Array<{
+        type: 'public-key';
+        alg: number;
+    }>;
+    authenticatorSelection?: {
+        authenticatorAttachment?: 'platform' | 'cross-platform';
+        residentKey?: 'required' | 'preferred' | 'discouraged';
+        userVerification?: 'required' | 'preferred' | 'discouraged';
+    };
+    attestation?: 'none' | 'indirect' | 'direct';
+}
+export interface MFASetupRequest {
+    mfaType: MFAType;
+    email?: string;
+    deviceInfo?: DeviceInfo;
+}
+export interface MFAVerificationRequest {
+    mfaType: MFAType;
+    code?: string;
+    token?: string;
+    credential?: PasskeyAuthenticationCredential;
+    sessionId?: string;
+    ipAddress?: string;
+    userAgent?: string;
+}
+export interface MFAVerificationSetupRequest {
+    mfaType: MFAType;
+    code?: string;
+    credential?: PasskeyRegistrationCredential;
+}
+export interface MFAEnableRequest {
+    mfaType: MFAType;
+}
+export interface MFAPrimaryRequest {
+    mfaType: MFAType;
+}
+export interface MFAResetRequest {
+    _placeholder?: never;
+}
+export interface MFAOrganizationEnforceRequest {
+    enforced: boolean;
+}
+export interface PasskeyCompleteRegistrationRequest {
+    credential: PasskeyRegistrationCredential;
+    challenge: string;
+}
+export interface MFAVerificationResult {
+    success: boolean;
+    mfaMethod: MFAType;
+    metadata?: Record<string, unknown>;
+    error?: string;
+}
+export interface MFASetupResult {
+    success: boolean;
+    setupData?: Record<string, unknown>;
+    error?: string;
+}
+export interface MFAStatus {
+    isEnabled: boolean;
+    isRequired: boolean;
+    isEnforced: boolean;
+    enabledMethods: MFAType[];
+    primaryMethod?: MFAType;
+}
+export interface MFAVerificationSetupResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface MFAEnableResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface MFADisableResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface MFAPrimaryResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface MFAResetResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface MFAOrganizationEnforceResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface GoogleAuthSetupData {
+    secret: string;
+    qrCode: string;
+    backupCodes: string[];
+}
+export interface MagicLinkSetupData {
+    email: string;
+    verificationRequired: boolean;
+}
+export interface PasskeySetupData {
+    challenge: PasskeyRegistrationOptions;
+    rpName: string;
+    userName: string;
+}
+export interface PasskeyAuthOptionsResult {
+    success: boolean;
+    data?: PasskeyChallengeOptions;
+    error?: string;
+}
+export interface PasskeyCompleteRegistrationResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface MFAConfig {
+    maxAttempts: number;
+    lockoutDuration: number;
+    backupCodeCount: number;
+    totpWindow: number;
+    magicLinkExpiry: number;
+}
+export declare const DEFAULT_MFA_CONFIG: MFAConfig;
+export interface MFAChallenge {
+    challengeId: string;
+    userId: string;
+    mfaType: MFAType;
+    expiresAt: Date;
+    metadata?: Record<string, unknown>;
+}
+export interface MFAVerificationChallenge {
+    challengeId: string;
+    userId: string;
+    mfaType: MFAType;
+    expiresAt: Date;
+    attempts: number;
+    maxAttempts: number;
+    isLocked: boolean;
+    lockoutUntil?: Date;
+}
+export interface MFAAttemptLog {
+    userId: string;
+    mfaType: MFAType;
+    attemptType: MFAAttemptType;
+    success: boolean;
+    ipAddress?: string;
+    userAgent?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface APIResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    message?: string;
+    error?: string;
+}
+export type MFAStatusResponse = APIResponse<MFAStatus>;
+export type MFAMethodsResponse = APIResponse<MFAType[]>;
+export type MFASetupResponse = APIResponse<Record<string, unknown>>;
+export type MFAVerificationSetupResponse = APIResponse<MFAVerificationSetupResult>;
+export type MFAEnableResponse = APIResponse<MFAEnableResult>;
+export type MFADisableResponse = APIResponse<MFADisableResult>;
+export type MFAPrimaryResponse = APIResponse<MFAPrimaryResult>;
+export type MFAResetResponse = APIResponse<MFAResetResult>;
+export type MFAOrganizationEnforceResponse = APIResponse<MFAOrganizationEnforceResult>;
+export type PasskeyAuthOptionsResponse = APIResponse<PasskeyChallengeOptions>;
+export type PasskeyCompleteRegistrationResponse = APIResponse<PasskeyCompleteRegistrationResult>;
+export type MagicLinkSendResponse = APIResponse<{
+    message: string;
+}>;
+export type MFAMethodType = 'GOOGLE_AUTH' | 'MAGIC_LINK' | 'PASSKEY';
+export type MFAAttemptTypeEnum = 'VERIFICATION' | 'SETUP' | 'DISABLE';

package/dist/api/types/mfa.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MFA_CONFIG = exports.MFAAttemptType = exports.MFAType = void 0;
+// ============================================================================
+// SELF-CONTAINED ENUM DEFINITIONS (Mirror Prisma but independent)
+// ============================================================================
+var MFAType;
+(function (MFAType) {
+    MFAType["GOOGLE_AUTH"] = "GOOGLE_AUTH";
+    MFAType["MAGIC_LINK"] = "MAGIC_LINK";
+    MFAType["PASSKEY"] = "PASSKEY";
+})(MFAType || (exports.MFAType = MFAType = {}));
+var MFAAttemptType;
+(function (MFAAttemptType) {
+    MFAAttemptType["VERIFICATION"] = "VERIFICATION";
+    MFAAttemptType["SETUP"] = "SETUP";
+    MFAAttemptType["DISABLE"] = "DISABLE";
+})(MFAAttemptType || (exports.MFAAttemptType = MFAAttemptType = {}));
+exports.DEFAULT_MFA_CONFIG = {
+    maxAttempts: 5,
+    lockoutDuration: 15,
+    backupCodeCount: 10,
+    totpWindow: 2, // Allow 2 time steps before/after current time
+    magicLinkExpiry: 10,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flashbacktech/flashbackclient",
-  "version": "0.1.74",
+  "version": "0.1.76",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"