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

package/dist/commands/base.js

@@ -0,0 +1,45 @@
+import { Command, Flags, } from '@oclif/core';
+import { AppContainer } from '../lib/container.js';
+import logger from '../logger.js';
+export class BaseCommand extends Command {
+    static baseFlags = {
+        config: Flags.string({
+            helpGroup: 'GLOBAL',
+            required: false,
+            summary: 'Specify config file.',
+        }),
+        url: Flags.string({
+            helpGroup: 'GLOBAL',
+            required: false,
+            summary: 'Specify provider base URL.',
+        }),
+    };
+    static enableJsonFlag = true;
+    args;
+    container;
+    flags;
+    logger;
+    constructor(argv, config) {
+        super(argv, config);
+        this.logger = logger.getPino();
+    }
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            args: this.ctor.args,
+            baseFlags: {
+                ...BaseCommand.baseFlags,
+                ...super.ctor.baseFlags,
+            },
+            enableJsonFlag: this.ctor.enableJsonFlag,
+            flags: this.ctor.flags,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+        this.container = AppContainer.container.setupRuntimeConfig({
+            configFile: flags.config,
+            url: flags.url,
+        });
+    }
+}

package/dist/commands/config/add.d.ts

@@ -0,0 +1,13 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigAdd extends BaseConfigCommand<typeof ConfigAdd> {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/add.js

@@ -0,0 +1,84 @@
+import { Args, Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { BaseConfigCommand } from './base.js';
+export default class ConfigAdd extends BaseConfigCommand {
+    static args = {
+        file: Args.string({
+            description: 'Configuration file path to import',
+            required: false,
+        }),
+    };
+    static description = 'Import a configuration from a file';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ./my-config.json',
+        '<%= config.bin %> <%= command.id %> ./my-config.json --name "Imported"',
+        `Configuration files must follow this schema:
+
+  {
+    "providerUrl": "https://api.dp.superprotocol.com",
+    "name": "Some name",
+    "account": {
+      "address": "0x111222333444555....",
+      "privateKey": "0x000011122233344555..."
+    }
+  }`,
+    ];
+    static flags = {
+        name: Flags.string({
+            char: 'n',
+            description: 'Custom name for the imported configuration',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Automatically switch to imported configuration',
+        }),
+    };
+    async run() {
+        const { cwdDir } = this.container;
+        let filePath = this.args.file;
+        if (!filePath) {
+            filePath = await this.inputPrompt({
+                message: 'Enter path to configuration file:',
+                validate(value) {
+                    if (!value)
+                        return 'File path is required';
+                    const testPath = path.isAbsolute(value) ? value : path.join(cwdDir, value);
+                    if (!existsSync(testPath)) {
+                        return 'File does not exist';
+                    }
+                    return true;
+                },
+            });
+        }
+        const absolutePath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(cwdDir, filePath);
+        if (!existsSync(absolutePath)) {
+            this.error('File does not exist');
+        }
+        try {
+            const importedFileName = await this.configFileManager.importConfig(absolutePath, this.flags.name);
+            const configs = this.configFileManager.getConfigsWithNames();
+            const importedConfig = configs.find(c => c.file === importedFileName);
+            const displayName = importedConfig?.name || importedFileName;
+            this.log(`Successfully imported configuration: ${displayName}`);
+            this.log(`Configuration file: ${importedFileName}`);
+            const shouldSwitch = this.flags.yes || await this.selectPrompt({
+                choices: [
+                    { name: 'Yes', value: true },
+                    { name: 'No', value: false },
+                ],
+                message: 'Switch to this configuration now?',
+            });
+            if (shouldSwitch) {
+                await this.configFileManager.setCurrentConfig(importedFileName);
+                this.log(`Switched to configuration: ${displayName}`);
+            }
+        }
+        catch (error) {
+            this.error(`Failed to import configuration: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/commands/config/base.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from '@oclif/core';
+import { input, select } from '@inquirer/prompts';
+import type { ConfigFileManager } from '../../managers/config-file-manager.js';
+import { BaseCommand } from '../base.js';
+type InputOptions = Parameters<typeof input>[0];
+type SelectOptions<T> = Parameters<typeof select<T>>[0];
+export declare abstract class BaseConfigCommand<T extends typeof Command> extends BaseCommand<T> {
+    protected configFileManager: ConfigFileManager;
+    protected displayCurrentConfig(): void;
+    init(): Promise<void>;
+    protected inputPrompt(options: InputOptions): Promise<string>;
+    protected selectPrompt<Value>(options: SelectOptions<Value>): Promise<Value>;
+}
+export {};

package/dist/commands/config/base.js

@@ -0,0 +1,62 @@
+import { input, select } from '@inquirer/prompts';
+import { BaseCommand } from '../base.js';
+export class BaseConfigCommand extends BaseCommand {
+    configFileManager;
+    displayCurrentConfig() {
+        const current = this.configFileManager.getCurrentConfigFile();
+        const configDir = this.configFileManager.getConfigDir();
+        if (current) {
+            const configs = this.configFileManager.getConfigsWithNames();
+            const currentConfig = configs.find(c => c.file === current);
+            const displayName = currentConfig?.name || current;
+            const configData = this.configFileManager.getConfigData(current);
+            this.log(`Current configuration: ${displayName}`);
+            this.log(`Configuration file: ${current}`);
+            this.log(`Configuration directory: ${configDir}`);
+            if (configData) {
+                this.log('');
+                this.log('Configuration details:');
+                if (configData.providerUrl) {
+                    this.log(`  Provider URL: ${configData.providerUrl}`);
+                }
+                else {
+                    this.log('  Provider URL: (using default)');
+                }
+                if (configData.auth?.accessKey) {
+                    this.log('  Authorization: ✓ Configured');
+                }
+                else {
+                    this.log('  Authorization: ✗ Not configured');
+                }
+                if (configData.account?.address) {
+                    this.log(`  Account: ✓ ${configData.account.address}`);
+                }
+                else {
+                    this.log('  Account: ✗ Not configured');
+                }
+                if (configData.cookies) {
+                    this.log('  Cookies: ✓ Stored');
+                }
+                else {
+                    this.log('  Cookies: ✗ None');
+                }
+            }
+        }
+        else {
+            this.log('No configuration is currently set');
+            this.log(`Configuration directory: ${configDir}`);
+            this.log('Create a new configuration with: sp config create --name "Config Name"');
+        }
+    }
+    async init() {
+        await super.init();
+        await this.container.initConfigFileManager().build();
+        this.configFileManager = this.container.configFileManager;
+    }
+    async inputPrompt(options) {
+        return input(options);
+    }
+    async selectPrompt(options) {
+        return select(options);
+    }
+}

package/dist/commands/config/create.d.ts

@@ -0,0 +1,11 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigCreate extends BaseConfigCommand<typeof ConfigCreate> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/create.js

@@ -0,0 +1,51 @@
+import { Flags } from '@oclif/core';
+import { getConfigName } from '../../utils/helper.js';
+import { BaseConfigCommand } from './base.js';
+export default class ConfigCreate extends BaseConfigCommand {
+    static description = 'Create a new configuration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --name "My Config"',
+        '<%= config.bin %> <%= command.id %> --name "Production" --url "https://api.dp.superprotocol.com"',
+    ];
+    static flags = {
+        name: Flags.string({
+            char: 'n',
+            description: 'Configuration name',
+            required: true,
+        }),
+        url: Flags.string({
+            char: 'u',
+            description: 'Provider base URL',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Switch to new config',
+        }),
+    };
+    async run() {
+        const { name, url, yes } = this.flags;
+        const fileName = getConfigName(name);
+        try {
+            await this.configFileManager.createConfig(fileName, name, url);
+            this.log(`Created new configuration: ${name}`);
+            this.log(`Configuration file: ${fileName}`);
+            if (url) {
+                this.log(`Provider URL: ${url}`);
+            }
+            const shouldSwitch = yes || await this.selectPrompt({
+                choices: [
+                    { name: 'Yes', value: true },
+                    { name: 'No', value: false },
+                ],
+                message: 'Switch to this configuration now?',
+            });
+            if (shouldSwitch) {
+                await this.configFileManager.setCurrentConfig(fileName);
+                this.log(`Switched to configuration: ${name}`);
+            }
+        }
+        catch (error) {
+            this.error(`Failed to create configuration: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/commands/config/delete.d.ts

@@ -0,0 +1,10 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigDelete extends BaseConfigCommand<typeof ConfigDelete> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/delete.js

@@ -0,0 +1,25 @@
+import { Flags } from '@oclif/core';
+import { BaseConfigCommand } from './base.js';
+export default class ConfigDelete extends BaseConfigCommand {
+    static description = 'Delete a configuration file';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --name "My Config"',
+        '<%= config.bin %> <%= command.id %> --name "My Config" --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force deletion without confirmation',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Configuration name to delete',
+        }),
+    };
+    async run() {
+        const { force, name } = this.flags;
+        await this.configFileManager.deleteConfigByName(name, force);
+    }
+}

package/dist/commands/config/index.d.ts

@@ -0,0 +1,6 @@
+import { BaseConfigCommand } from './base.js';
+export default class Config extends BaseConfigCommand<typeof Config> {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/index.js

@@ -0,0 +1,22 @@
+import { BaseConfigCommand } from './base.js';
+export default class Config extends BaseConfigCommand {
+    static description = 'Manage configuration configs';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> show - Show current configuration details',
+        '<%= config.bin %> <%= command.id %> list - List all configurations',
+        '<%= config.bin %> <%= command.id %> use - Switch to a configuration',
+        '<%= config.bin %> <%= command.id %> create --name "My Config" - Create new configuration',
+        '<%= config.bin %> <%= command.id %> add ./config.json - Import configuration from file',
+        '<%= config.bin %> <%= command.id %> delete - Delete a configuration',
+    ];
+    async run() {
+        this.displayCurrentConfig();
+        this.log('\nAvailable commands:');
+        this.log('  sp config show    - Show current configuration');
+        this.log('  sp config list    - List all configurations');
+        this.log('  sp config use     - Switch configuration');
+        this.log('  sp config create  - Create new configuration');
+        this.log('  sp config add     - Import configuration');
+        this.log('  sp config delete  - Delete configuration');
+    }
+}

package/dist/commands/config/list.d.ts

@@ -0,0 +1,6 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigList extends BaseConfigCommand<typeof ConfigList> {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/list.js

@@ -0,0 +1,39 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigList extends BaseConfigCommand {
+    static description = 'List all configurations';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const configs = this.configFileManager.getConfigsWithNames();
+        const current = this.configFileManager.getCurrentConfigFile();
+        if (configs.length === 0) {
+            this.log('No configurations found');
+            this.log('Create a new configuration with: sp config create --name "Config Name"');
+            return;
+        }
+        this.log('Available configurations:\n');
+        for (const config of configs) {
+            const marker = config.file === current ? '* ' : '  ';
+            const configData = this.configFileManager.getConfigData(config.file);
+            let statusInfo = '';
+            if (configData) {
+                const parts = [];
+                if (configData.providerUrl) {
+                    parts.push(`URL: ${configData.providerUrl}`);
+                }
+                if (configData.auth) {
+                    parts.push('Auth: ✓');
+                }
+                if (configData.account) {
+                    parts.push('Account: ✓');
+                }
+                if (parts.length > 0) {
+                    statusInfo = ` | ${parts.join(', ')}`;
+                }
+            }
+            this.log(`${marker}${config.name}${statusInfo}`);
+            this.log(`  File: ${config.file}`);
+        }
+    }
+}

package/dist/commands/config/show.d.ts

@@ -0,0 +1,6 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigShow extends BaseConfigCommand<typeof ConfigShow> {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/show.js

@@ -0,0 +1,10 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigShow extends BaseConfigCommand {
+    static description = 'Show current configuration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        this.displayCurrentConfig();
+    }
+}

package/dist/commands/config/use.d.ts

@@ -0,0 +1,6 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigUse extends BaseConfigCommand<typeof ConfigUse> {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/use.js

@@ -0,0 +1,25 @@
+import { BaseConfigCommand } from './base.js';
+export default class ConfigUse extends BaseConfigCommand {
+    static description = 'Switch to a different configuration file';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const configs = this.configFileManager.getConfigsWithNames();
+        if (configs.length === 0) {
+            this.log('No configurations found');
+            this.log('Create a new configuration with: sp config create --name "Config Name"');
+            return;
+        }
+        const selected = await this.selectPrompt({
+            choices: configs.map(config => ({
+                name: config.name ?? config.file,
+                value: config.file,
+            })),
+            message: 'Select a configuration:',
+        });
+        await this.configFileManager.setCurrentConfig(selected);
+        const selectedConfig = configs.find(c => c.file === selected);
+        this.log(`Switched to configuration: ${selectedConfig?.name || selected}`);
+    }
+}

package/dist/config/config-file.schema.d.ts

@@ -0,0 +1,6 @@
+import { Static } from '@sinclair/typebox';
+export declare const configFileManagerSchema: import("@sinclair/typebox").TObject<{
+    configs: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    currentConfig: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type ConfigFileManagerData = Static<typeof configFileManagerSchema>;

package/dist/config/config-file.schema.js

@@ -0,0 +1,5 @@
+import { Type } from '@sinclair/typebox';
+export const configFileManagerSchema = Type.Object({
+    configs: Type.Array(Type.String()),
+    currentConfig: Type.Optional(Type.String()),
+});

package/dist/config/config.schema.d.ts

@@ -15,6 +15,8 @@ export declare const cliConfigSchema: import("@sinclair/typebox").TObject<{
         accessKey: import("@sinclair/typebox").TString;
     }>>;
     cookies: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    providerUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export type CliConfig = Static<typeof cliConfigSchema>;
 export type Account = Static<typeof accountSchema>;

package/dist/config/config.schema.js

@@ -1,4 +1,13 @@
-import { Type } from '@sinclair/typebox';
+import { FormatRegistry, Type } from '@sinclair/typebox';
+FormatRegistry.Set('url', (value) => {
+    try {
+        const u = new URL(value);
+        return u.protocol === 'http:' || u.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+});
 export const accountSchema = Type.Object({
     address: Type.String({ pattern: '^0x[a-fA-F0-9]{40}$' }),
     privateKey: Type.String({ pattern: '^0x[a-fA-F0-9]{64}$' }),
@@ -10,4 +19,6 @@ export const cliConfigSchema = Type.Object({
     account: Type.Optional(accountSchema),
     auth: Type.Optional(authSchema),
     cookies: Type.Optional(Type.Unknown()),
+    name: Type.Optional(Type.String()),
+    providerUrl: Type.Optional(Type.String({ format: 'url' })),
 });

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FILE_ACCESS_PERMS = 384;
+export declare const DIR_ACCESS_PERMS = 448;
+export declare const PROVIDER_URL = "https://api.dp.superprotocol.com";

package/dist/constants.js

@@ -0,0 +1,5 @@
+//  File permissions.           '-rw-------'
+export const FILE_ACCESS_PERMS = 0o600;
+//  Directory permissions.     'drwx------'
+export const DIR_ACCESS_PERMS = 0o700;
+export const PROVIDER_URL = 'https://api.dp.superprotocol.com';

package/dist/hooks/init/init-container.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook<'init'>;
+export default hook;

package/dist/hooks/init/init-container.js

@@ -0,0 +1,6 @@
+import { AppContainer } from '../../lib/container.js';
+const hook = async function (opts) {
+    AppContainer
+        .initialize(process.cwd(), opts.config);
+};
+export default hook;

package/dist/index.d.ts

@@ -1 +1,2 @@
-export { run } from '@oclif/core';
+import { Interfaces, run as oclifRun } from '@oclif/core';
+export declare const run: (argv: string[], loadOptions?: Interfaces.LoadOptions | URL) => ReturnType<typeof oclifRun>;

package/dist/index.js

@@ -1 +1,23 @@
-export { run } from '@oclif/core';
+import { run as oclifRun } from '@oclif/core';
+import { fileURLToPath } from 'node:url';
+import logger from './logger.js';
+const normalizeLoadOptions = (loadOptions) => {
+    if (!loadOptions) {
+        return undefined;
+    }
+    if (loadOptions instanceof URL) {
+        return fileURLToPath(loadOptions);
+    }
+    return loadOptions;
+};
+export const run = async (argv, loadOptions) => {
+    const resolved = normalizeLoadOptions(loadOptions);
+    if (typeof resolved === 'string') {
+        return oclifRun(argv, { logger, root: resolved });
+    }
+    if (!resolved) {
+        const defaultRoot = fileURLToPath(new URL('..', import.meta.url));
+        return oclifRun(argv, { logger, root: defaultRoot });
+    }
+    return oclifRun(argv, { ...resolved, logger });
+};

package/dist/interfaces/index.d.ts

@@ -1,4 +1,3 @@
-export * from './abstract.command.js';
 export * from './account-manager.interface.js';
 export * from './config-manager.interface.js';
 export * from './manager.interface.js';

package/dist/interfaces/index.js

@@ -1,4 +1,3 @@
-export * from './abstract.command.js';
 export * from './account-manager.interface.js';
 export * from './config-manager.interface.js';
 export * from './manager.interface.js';

package/dist/interfaces/manager.interface.d.ts

@@ -1,3 +1,3 @@
 export interface IManager {
-    init(command?: string): Promise<void>;
+    init(): Promise<void>;
 }

package/dist/lib/container.d.ts

@@ -0,0 +1,40 @@
+import { Config } from '@oclif/core';
+import { ProviderClient } from '@super-protocol/provider-client';
+import { AccountManager, ConfigFileManager, ConfigManager } from '../managers/index.js';
+interface RuntimeConfig {
+    configFile?: string;
+    url?: string;
+}
+export declare class AppContainer {
+    readonly cwdDir: string;
+    private readonly oclifConfig;
+    private static appContainer?;
+    private _accountManager?;
+    private _configFileManager?;
+    private _configManager?;
+    private _providerClient?;
+    private initPromises;
+    private readonly initQueue;
+    private logger;
+    private runtimeConfigFile?;
+    private runtimeProviderUrl?;
+    private constructor();
+    static initialize(currentDir: string, config: Config): AppContainer;
+    get accountManager(): AccountManager;
+    get configFileManager(): ConfigFileManager;
+    get configManager(): ConfigManager;
+    static get container(): AppContainer;
+    get providerClient(): ProviderClient;
+    build(): Promise<void>;
+    initAccountManager(): this;
+    initConfigFileManager(): this;
+    initConfigManager(): this;
+    initProviderClient({ enableAuth, enableCookies }?: {
+        enableAuth?: boolean;
+        enableCookies?: boolean;
+    }): this;
+    setupRuntimeConfig(config: RuntimeConfig): this;
+    private queueInit;
+    private waitFor;
+}
+export {};