@super-protocol/sp-cli 0.0.1-alpha.35 → 0.0.2

package/dist/commands/refresh.d.ts

@@ -1,4 +0,0 @@
-import { SpCommand } from '../interfaces/index.js';
-export default class Refresh extends SpCommand {
-    run(): Promise<void>;
-}

package/dist/commands/refresh.js

@@ -1,7 +0,0 @@
-import { SpCommand } from '../interfaces/index.js';
-export default class Refresh extends SpCommand {
-    async run() {
-        await this.authManager.ensureAccessKey(true);
-        this.log('Access token refreshed');
-    }
-}

package/dist/config/constants.d.ts

@@ -1 +0,0 @@
-export declare const PROVIDER_BASE_URL: string;

package/dist/config/constants.js

@@ -1,2 +0,0 @@
-// TODO: store sticky cookies for prevent request round robin
-export const PROVIDER_BASE_URL = process.env.SP_BASE_URL ?? 'https://provider-api1.staging.superprotocol.io/';

package/dist/interfaces/abstract.command.d.ts

@@ -1,16 +0,0 @@
-import { Command } from '@oclif/core';
-import { ProviderClient } from '@super-protocol/provider-client';
-import pino from 'pino';
-import { AuthManager, CookiesManager } from '../managers/index.js';
-import { IAccountManager } from './account-manager.interface.js';
-import { IConfigManager } from './config-manager.interface.js';
-export declare abstract class SpCommand extends Command {
-    protected accountManager: IAccountManager;
-    protected authManager: AuthManager;
-    protected configManager: IConfigManager;
-    protected cookiesManager: CookiesManager;
-    protected logger: pino.BaseLogger;
-    protected providerClient: ProviderClient;
-    getConfigManager(): IConfigManager;
-    init(): Promise<void>;
-}

package/dist/interfaces/abstract.command.js

@@ -1,59 +0,0 @@
-import { Command } from '@oclif/core';
-import { createProviderClient, loggerMiddleware, requestIdMiddleware, } from '@super-protocol/provider-client';
-import pino from 'pino';
-import { PROVIDER_BASE_URL } from '../config/constants.js';
-import { AccountManager, AuthManager, ConfigManager, CookiesManager, } from '../managers/index.js';
-export class SpCommand extends Command {
-    accountManager;
-    authManager;
-    configManager;
-    cookiesManager;
-    logger;
-    providerClient;
-    getConfigManager() {
-        return this.configManager;
-    }
-    async init() {
-        this.logger = pino({
-            level: process.env.SP_LOG_LEVEL || 'silent',
-            transport: {
-                options: {
-                    colorize: true,
-                },
-                target: 'pino-pretty',
-            },
-        });
-        await super.init();
-        this.logger.info('Initializing config manager');
-        this.configManager = new ConfigManager(this.config, this.logger);
-        await this.configManager.init(this.id);
-        this.logger.info('Initializing account manager');
-        this.accountManager = new AccountManager(this.configManager, this.logger);
-        await this.accountManager.init(this.id);
-        this.logger.info('Initializing provider client');
-        this.providerClient = createProviderClient({
-            baseUrl: PROVIDER_BASE_URL,
-            logger: this.logger,
-            middlewares: [requestIdMiddleware, loggerMiddleware],
-        });
-        this.providerClient.use({
-            onRequest: async ({ request }) => {
-                const req = request.clone();
-                const readBody = await req.body?.getReader().read();
-                let body;
-                if (readBody && readBody.value)
-                    body = Buffer.from(readBody.value).toString('utf8');
-                this.logger.debug({
-                    body,
-                    url: req.url,
-                }, 'Requesting');
-            },
-        });
-        this.logger.info('Initializing cookies manager');
-        this.cookiesManager = new CookiesManager(this.configManager, this.providerClient, this.logger, PROVIDER_BASE_URL);
-        await this.cookiesManager.init(this.id);
-        this.logger.info('Initializing authorization manager');
-        this.authManager = new AuthManager(this.configManager, this.providerClient, this.logger);
-        await this.authManager.init(this.id);
-    }
-}

package/dist/managers/auth-manager.d.ts

@@ -1,19 +0,0 @@
-import type { ProviderClient } from '@super-protocol/provider-client';
-import pino from 'pino';
-import { Auth } from '../config/config.schema.js';
-import { IConfigManager, IManager } from '../interfaces/index.js';
-export declare class AuthManager implements IManager {
-    private readonly configManager;
-    private readonly providerClient;
-    private readonly logger;
-    private auth?;
-    private refreshPromise?;
-    private readonly skipCommands;
-    constructor(configManager: IConfigManager, providerClient: ProviderClient, logger: pino.BaseLogger);
-    ensureAccessKey(forceRefresh?: boolean): Promise<string | undefined>;
-    init(command?: string): Promise<void>;
-    setCredentials(auth: Auth): Promise<void>;
-    private isAccessKeyExpired;
-    private performRefresh;
-    private refreshAccessKey;
-}

package/dist/managers/auth-manager.js

@@ -1,101 +0,0 @@
-import { decode } from 'jsonwebtoken';
-import { AuthorizationRequiredError } from '../errors.js';
-export class AuthManager {
-    configManager;
-    providerClient;
-    logger;
-    auth;
-    refreshPromise;
-    skipCommands = ['init', 'help', 'version', 'auth:login'];
-    constructor(configManager, providerClient, logger) {
-        this.configManager = configManager;
-        this.providerClient = providerClient;
-        this.logger = logger;
-    }
-    async ensureAccessKey(forceRefresh = false) {
-        if (!this.auth) {
-            return undefined;
-        }
-        const { accessKey } = this.auth;
-        if (!forceRefresh && accessKey && !this.isAccessKeyExpired(accessKey)) {
-            return accessKey;
-        }
-        return this.refreshAccessKey();
-    }
-    async init(command) {
-        if (command && this.skipCommands.includes(command)) {
-            return;
-        }
-        this.auth = await this.configManager.get('auth');
-        if (!this.auth) {
-            throw new AuthorizationRequiredError('Authorization not found please login first');
-        }
-        this.logger.info('Setup authorization middleware');
-        this.providerClient.use({
-            onRequest: async ({ request }) => {
-                const accessToken = await this.ensureAccessKey();
-                if (accessToken) {
-                    request.headers.set('Authorization', `Bearer ${accessToken}`);
-                }
-                return request;
-            },
-        });
-    }
-    async setCredentials(auth) {
-        this.auth = auth;
-        await this.configManager.set('auth', auth);
-    }
-    isAccessKeyExpired(accessKey) {
-        try {
-            const payload = decode(accessKey);
-            if (!payload || typeof payload.exp !== 'number') {
-                return true;
-            }
-            const now = Math.floor(Date.now() / 1000);
-            return now >= payload.exp;
-        }
-        catch {
-            return true;
-        }
-    }
-    async performRefresh() {
-        if (!this.auth) {
-            return undefined;
-        }
-        this.logger.info('Performed refresh token');
-        let refreshResult;
-        try {
-            refreshResult = await this.providerClient.POST('/api/auth/refresh-access');
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'failure refresh token');
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            throw new AuthorizationRequiredError(`Unable to reach provider API: ${message}`);
-        }
-        const { data, error: refreshError } = refreshResult;
-        if (refreshError) {
-            this.logger.error({ refreshError }, 'Faulire refresh response');
-            throw new AuthorizationRequiredError(`Unable to refresh access key: ${JSON.stringify(refreshError)}`);
-        }
-        if (!data || !data.accessToken) {
-            this.logger.error({ response: data }, 'Server returned incorrect response');
-            throw new AuthorizationRequiredError('Provider returned an unexpected refresh response.');
-        }
-        const updatedAuth = {
-            accessKey: data.accessToken,
-        };
-        this.setCredentials(updatedAuth);
-        return updatedAuth.accessKey;
-    }
-    async refreshAccessKey() {
-        if (!this.auth) {
-            return undefined;
-        }
-        if (!this.refreshPromise) {
-            this.refreshPromise = this.performRefresh().finally(() => {
-                this.refreshPromise = undefined;
-            });
-        }
-        return this.refreshPromise;
-    }
-}

package/dist/managers/cookies-manager.d.ts

@@ -1,15 +0,0 @@
-import type { ProviderClient } from '@super-protocol/provider-client';
-import type pino from 'pino';
-import type { IConfigManager, IManager } from '../interfaces/index.js';
-export declare class CookiesManager implements IManager {
-    private readonly configManager;
-    private readonly providerClient;
-    private readonly logger;
-    private readonly baseUrl;
-    private cookieJar;
-    constructor(configManager: IConfigManager, providerClient: ProviderClient, logger: pino.BaseLogger, baseUrl: string);
-    init(_command?: string): Promise<void>;
-    private extractSetCookieHeaders;
-    private loadCookieJar;
-    private persistCookieJar;
-}

package/dist/managers/cookies-manager.js

@@ -1,92 +0,0 @@
-import { CookieJar } from 'tough-cookie';
-export class CookiesManager {
-    configManager;
-    providerClient;
-    logger;
-    baseUrl;
-    cookieJar = new CookieJar();
-    constructor(configManager, providerClient, logger, baseUrl) {
-        this.configManager = configManager;
-        this.providerClient = providerClient;
-        this.logger = logger;
-        this.baseUrl = baseUrl;
-    }
-    async init(_command) {
-        await this.loadCookieJar();
-        this.providerClient.use({
-            onRequest: async ({ request }) => {
-                const requestUrl = request.url ?? this.baseUrl;
-                try {
-                    const cookieHeader = await this.cookieJar.getCookieString(requestUrl);
-                    if (cookieHeader) {
-                        request.headers.set('Cookie', cookieHeader);
-                    }
-                }
-                catch (error) {
-                    this.logger.warn({ err: error, requestUrl }, 'Failed to attach cookies to request');
-                }
-            },
-            onResponse: async ({ response }) => {
-                const rawCookies = this.extractSetCookieHeaders(response);
-                if (rawCookies.length === 0) {
-                    return response;
-                }
-                const targetUrl = response.url || this.baseUrl;
-                const updates = await Promise.all(rawCookies.map(async (rawCookie) => {
-                    try {
-                        const storedCookie = await this.cookieJar.setCookie(rawCookie, targetUrl);
-                        if (storedCookie) {
-                            this.logger.debug({ cookie: storedCookie.key }, 'Updated cookie from response');
-                        }
-                        return true;
-                    }
-                    catch (error) {
-                        this.logger.warn({ err: error, rawCookie }, 'Failed to store cookie from response');
-                        return false;
-                    }
-                }));
-                if (updates.some(Boolean)) {
-                    await this.persistCookieJar();
-                }
-                return response;
-            },
-        });
-    }
-    extractSetCookieHeaders(response) {
-        const cookiesFromGetter = response.headers.getSetCookie?.();
-        if (cookiesFromGetter && cookiesFromGetter.length > 0) {
-            return cookiesFromGetter;
-        }
-        // For capability to nodejs < 20
-        const headersWithRaw = response.headers;
-        const raw = headersWithRaw.raw?.();
-        const headerList = raw?.['set-cookie'];
-        if (headerList && headerList.length > 0) {
-            return headerList;
-        }
-        const headerValue = response.headers.get('set-cookie');
-        return headerValue ? [headerValue] : [];
-    }
-    async loadCookieJar() {
-        try {
-            const stored = await this.configManager.get('cookies');
-            if (stored && typeof stored === 'object') {
-                this.cookieJar = CookieJar.fromJSON(stored);
-                return;
-            }
-        }
-        catch (error) {
-            this.logger.warn({ err: error }, 'Failed to load cookies from config');
-        }
-        this.cookieJar = new CookieJar();
-    }
-    async persistCookieJar() {
-        try {
-            const serialized = this.cookieJar.toJSON();
-            await this.configManager.set('cookies', serialized);
-        }
-        catch (error) {
-            this.logger.warn({ err: error }, 'Failed to persist cookies');
-        }
-    }
-}