@super-protocol/sp-cli 0.0.8 → 0.0.10-beta

package/dist/lib/container.d.ts

@@ -1,6 +1,6 @@
 import type { Config } from '@oclif/core';
-import { type ProviderClient } from '@super-protocol/provider-client';
 import { AccountManager, ConfigFileManager, ConfigManager } from '../managers/index.js';
+import { type SwarmClient } from './swarm-client/index.js';
 interface RuntimeConfig {
     configFile?: string;
 }
@@ -11,31 +11,23 @@ export declare class AppContainer {
     private _accountManager?;
     private _configFileManager?;
     private _configManager?;
-    private _providerClient?;
-    private providerClientOptions?;
+    private _swarmClient?;
     private readonly initQueue;
     private logger;
-    private providerClientInitToken;
     private runtimeConfigFile?;
     private constructor();
     static initialize(currentDir: string, config: Config): AppContainer;
     get accountManager(): AccountManager;
     get configFileManager(): ConfigFileManager;
     get configManager(): ConfigManager;
+    get swarmClient(): SwarmClient;
     static get container(): AppContainer;
-    get providerClient(): ProviderClient;
     build(): Promise<this>;
     initAccountManager(rebuild?: boolean): this;
-    initBlockchainConnector(): this;
+    initSwarmClient(rebuild?: boolean): this;
     initConfigFileManager(rebuild?: boolean): this;
     initConfigManager(rebuild?: boolean): this;
-    initProviderClient({ enableAuth, enableCookies, rebuild, }?: {
-        enableAuth?: boolean;
-        enableCookies?: boolean;
-        rebuild?: boolean;
-    }): this;
     setupRuntimeConfig(config: RuntimeConfig): this;
-    private getProviderClientForBootstrap;
     private queueInit;
     private waitFor;
 }

package/dist/lib/container.js

@@ -1,11 +1,7 @@
 import path from 'node:path';
-import { createProviderClient, loggerMiddleware, requestIdMiddleware, } from '@super-protocol/provider-client';
-import { BlockchainConnector } from '@super-protocol/sdk-js';
-import { PROVIDER_URL } from '../constants.js';
 import logger from '../logger.js';
 import { AccountManager, ConfigFileManager, ConfigManager } from '../managers/index.js';
-import { createAuthMiddleware } from '../middlewares/auth-middleware.js';
-import { createCookieMiddleware } from '../middlewares/cookies-middleware.js';
+import { createSwarmClient } from './swarm-client/index.js';
 export class AppContainer {
     cwdDir;
     oclifConfig;
@@ -13,11 +9,9 @@ export class AppContainer {
     _accountManager;
     _configFileManager;
     _configManager;
-    _providerClient;
-    providerClientOptions;
+    _swarmClient;
     initQueue = new Map();
     logger;
-    providerClientInitToken = 0;
     runtimeConfigFile;
     constructor(cwdDir, oclifConfig) {
         this.cwdDir = cwdDir;
@@ -48,18 +42,18 @@ export class AppContainer {
         }
         return this._configManager;
     }
+    get swarmClient() {
+        if (!this._swarmClient) {
+            throw new Error('Swarm client not initialized');
+        }
+        return this._swarmClient;
+    }
     static get container() {
         if (!AppContainer.appContainer) {
             throw new Error('AppContainer not initialized');
         }
         return AppContainer.appContainer;
     }
-    get providerClient() {
-        if (!this._providerClient) {
-            throw new Error('Provider client not initialized');
-        }
-        return this._providerClient;
-    }
     async build() {
         await Promise.all(this.initQueue.values());
         return this;
@@ -80,26 +74,26 @@ export class AppContainer {
             this._accountManager = accountManager;
         }, rebuild);
     }
-    initBlockchainConnector() {
-        this.initConfigManager();
-        return this.queueInit('blockchainConnector', async () => {
+    initSwarmClient(rebuild = false) {
+        this.initConfigManager(rebuild);
+        return this.queueInit('swarmClient', async () => {
             await this.waitFor('configManager', { required: true });
-            let blockchainConfig = await this.configManager.get('blockchain');
-            if (!blockchainConfig) {
-                const client = await this.getProviderClientForBootstrap();
-                const { data, error } = await client.GET('/api/config');
-                if (error || !data) {
-                    throw new Error('Could not get configuration from provider');
-                }
-                blockchainConfig = {
-                    blockchainUrl: data.blockchainUrl,
-                    contractAddress: data.contractAddress,
-                };
-                await this.configManager.set('blockchain', blockchainConfig);
+            if (this._swarmClient && !rebuild) {
+                return;
             }
-            this.logger.info('Initializing blockchain connector');
-            await BlockchainConnector.getInstance().initialize(blockchainConfig);
-        });
+            if (rebuild) {
+                this._swarmClient = undefined;
+            }
+            const swarmUrl = await this.configManager.get('swarmUrl');
+            const auth = await this.configManager.getCredentials();
+            const accessToken = auth?.accessKey;
+            this.logger.info('Initializing swarm client');
+            this._swarmClient = createSwarmClient({
+                accessToken,
+                baseUrl: swarmUrl,
+                logger: this.logger,
+            });
+        }, rebuild);
     }
     initConfigFileManager(rebuild = false) {
         return this.queueInit('configFileManager', async () => {
@@ -136,66 +130,6 @@ export class AppContainer {
             this._configManager = configManager;
         }, rebuild);
     }
-    initProviderClient({ enableAuth = true, enableCookies = true, rebuild = false, } = {}) {
-        this.initConfigManager();
-        const options = { enableAuth, enableCookies };
-        const optionsChanged = this.providerClientOptions &&
-            (this.providerClientOptions.enableAuth !== options.enableAuth ||
-                this.providerClientOptions.enableCookies !== options.enableCookies);
-        if (optionsChanged) {
-            rebuild = true;
-            this.logger.debug({ newOptions: options, oldOptions: this.providerClientOptions }, 'Provider client options changed, rebuilding');
-        }
-        const shouldSchedule = rebuild || !this.initQueue.has('providerClient');
-        const initToken = shouldSchedule
-            ? ++this.providerClientInitToken
-            : this.providerClientInitToken;
-        return this.queueInit('providerClient', async () => {
-            if (this._providerClient && !rebuild) {
-                return;
-            }
-            if (rebuild && this._providerClient) {
-                this.logger.debug('Clearing existing provider client for rebuild');
-                this._providerClient = undefined;
-            }
-            await this.waitFor('configManager', { required: true });
-            const providerUrl = (await this.configManager.get('providerUrl')) || PROVIDER_URL;
-            this.logger.info('Initializing provider client');
-            const providerClient = createProviderClient({
-                baseUrl: providerUrl,
-                logger: this.logger,
-                middlewares: [requestIdMiddleware, loggerMiddleware],
-            });
-            if (enableCookies) {
-                this.logger.info('Initializing cookie middleware');
-                const cookiesMiddleware = await createCookieMiddleware(this.configManager, this.logger, providerUrl);
-                providerClient.use(cookiesMiddleware);
-            }
-            if (enableAuth) {
-                this.logger.info('Initializing auth middleware');
-                const authMiddleware = await createAuthMiddleware(this.configManager, providerClient, this.logger);
-                providerClient.use(authMiddleware);
-            }
-            if (process.env.SP_CLI_DEBUG_REQUESTS === '1') {
-                providerClient.use({
-                    onRequest: async ({ request }) => {
-                        this.logger.debug({
-                            hasAuthHeader: Boolean(request.headers.get('Authorization')),
-                            hasBody: Boolean(request.body),
-                            method: request.method,
-                            url: request.url,
-                        }, 'Requesting');
-                    },
-                });
-            }
-            if (initToken !== this.providerClientInitToken) {
-                this.logger.debug({ initToken, providerClientInitToken: this.providerClientInitToken }, 'Skipping provider client assignment (superseded)');
-                return;
-            }
-            this._providerClient = providerClient;
-            this.providerClientOptions = options;
-        }, rebuild);
-    }
     setupRuntimeConfig(config) {
         const previousRuntimeConfigFile = this.runtimeConfigFile;
         if (config.configFile) {
@@ -211,11 +145,10 @@ export class AppContainer {
             this.logger.debug({ previousRuntimeConfigFile, runtimeConfigFile: this.runtimeConfigFile }, 'Runtime config changed; clearing dependent services');
             this._configManager = undefined;
             this._accountManager = undefined;
-            this._providerClient = undefined;
-            this.providerClientOptions = undefined;
+            this._swarmClient = undefined;
             this.initQueue.delete('configManager');
             this.initQueue.delete('accountManager');
-            this.initQueue.delete('providerClient');
+            this.initQueue.delete('swarmClient');
             this.initQueue.delete('blockchainConnector');
             this.initQueue.delete('configFileManager');
         }
@@ -224,24 +157,6 @@ export class AppContainer {
         }
         return this;
     }
-    async getProviderClientForBootstrap() {
-        if (this._providerClient) {
-            return this._providerClient;
-        }
-        const queued = this.initQueue.get('providerClient');
-        if (queued) {
-            await queued;
-            return this.providerClient;
-        }
-        await this.waitFor('configManager', { required: true });
-        const providerUrl = (await this.configManager.get('providerUrl')) || PROVIDER_URL;
-        this.logger.debug({ providerUrl }, 'Creating bootstrap provider client');
-        return createProviderClient({
-            baseUrl: providerUrl,
-            logger: this.logger,
-            middlewares: [requestIdMiddleware, loggerMiddleware],
-        });
-    }
     queueInit(name, task, force = false) {
         if (force) {
             this.initQueue.delete(name);

package/dist/lib/swarm-client/fetch-api.d.ts

@@ -0,0 +1,7 @@
+import { type ApiFetcher } from '@ts-rest/core';
+type FetchApiConfig = {
+    fetchClient?: typeof fetch;
+    timeout?: number;
+};
+export declare const createSwarmFetchApi: ({ fetchClient, timeout, }: FetchApiConfig) => ApiFetcher;
+export {};

package/dist/lib/swarm-client/fetch-api.js

@@ -0,0 +1,41 @@
+import { isZodType } from '@ts-rest/core';
+import { fetchWithTimeoutClient } from './fetch-timeout.client.js';
+export const createSwarmFetchApi = ({ fetchClient = fetch, timeout, }) => {
+    const fetchWithTimeout = fetchWithTimeoutClient(fetchClient, timeout);
+    return async ({ route, path, method, headers, body, validateResponse, fetchOptions }) => {
+        const result = await fetchWithTimeout(path, {
+            ...fetchOptions,
+            method,
+            headers,
+            body,
+        });
+        const contentType = result.headers.get('content-type');
+        if (contentType?.includes('application/') && contentType.includes('json')) {
+            const response = {
+                status: result.status,
+                body: await result.json(),
+                headers: result.headers,
+            };
+            const responseSchema = route.responses[response.status];
+            if ((validateResponse ?? route.validateResponseOnClient) && isZodType(responseSchema)) {
+                return {
+                    ...response,
+                    body: responseSchema.parse(response.body),
+                };
+            }
+            return response;
+        }
+        if (contentType?.includes('text/')) {
+            return {
+                status: result.status,
+                body: await result.text(),
+                headers: result.headers,
+            };
+        }
+        return {
+            status: result.status,
+            body: await result.blob(),
+            headers: result.headers,
+        };
+    };
+};

package/dist/lib/swarm-client/fetch-timeout.client.d.ts

@@ -0,0 +1 @@
+export declare const fetchWithTimeoutClient: (fetchClient: typeof fetch, timeout?: number) => (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

package/dist/lib/swarm-client/fetch-timeout.client.js

@@ -0,0 +1,32 @@
+export const fetchWithTimeoutClient = (fetchClient, timeout) => async (input, init) => {
+    if (!timeout || timeout <= 0) {
+        return fetchClient(input, init);
+    }
+    const controller = new AbortController();
+    const cleanups = [];
+    if (init?.signal) {
+        const onAbort = () => controller.abort(init.signal?.reason);
+        if (init.signal.aborted) {
+            controller.abort(init.signal.reason);
+        }
+        else {
+            init.signal.addEventListener('abort', onAbort, { once: true });
+            cleanups.push(() => init.signal?.removeEventListener('abort', onAbort));
+        }
+    }
+    const abortSignal = AbortSignal.timeout(timeout);
+    if (abortSignal.aborted) {
+        controller.abort(abortSignal.reason);
+    }
+    else {
+        const onTimeoutAbort = () => controller.abort(abortSignal.reason);
+        abortSignal.addEventListener('abort', onTimeoutAbort, { once: true });
+        cleanups.push(() => abortSignal.removeEventListener('abort', onTimeoutAbort));
+    }
+    const promise = fetchClient(input, { ...init, signal: controller.signal });
+    return promise.finally(() => {
+        for (const cleanup of cleanups) {
+            cleanup();
+        }
+    });
+};

package/dist/lib/swarm-client/index.d.ts

@@ -0,0 +1,6 @@
+import { authorizationMiddleware, defaultMiddlewares, loggerMiddleware, requestIdMiddleware } from './middlewares/index.js';
+import type { SwarmClient, SwarmClientOptions } from './types.js';
+export declare const createSwarmClient: (options?: SwarmClientOptions) => SwarmClient;
+export type { SwarmClientOptions, SwarmClient, SwarmMiddleware, SwarmMiddlewareContext, } from './types.js';
+export { authorizationMiddleware, defaultMiddlewares, loggerMiddleware, requestIdMiddleware };
+export * from '@super-protocol/swarm-contracts';

package/dist/lib/swarm-client/index.js

@@ -0,0 +1,31 @@
+import { apiContract } from '@super-protocol/swarm-contracts';
+import { initClient } from '@ts-rest/core';
+import { createSwarmFetchApi } from './fetch-api.js';
+import { authorizationMiddleware, defaultMiddlewares, loggerMiddleware, requestIdMiddleware, } from './middlewares/index.js';
+const applyMiddlewares = (api, middlewares, context) => middlewares.reduceRight((next, middleware) => middleware(next, context), api);
+export const createSwarmClient = (options = {}) => {
+    const { accessToken = process.env.SP_ACCESS_TOKEN, baseUrl: baseUrlFromOptions = process.env.SP_SWARM_URL, middlewares = defaultMiddlewares, timeout, fetchClient, baseHeaders, jsonQuery, validateResponse, credentials, throwOnUnknownStatus, logger, api, } = options;
+    const baseUrl = baseUrlFromOptions?.trim();
+    if (!baseUrl || baseUrl === 'undefined' || baseUrl === 'null') {
+        throw new Error('Swarm client baseUrl is required. Set SP_SWARM_URL or pass baseUrl.');
+    }
+    const mergedBaseHeaders = accessToken || baseHeaders
+        ? {
+            ...(accessToken ? { authorization: `Bearer ${accessToken}` } : {}),
+            ...baseHeaders,
+        }
+        : undefined;
+    const baseApi = api ?? createSwarmFetchApi({ fetchClient, timeout });
+    const apiWithMiddleware = applyMiddlewares(baseApi, middlewares, { accessToken, logger });
+    return initClient(apiContract, {
+        baseUrl,
+        api: apiWithMiddleware,
+        baseHeaders: mergedBaseHeaders,
+        jsonQuery,
+        validateResponse,
+        credentials,
+        throwOnUnknownStatus,
+    });
+};
+export { authorizationMiddleware, defaultMiddlewares, loggerMiddleware, requestIdMiddleware };
+export * from '@super-protocol/swarm-contracts';

package/dist/lib/swarm-client/middlewares/authorization.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { SwarmMiddleware } from '../types.js';
+export declare const authorizationMiddleware: SwarmMiddleware;

package/dist/lib/swarm-client/middlewares/authorization.middleware.js

@@ -0,0 +1,12 @@
+export const authorizationMiddleware = (next, { accessToken }) => async (args) => {
+    if (!accessToken || args.headers.authorization) {
+        return next(args);
+    }
+    return next({
+        ...args,
+        headers: {
+            ...args.headers,
+            authorization: `Bearer ${accessToken}`,
+        },
+    });
+};

package/dist/lib/swarm-client/middlewares/index.d.ts

@@ -0,0 +1,6 @@
+import { authorizationMiddleware } from './authorization.middleware.js';
+import { loggerMiddleware } from './logger.middleware.js';
+import { requestIdMiddleware } from './request-id.middleware.js';
+export type { SwarmMiddleware, SwarmMiddlewareContext } from '../types.js';
+export { authorizationMiddleware, loggerMiddleware, requestIdMiddleware };
+export declare const defaultMiddlewares: import("../types.js").SwarmMiddleware[];

package/dist/lib/swarm-client/middlewares/index.js

@@ -0,0 +1,5 @@
+import { authorizationMiddleware } from './authorization.middleware.js';
+import { loggerMiddleware } from './logger.middleware.js';
+import { requestIdMiddleware } from './request-id.middleware.js';
+export { authorizationMiddleware, loggerMiddleware, requestIdMiddleware };
+export const defaultMiddlewares = [requestIdMiddleware, loggerMiddleware, authorizationMiddleware];

package/dist/lib/swarm-client/middlewares/logger.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { SwarmMiddleware } from '../types.js';
+export declare const loggerMiddleware: SwarmMiddleware;

package/dist/lib/swarm-client/middlewares/logger.middleware.js

@@ -0,0 +1,30 @@
+export const loggerMiddleware = (next, { logger }) => async (args) => {
+    if (!logger) {
+        return next(args);
+    }
+    const requestId = args.headers['request-id'];
+    logger.trace({
+        method: args.method,
+        url: args.path,
+        requestId,
+    }, 'Swarm request');
+    try {
+        const response = await next(args);
+        logger.trace({
+            method: args.method,
+            url: args.path,
+            requestId,
+            status: response.status,
+        }, 'Swarm response');
+        return response;
+    }
+    catch (error) {
+        logger.error({
+            err: error,
+            method: args.method,
+            url: args.path,
+            requestId,
+        }, 'Swarm request failed');
+        throw error;
+    }
+};

package/dist/lib/swarm-client/middlewares/request-id.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { SwarmMiddleware } from '../types.js';
+export declare const requestIdMiddleware: SwarmMiddleware;

package/dist/lib/swarm-client/middlewares/request-id.middleware.js

@@ -0,0 +1,13 @@
+import { randomUUID } from 'node:crypto';
+export const requestIdMiddleware = (next) => async (args) => {
+    if (args.headers['request-id']) {
+        return next(args);
+    }
+    return next({
+        ...args,
+        headers: {
+            ...args.headers,
+            'request-id': randomUUID(),
+        },
+    });
+};

package/dist/lib/swarm-client/types.d.ts

@@ -0,0 +1,23 @@
+import type { ApiContract } from '@super-protocol/swarm-contracts';
+import type { ApiFetcher, ClientArgs, FetchOptions, InitClientArgs, InitClientReturn } from '@ts-rest/core';
+import type pino from 'pino';
+export type SwarmClient = InitClientReturn<ApiContract, InitClientArgs>;
+export type SwarmMiddlewareContext = {
+    accessToken?: string;
+    logger?: pino.BaseLogger;
+};
+export type SwarmMiddleware = (next: ApiFetcher, context: SwarmMiddlewareContext) => ApiFetcher;
+export interface SwarmClientOptions {
+    baseUrl?: string;
+    accessToken?: string;
+    logger?: pino.BaseLogger;
+    middlewares?: SwarmMiddleware[];
+    timeout?: number;
+    fetchClient?: typeof fetch;
+    baseHeaders?: ClientArgs['baseHeaders'];
+    jsonQuery?: boolean;
+    validateResponse?: boolean;
+    credentials?: FetchOptions['credentials'];
+    throwOnUnknownStatus?: boolean;
+    api?: ApiFetcher;
+}

package/dist/lib/swarm-client/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -16,4 +16,5 @@ export declare class AccountManager implements IAccountManager {
     init(): Promise<void>;
     private loadAccount;
     private save;
+    private setAccountFromPrivateKey;
 }

package/dist/managers/account-manager.js

@@ -12,26 +12,10 @@ export class AccountManager {
         this.logger = logger;
     }
     async create() {
-        this.privateKey = generatePrivateKey();
-        const account = privateKeyToAccount(this.privateKey);
-        this.account = {
-            address: account.address,
-            privateKey: this.privateKey,
-        };
-        await this.save();
-        this.logger.debug('Created new account');
-        return this.account;
+        return this.setAccountFromPrivateKey(generatePrivateKey(), 'Created new account');
     }
     async createFromKey(privateKey) {
-        this.privateKey = privateKey;
-        const account = privateKeyToAccount(this.privateKey);
-        this.account = {
-            address: account.address,
-            privateKey: this.privateKey,
-        };
-        await this.save();
-        this.logger.debug('Created new account from key');
-        return this.account;
+        return this.setAccountFromPrivateKey(privateKey, 'Created new account from key');
     }
     async createSign(nonce) {
         if (!this.privateKey) {
@@ -76,4 +60,15 @@ export class AccountManager {
     async save() {
         await this.configManager.set('account', this.account);
     }
+    async setAccountFromPrivateKey(privateKey, logMessage) {
+        this.privateKey = privateKey;
+        const account = privateKeyToAccount(privateKey);
+        this.account = {
+            address: account.address,
+            privateKey,
+        };
+        await this.save();
+        this.logger.debug(logMessage);
+        return this.account;
+    }
 }

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

@@ -1,16 +1,8 @@
-import { confirm, select } from '@clack/prompts';
-import { ux } from '@oclif/core';
 import type pino from 'pino';
 import { type Account, type CliConfig } from '../config/config.schema.js';
 import type { IManager } from '../interfaces/manager.interface.js';
-type ConfirmPrompt = typeof confirm;
-type SelectPrompt = typeof select;
-type UxLike = Pick<typeof ux, 'error' | 'stdout'>;
 interface ConfigFileManagerOptions {
-    confirmPrompt?: ConfirmPrompt;
     runtimeConfigFile?: string;
-    selectPrompt?: SelectPrompt;
-    ux?: UxLike;
 }
 export declare class ConfigFileManager implements IManager {
     private readonly logger;
@@ -20,30 +12,45 @@ export declare class ConfigFileManager implements IManager {
     private readonly configFilePath;
     private configs;
     private readonly configsDir;
-    private readonly confirmPrompt;
     private runtimeConfigFile?;
-    private readonly selectPrompt;
-    private readonly ux;
     constructor(configDir: string, logger: pino.BaseLogger, options?: ConfigFileManagerOptions);
-    createConfig(configFileName: string, name: string, url?: string, account?: Account): Promise<void>;
+    createConfig(configFileName: string, name?: string, url?: string, account?: Account, authUrl?: string): Promise<string>;
+    updateConfigName(configFileName: string, name: string): Promise<{
+        updated: boolean;
+        fileName: string;
+    }>;
+    updateConfigAuthUrl(configFileName: string, authUrl: string): Promise<boolean>;
     deleteConfig(configName: string): Promise<void>;
-    deleteConfigByName(name?: string, force?: boolean): Promise<void>;
-    getConfigData(configName: string): CliConfig | undefined;
+    deleteConfigByName(name?: string): Promise<void>;
+    getConfigData(configName: string): Promise<CliConfig | undefined>;
     getConfigDir(): string;
-    getConfigs(): string[];
-    getConfigsWithNames(): Array<{
+    configExists(configName: string): Promise<boolean>;
+    private listConfigFiles;
+    private getConfigBaseName;
+    getConfigWithName(name: string): Promise<{
         file: string;
         name: string;
     }>;
+    getConfigsWithNames(): Promise<Array<{
+        file: string;
+        name: string;
+    }>>;
     getCurrentConfigFile(): string | undefined;
     getCurrentConfigPath(): Promise<string>;
     importConfig(sourcePath: string, targetName?: string): Promise<string>;
     init(): Promise<void>;
-    private removeConfig;
     setCurrentConfig(configName: string): Promise<void>;
     setRuntimeConfigFile(runtimeConfigFile?: string): void;
     private ensureDirectories;
+    private normalizeConfigFiles;
     private load;
     private save;
+    private pathExists;
+    private readJsonFileOrThrow;
+    private tryReadJsonFile;
+    private writeJsonFile;
+    private resolveConfigFileName;
+    private isNotFoundError;
+    private isAlreadyExistsError;
 }
 export {};