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

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

@@ -1,19 +1,25 @@
-import { Config } from '@oclif/core/interfaces';
 import pino from 'pino';
-import { CliConfig } from '../config/config.schema.js';
+import { Auth, CliConfig } from '../config/config.schema.js';
 import { IConfigManager } from '../interfaces/config-manager.interface.js';
 export declare class ConfigManager implements IConfigManager {
-    private readonly oclifConfig;
-    private readonly logger;
     private readonly configFile;
+    private readonly logger;
     private config;
-    constructor(oclifConfig: Config, logger: pino.BaseLogger, configFile?: string);
-    get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): Promise<V>;
+    private readonly configDir;
+    constructor(configFile: string, logger: pino.BaseLogger);
+    get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): Promise<undefined | V>;
     getConfig(): CliConfig;
+    getCookies(): Promise<unknown>;
+    getCredentials(): Promise<{
+        accessKey: string;
+    } | undefined>;
     init(): Promise<void>;
     load(): Promise<CliConfig>;
+    makeBackup(): void;
     save(): Promise<void>;
     set<K extends keyof CliConfig, V extends CliConfig[K]>(key: K, value: V): Promise<void>;
+    setCookies(cookies: unknown): Promise<void>;
+    setCredentials(auth: Auth): Promise<void>;
     private getConfigPath;
     private hasConfig;
 }

package/dist/managers/config-manager.js

@@ -1,16 +1,17 @@
 import { ux } from '@oclif/core';
 import * as fs from 'node:fs';
 import path from 'node:path';
+import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS } from '../constants.js';
 import { ConfigurationNotFoundError } from '../errors.js';
 export class ConfigManager {
-    oclifConfig;
-    logger;
     configFile;
+    logger;
     config = {};
-    constructor(oclifConfig, logger, configFile = 'config.json') {
-        this.oclifConfig = oclifConfig;
-        this.logger = logger;
+    configDir;
+    constructor(configFile, logger) {
         this.configFile = configFile;
+        this.logger = logger;
+        this.configDir = path.dirname(configFile);
     }
     async get(key) {
         return this.config[key];
@@ -23,22 +24,30 @@ export class ConfigManager {
         const raw = fs.readFileSync(configPath, 'utf8');
         return JSON.parse(raw);
     }
+    getCookies() {
+        return this.get('cookies');
+    }
+    getCredentials() {
+        return this.get('auth');
+    }
     async init() {
         try {
             await this.load();
         }
         catch (error) {
             if (error instanceof ConfigurationNotFoundError) {
-                ux.stdout('Config file not found. Creating new one ');
+                this.logger.error({ err: error }, 'Config file not found. Creating new one');
                 await this.save();
             }
             else if (error instanceof SyntaxError) {
-                ux.stdout('Config file corrupted');
+                this.makeBackup();
+                this.logger.error({ err: error }, 'Config file corrupted');
                 await this.save();
             }
             else {
-                ux.stderr('Something went wrong');
-                this.logger.error(error);
+                this.makeBackup();
+                this.logger.error({ err: error }, 'Something went wrong');
+                ux.error('Something went wrong', { exit: 1 });
             }
         }
     }
@@ -47,21 +56,36 @@ export class ConfigManager {
         this.config = config;
         return this.config;
     }
+    makeBackup() {
+        if (this.hasConfig()) {
+            fs.renameSync(this.getConfigPath(), `${this.getConfigPath()}.${Date.now()}.bak`);
+        }
+    }
     async save() {
-        fs.mkdirSync(this.oclifConfig.configDir, { recursive: true });
-        console.log(this.getConfigPath(), JSON.stringify(this.config));
+        fs.mkdirSync(this.configDir, { mode: DIR_ACCESS_PERMS, recursive: true });
+        this.logger.debug({ configFile: this.getConfigPath() }, 'Saving config file');
         fs.writeFileSync(this.getConfigPath(), JSON.stringify(this.config, undefined, '  '), {
             encoding: 'utf8',
-            flush: true,
+            flag: 'w',
+            mode: FILE_ACCESS_PERMS,
         });
     }
     async set(key, value) {
         this.config[key] = value;
-        this.logger.debug({ key, value }, 'Saving parametes to file');
+        this.logger.debug({ key }, 'Saving parameters to file');
         await this.save();
     }
+    async setCookies(cookies) {
+        await this.set('cookies', cookies);
+    }
+    async setCredentials(auth) {
+        await this.set('auth', auth);
+    }
     getConfigPath() {
-        return path.join(this.oclifConfig.configDir, this.configFile);
+        if (path.isAbsolute(this.configFile)) {
+            return this.configFile;
+        }
+        return path.join(this.configDir, this.configFile);
     }
     hasConfig() {
         const configPath = this.getConfigPath();

package/dist/managers/index.d.ts

@@ -1,4 +1,3 @@
 export * from './account-manager.js';
-export * from './auth-manager.js';
+export * from './config-file-manager.js';
 export * from './config-manager.js';
-export * from './cookies-manager.js';

package/dist/managers/index.js

@@ -1,4 +1,3 @@
 export * from './account-manager.js';
-export * from './auth-manager.js';
+export * from './config-file-manager.js';
 export * from './config-manager.js';
-export * from './cookies-manager.js';

package/dist/middlewares/auth-middleware.d.ts

@@ -0,0 +1,9 @@
+import type { MiddlewareFn, ProviderClient } from '@super-protocol/provider-client';
+import type pino from 'pino';
+import { type Auth } from '../config/config.schema.js';
+interface CredentialsStorage {
+    getCredentials(): Promise<Auth | undefined>;
+    setCredentials(auth: Auth): void;
+}
+export declare function createAuthMiddleware(configManager: CredentialsStorage, providerClient: ProviderClient, logger: pino.BaseLogger): Promise<ReturnType<MiddlewareFn>>;
+export {};

package/dist/middlewares/auth-middleware.js

@@ -0,0 +1,87 @@
+import { decode } from 'jsonwebtoken';
+import { AuthorizationRequiredError } from '../errors.js';
+function 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;
+    }
+}
+export async function createAuthMiddleware(configManager, providerClient, logger) {
+    let auth;
+    let refreshPromise;
+    const performRefresh = async () => {
+        if (!auth) {
+            return undefined;
+        }
+        logger.info('Performed refresh token');
+        let refreshResult;
+        try {
+            refreshResult = await providerClient.POST('/api/auth/refresh-access');
+        }
+        catch (error) {
+            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) {
+            logger.error({ refreshError }, 'Failure refresh response');
+            throw new AuthorizationRequiredError(`Unable to refresh access key: ${JSON.stringify(refreshError)}`);
+        }
+        if (!data || !data.accessToken) {
+            logger.error({ response: data }, 'Server returned incorrect response');
+            throw new AuthorizationRequiredError('Provider returned an unexpected refresh response.');
+        }
+        const updatedAuth = {
+            accessKey: data.accessToken,
+        };
+        await setCredentials(updatedAuth);
+        return updatedAuth.accessKey;
+    };
+    const refreshAccessKey = async () => {
+        if (!auth) {
+            return undefined;
+        }
+        if (!refreshPromise) {
+            refreshPromise = performRefresh().finally(() => {
+                refreshPromise = undefined;
+            });
+        }
+        return refreshPromise;
+    };
+    const ensureAccessKey = async (forceRefresh = false) => {
+        if (!auth) {
+            return undefined;
+        }
+        const { accessKey } = auth;
+        if (!forceRefresh && accessKey && !isAccessKeyExpired(accessKey)) {
+            return accessKey;
+        }
+        return refreshAccessKey();
+    };
+    const setCredentials = async (newAuth) => {
+        auth = newAuth;
+        await configManager.setCredentials(newAuth);
+    };
+    auth = await configManager.getCredentials();
+    if (!auth) {
+        throw new AuthorizationRequiredError('Authorization not found please login first');
+    }
+    const middleware = {
+        async onRequest({ request }) {
+            const accessToken = await ensureAccessKey();
+            if (accessToken) {
+                request.headers.set('Authorization', `Bearer ${accessToken}`);
+            }
+            return request;
+        },
+    };
+    return middleware;
+}

package/dist/middlewares/cookies-middleware.d.ts

@@ -0,0 +1,8 @@
+import type { MiddlewareFn } from '@super-protocol/provider-client';
+import type pino from 'pino';
+interface CookiesStorage {
+    getCookies(): Promise<unknown>;
+    setCookies(cookies: unknown): Promise<void>;
+}
+export declare const createCookieMiddleware: (configManager: CookiesStorage, logger: pino.BaseLogger, baseUrl: string) => Promise<ReturnType<MiddlewareFn>>;
+export {};

package/dist/middlewares/cookies-middleware.js

@@ -0,0 +1,80 @@
+import { CookieJar } from 'tough-cookie';
+const 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] : [];
+};
+export const createCookieMiddleware = async (configManager, logger, baseUrl) => {
+    let cookieJar = new CookieJar();
+    const loadCookieJar = async () => {
+        try {
+            const stored = await configManager.getCookies();
+            if (stored && typeof stored === 'object') {
+                cookieJar = CookieJar.fromJSON(stored);
+                return;
+            }
+        }
+        catch (error) {
+            logger.warn({ err: error }, 'Failed to load cookies from config');
+        }
+        cookieJar = new CookieJar();
+    };
+    const persistCookieJar = async () => {
+        try {
+            const serialized = cookieJar.toJSON();
+            await configManager.setCookies(serialized);
+        }
+        catch (error) {
+            logger.warn({ err: error }, 'Failed to persist cookies');
+        }
+    };
+    await loadCookieJar();
+    return {
+        async onRequest({ request }) {
+            const requestUrl = request.url ?? baseUrl;
+            try {
+                const cookieHeader = await cookieJar.getCookieString(requestUrl);
+                if (cookieHeader) {
+                    request.headers.set('Cookie', cookieHeader);
+                }
+            }
+            catch (error) {
+                logger.warn({ err: error, requestUrl }, 'Failed to attach cookies to request');
+            }
+        },
+        async onResponse({ response }) {
+            const rawCookies = extractSetCookieHeaders(response);
+            if (rawCookies.length === 0) {
+                return response;
+            }
+            const targetUrl = response.url || baseUrl;
+            const updates = await Promise.all(rawCookies.map(async (rawCookie) => {
+                try {
+                    const storedCookie = await cookieJar.setCookie(rawCookie, targetUrl);
+                    if (storedCookie) {
+                        logger.debug({ cookie: storedCookie.key }, 'Updated cookie from response');
+                    }
+                    return true;
+                }
+                catch (error) {
+                    logger.warn({ err: error, rawCookie }, 'Failed to store cookie from response');
+                    return false;
+                }
+            }));
+            if (updates.some(Boolean)) {
+                await persistCookieJar();
+            }
+            return response;
+        },
+    };
+};

package/dist/utils/helper.d.ts

@@ -0,0 +1 @@
+export declare const getConfigName: (name: string) => string;

package/dist/utils/helper.js

@@ -0,0 +1 @@
+export const getConfigName = (name) => name.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-') + '.config.json';