@dominusnode/sdk 1.0.0

package/dist/cjs/admin.d.ts

@@ -0,0 +1,71 @@
+import type { HttpClient } from "./http.js";
+import type { AdminUser, SystemStats } from "./types.js";
+export interface DateRangeOptions {
+    since?: string;
+    until?: string;
+}
+export interface ListUsersResponse {
+    users: AdminUser[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+}
+export interface GetUserResponse {
+    user: AdminUser;
+}
+export interface RevenueResponse {
+    totalRevenueCents: number;
+    totalRevenueUsd: number;
+    avgTransactionCents: number;
+    avgTransactionUsd: number;
+    transactionCount: number;
+    topupCount: number;
+    period: {
+        since: string;
+        until: string;
+    };
+}
+export interface DailyRevenueEntry {
+    date: string;
+    revenueCents: number;
+    revenueUsd: number;
+}
+export interface DailyRevenueResponse {
+    days: DailyRevenueEntry[];
+    period: {
+        since: string;
+        until: string;
+    };
+}
+export declare class AdminResource {
+    private http;
+    constructor(http: HttpClient);
+    /** List all users (paginated). Requires admin privileges. */
+    listUsers(opts?: {
+        page?: number;
+        limit?: number;
+    }): Promise<ListUsersResponse>;
+    /** Get detailed info for a specific user. Requires admin privileges. */
+    getUser(id: string): Promise<GetUserResponse>;
+    /** Suspend a user account. Requires admin privileges. */
+    suspendUser(id: string): Promise<{
+        message: string;
+    }>;
+    /** Reactivate a suspended user account. Requires admin privileges. */
+    activateUser(id: string): Promise<{
+        message: string;
+    }>;
+    /** Soft-delete a user account. Requires admin privileges. */
+    deleteUser(id: string): Promise<{
+        message: string;
+    }>;
+    /** Get revenue statistics for a date range. Requires admin privileges. */
+    getRevenue(opts?: DateRangeOptions): Promise<RevenueResponse>;
+    /** Get daily revenue breakdown. Requires admin privileges. */
+    getDailyRevenue(opts?: DateRangeOptions): Promise<DailyRevenueResponse>;
+    /** Get system-wide statistics. Requires admin privileges. */
+    getStats(): Promise<SystemStats>;
+}

package/dist/cjs/admin.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminResource = void 0;
+class AdminResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** List all users (paginated). Requires admin privileges. */
+    async listUsers(opts) {
+        const params = new URLSearchParams();
+        if (opts?.page !== undefined)
+            params.set("page", String(opts.page));
+        if (opts?.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        const qs = params.toString();
+        return this.http.get(`/api/admin/users${qs ? `?${qs}` : ""}`);
+    }
+    /** Get detailed info for a specific user. Requires admin privileges. */
+    async getUser(id) {
+        return this.http.get(`/api/admin/users/${encodeURIComponent(id)}`);
+    }
+    /** Suspend a user account. Requires admin privileges. */
+    async suspendUser(id) {
+        return this.http.put(`/api/admin/users/${encodeURIComponent(id)}/suspend`);
+    }
+    /** Reactivate a suspended user account. Requires admin privileges. */
+    async activateUser(id) {
+        return this.http.put(`/api/admin/users/${encodeURIComponent(id)}/activate`);
+    }
+    /** Soft-delete a user account. Requires admin privileges. */
+    async deleteUser(id) {
+        return this.http.delete(`/api/admin/users/${encodeURIComponent(id)}`);
+    }
+    /** Get revenue statistics for a date range. Requires admin privileges. */
+    async getRevenue(opts) {
+        const params = new URLSearchParams();
+        if (opts?.since)
+            params.set("since", opts.since);
+        if (opts?.until)
+            params.set("until", opts.until);
+        const qs = params.toString();
+        return this.http.get(`/api/admin/revenue${qs ? `?${qs}` : ""}`);
+    }
+    /** Get daily revenue breakdown. Requires admin privileges. */
+    async getDailyRevenue(opts) {
+        const params = new URLSearchParams();
+        if (opts?.since)
+            params.set("since", opts.since);
+        if (opts?.until)
+            params.set("until", opts.until);
+        const qs = params.toString();
+        return this.http.get(`/api/admin/revenue/daily${qs ? `?${qs}` : ""}`);
+    }
+    /** Get system-wide statistics. Requires admin privileges. */
+    async getStats() {
+        return this.http.get("/api/admin/stats");
+    }
+}
+exports.AdminResource = AdminResource;

package/dist/cjs/auth.d.ts

@@ -0,0 +1,47 @@
+import type { HttpClient } from "./http.js";
+import type { User, LoginResult, MfaStatus, MfaSetup } from "./types.js";
+export declare class AuthResource {
+    private http;
+    constructor(http: HttpClient);
+    register(email: string, password: string): Promise<{
+        user: User;
+        token?: string;
+        refreshToken?: string;
+    }>;
+    login(email: string, password: string): Promise<LoginResult & {
+        token?: string;
+        refreshToken?: string;
+    }>;
+    verifyMfa(code: string, opts?: {
+        mfaChallengeToken?: string;
+        isBackupCode?: boolean;
+    }): Promise<{
+        user: User;
+        token: string;
+        refreshToken: string;
+    }>;
+    refresh(refreshToken: string): Promise<{
+        token: string;
+        refreshToken?: string;
+    }>;
+    logout(): Promise<void>;
+    me(): Promise<{
+        user: User;
+    }>;
+    changePassword(currentPassword: string, newPassword: string): Promise<void>;
+    verifyKey(apiKey: string): Promise<{
+        valid: boolean;
+        token: string;
+        refreshToken: string;
+        userId: string;
+        email: string;
+    }>;
+    mfaSetup(): Promise<MfaSetup>;
+    mfaEnable(code: string): Promise<{
+        enabled: boolean;
+    }>;
+    mfaDisable(password: string, code: string): Promise<{
+        enabled: boolean;
+    }>;
+    mfaStatus(): Promise<MfaStatus>;
+}

package/dist/cjs/auth.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthResource = void 0;
+class AuthResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async register(email, password) {
+        return this.http.post("/api/auth/register", { email, password }, false);
+    }
+    async login(email, password) {
+        return this.http.post("/api/auth/login", { email, password }, false);
+    }
+    async verifyMfa(code, opts) {
+        return this.http.post("/api/auth/mfa/verify", { code, ...opts }, false);
+    }
+    async refresh(refreshToken) {
+        return this.http.post("/api/auth/refresh", { refreshToken }, false);
+    }
+    async logout() {
+        await this.http.post("/api/auth/logout", {});
+    }
+    async me() {
+        return this.http.get("/api/auth/me");
+    }
+    async changePassword(currentPassword, newPassword) {
+        await this.http.post("/api/auth/change-password", { currentPassword, newPassword });
+    }
+    async verifyKey(apiKey) {
+        return this.http.post("/api/auth/verify-key", { apiKey }, false);
+    }
+    async mfaSetup() {
+        return this.http.post("/api/auth/mfa/setup", {});
+    }
+    async mfaEnable(code) {
+        return this.http.post("/api/auth/mfa/enable", { code });
+    }
+    async mfaDisable(password, code) {
+        return this.http.post("/api/auth/mfa/disable", { password, code });
+    }
+    async mfaStatus() {
+        return this.http.get("/api/auth/mfa/status");
+    }
+}
+exports.AuthResource = AuthResource;

package/dist/cjs/client.d.ts

@@ -0,0 +1,56 @@
+import { AuthResource } from "./auth.js";
+import { KeysResource } from "./keys.js";
+import { WalletResource } from "./wallet.js";
+import { UsageResource } from "./usage.js";
+import { PlansResource } from "./plans.js";
+import { SessionsResource } from "./sessions.js";
+import { ProxyResource } from "./proxy.js";
+import { AdminResource } from "./admin.js";
+import { SlotsResource } from "./slots.js";
+import { AgenticWalletResource } from "./resources/agent-wallet.js";
+import { TeamsResource } from "./resources/teams.js";
+import { X402Resource } from "./resources/x402.js";
+import { WalletAuthResource } from "./resources/wallet-auth.js";
+import type { DominusNodeConfig, LoginResult } from "./types.js";
+export declare class DominusNodeClient {
+    readonly auth: AuthResource;
+    readonly keys: KeysResource;
+    readonly wallet: WalletResource;
+    readonly usage: UsageResource;
+    readonly plans: PlansResource;
+    readonly sessions: SessionsResource;
+    readonly proxy: ProxyResource;
+    readonly admin: AdminResource;
+    readonly slots: SlotsResource;
+    readonly agenticWallets: AgenticWalletResource;
+    readonly teams: TeamsResource;
+    readonly x402: X402Resource;
+    readonly walletAuth: WalletAuthResource;
+    private tokenManager;
+    private http;
+    private apiKey;
+    constructor(config?: DominusNodeConfig);
+    /**
+     * Authenticate with an API key.
+     * Verifies the key against the server and stores the resulting JWT tokens
+     * for subsequent authenticated requests.
+     */
+    connectWithKey(apiKey: string): Promise<void>;
+    /**
+     * Authenticate with email and password.
+     * If MFA is required, the returned result will have `mfaRequired: true`.
+     * Call `completeMfa()` to finish authentication in that case.
+     */
+    connectWithCredentials(email: string, password: string): Promise<LoginResult>;
+    /**
+     * Complete MFA verification after a login that returned `mfaRequired: true`.
+     */
+    completeMfa(code: string, opts?: {
+        mfaChallengeToken?: string;
+        isBackupCode?: boolean;
+    }): Promise<void>;
+    /**
+     * Disconnect: revoke refresh tokens server-side (best-effort) and clear all stored tokens.
+     */
+    disconnect(): Promise<void>;
+}

package/dist/cjs/client.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DominusNodeClient = void 0;
+const token_manager_js_1 = require("./token-manager.js");
+const http_js_1 = require("./http.js");
+const auth_js_1 = require("./auth.js");
+const keys_js_1 = require("./keys.js");
+const wallet_js_1 = require("./wallet.js");
+const usage_js_1 = require("./usage.js");
+const plans_js_1 = require("./plans.js");
+const sessions_js_1 = require("./sessions.js");
+const proxy_js_1 = require("./proxy.js");
+const admin_js_1 = require("./admin.js");
+const slots_js_1 = require("./slots.js");
+const agent_wallet_js_1 = require("./resources/agent-wallet.js");
+const teams_js_1 = require("./resources/teams.js");
+const x402_js_1 = require("./resources/x402.js");
+const wallet_auth_js_1 = require("./resources/wallet-auth.js");
+const constants_js_1 = require("./constants.js");
+class DominusNodeClient {
+    auth;
+    keys;
+    wallet;
+    usage;
+    plans;
+    sessions;
+    proxy;
+    admin;
+    slots;
+    agenticWallets;
+    teams;
+    x402;
+    walletAuth;
+    tokenManager;
+    http;
+    apiKey = null;
+    constructor(config = {}) {
+        const baseUrl = config.baseUrl ?? constants_js_1.DEFAULT_BASE_URL;
+        this.tokenManager = new token_manager_js_1.TokenManager();
+        this.http = new http_js_1.HttpClient(baseUrl, this.tokenManager);
+        // Initialize all resource modules BEFORE setting refresh function
+        // this.auth must exist before refresh function can be invoked
+        this.auth = new auth_js_1.AuthResource(this.http);
+        this.keys = new keys_js_1.KeysResource(this.http);
+        this.wallet = new wallet_js_1.WalletResource(this.http);
+        this.usage = new usage_js_1.UsageResource(this.http);
+        this.plans = new plans_js_1.PlansResource(this.http);
+        this.sessions = new sessions_js_1.SessionsResource(this.http);
+        this.proxy = new proxy_js_1.ProxyResource(this.http, config);
+        this.admin = new admin_js_1.AdminResource(this.http);
+        this.slots = new slots_js_1.SlotsResource(this.http);
+        this.agenticWallets = new agent_wallet_js_1.AgenticWalletResource(this.http);
+        this.teams = new teams_js_1.TeamsResource(this.http);
+        this.x402 = new x402_js_1.X402Resource(this.http);
+        this.walletAuth = new wallet_auth_js_1.WalletAuthResource(this.http, this.tokenManager);
+        // Set refresh function AFTER auth is initialized
+        this.tokenManager.setRefreshFunction(async (rt) => {
+            const res = await this.auth.refresh(rt);
+            return { accessToken: res.token, refreshToken: res.refreshToken };
+        });
+        // Auto-authenticate if tokens were provided in config
+        if (config.accessToken) {
+            this.tokenManager.setTokens(config.accessToken, config.refreshToken);
+        }
+    }
+    /**
+     * Authenticate with an API key.
+     * Verifies the key against the server and stores the resulting JWT tokens
+     * for subsequent authenticated requests.
+     */
+    async connectWithKey(apiKey) {
+        const res = await this.auth.verifyKey(apiKey);
+        this.apiKey = apiKey;
+        this.tokenManager.setTokens(res.token, res.refreshToken);
+    }
+    /**
+     * Authenticate with email and password.
+     * If MFA is required, the returned result will have `mfaRequired: true`.
+     * Call `completeMfa()` to finish authentication in that case.
+     */
+    async connectWithCredentials(email, password) {
+        const res = await this.auth.login(email, password);
+        if (res.token) {
+            this.tokenManager.setTokens(res.token, res.refreshToken);
+        }
+        return { user: res.user, mfaRequired: res.mfaRequired };
+    }
+    /**
+     * Complete MFA verification after a login that returned `mfaRequired: true`.
+     */
+    async completeMfa(code, opts) {
+        const res = await this.auth.verifyMfa(code, opts);
+        this.tokenManager.setTokens(res.token, res.refreshToken);
+    }
+    /**
+     * Disconnect: revoke refresh tokens server-side (best-effort) and clear all stored tokens.
+     */
+    async disconnect() {
+        try {
+            await this.auth.logout();
+        }
+        catch {
+            // Best-effort — server may be unreachable
+        }
+        this.apiKey = null;
+        this.tokenManager.clear();
+    }
+}
+exports.DominusNodeClient = DominusNodeClient;

package/dist/cjs/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const SDK_VERSION = "1.0.0";
+export declare const USER_AGENT = "dominusnode-sdk-node/1.0.0";
+export declare const DEFAULT_BASE_URL = "https://api.dominusnode.com";
+export declare const DEFAULT_PROXY_HOST = "proxy.dominusnode.com";
+export declare const DEFAULT_HTTP_PROXY_PORT = 8080;
+export declare const DEFAULT_SOCKS5_PROXY_PORT = 1080;
+export declare const TOKEN_REFRESH_BUFFER_MS = 60000;
+export declare const MAX_RATE_LIMIT_RETRIES = 1;

package/dist/cjs/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_RATE_LIMIT_RETRIES = exports.TOKEN_REFRESH_BUFFER_MS = exports.DEFAULT_SOCKS5_PROXY_PORT = exports.DEFAULT_HTTP_PROXY_PORT = exports.DEFAULT_PROXY_HOST = exports.DEFAULT_BASE_URL = exports.USER_AGENT = exports.SDK_VERSION = void 0;
+exports.SDK_VERSION = "1.0.0";
+exports.USER_AGENT = `dominusnode-sdk-node/${exports.SDK_VERSION}`;
+exports.DEFAULT_BASE_URL = "https://api.dominusnode.com";
+exports.DEFAULT_PROXY_HOST = "proxy.dominusnode.com";
+exports.DEFAULT_HTTP_PROXY_PORT = 8080;
+exports.DEFAULT_SOCKS5_PROXY_PORT = 1080;
+exports.TOKEN_REFRESH_BUFFER_MS = 60_000; // Refresh 60s before expiry
+exports.MAX_RATE_LIMIT_RETRIES = 1;

package/dist/cjs/errors.d.ts

@@ -0,0 +1,36 @@
+export declare class DominusNodeError extends Error {
+    readonly statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+export declare class AuthenticationError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class AuthorizationError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class RateLimitError extends DominusNodeError {
+    readonly retryAfterSeconds: number;
+    constructor(message?: string, retryAfter?: number);
+}
+export declare class InsufficientBalanceError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class ValidationError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class ServerError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class NetworkError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class ProxyError extends DominusNodeError {
+    readonly proxyErrorCode?: string;
+    constructor(message: string, proxyErrorCode?: string);
+}

package/dist/cjs/errors.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyError = exports.NetworkError = exports.ServerError = exports.ConflictError = exports.NotFoundError = exports.ValidationError = exports.InsufficientBalanceError = exports.RateLimitError = exports.AuthorizationError = exports.AuthenticationError = exports.DominusNodeError = void 0;
+class DominusNodeError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "DominusNodeError";
+    }
+}
+exports.DominusNodeError = DominusNodeError;
+class AuthenticationError extends DominusNodeError {
+    constructor(message = "Authentication failed") {
+        super(message, 401);
+        this.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class AuthorizationError extends DominusNodeError {
+    constructor(message = "Access denied") {
+        super(message, 403);
+        this.name = "AuthorizationError";
+    }
+}
+exports.AuthorizationError = AuthorizationError;
+class RateLimitError extends DominusNodeError {
+    retryAfterSeconds;
+    constructor(message = "Rate limit exceeded", retryAfter = 60) {
+        super(message, 429);
+        this.name = "RateLimitError";
+        this.retryAfterSeconds = retryAfter;
+    }
+}
+exports.RateLimitError = RateLimitError;
+class InsufficientBalanceError extends DominusNodeError {
+    constructor(message = "Insufficient balance") {
+        super(message, 402);
+        this.name = "InsufficientBalanceError";
+    }
+}
+exports.InsufficientBalanceError = InsufficientBalanceError;
+class ValidationError extends DominusNodeError {
+    constructor(message = "Validation failed") {
+        super(message, 400);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;
+class NotFoundError extends DominusNodeError {
+    constructor(message = "Resource not found") {
+        super(message, 404);
+        this.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+class ConflictError extends DominusNodeError {
+    constructor(message = "Resource conflict") {
+        super(message, 409);
+        this.name = "ConflictError";
+    }
+}
+exports.ConflictError = ConflictError;
+class ServerError extends DominusNodeError {
+    constructor(message = "Server error") {
+        super(message, 500);
+        this.name = "ServerError";
+    }
+}
+exports.ServerError = ServerError;
+class NetworkError extends DominusNodeError {
+    constructor(message = "Network error") {
+        super(message);
+        this.name = "NetworkError";
+    }
+}
+exports.NetworkError = NetworkError;
+class ProxyError extends DominusNodeError {
+    proxyErrorCode;
+    constructor(message, proxyErrorCode) {
+        super(message);
+        this.name = "ProxyError";
+        this.proxyErrorCode = proxyErrorCode;
+    }
+}
+exports.ProxyError = ProxyError;

package/dist/cjs/http.d.ts

@@ -0,0 +1,19 @@
+import type { TokenManager } from "./token-manager.js";
+export interface HttpOptions {
+    method: string;
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    requiresAuth?: boolean;
+}
+export declare class HttpClient {
+    private baseUrl;
+    private tokenManager;
+    constructor(baseUrl: string, tokenManager: TokenManager);
+    request<T>(opts: HttpOptions): Promise<T>;
+    get<T>(path: string, requiresAuth?: boolean): Promise<T>;
+    post<T>(path: string, body?: unknown, requiresAuth?: boolean): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}