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

package/dist/services/account.service.js

@@ -0,0 +1,140 @@
+import path from 'node:path';
+import { Value } from 'typebox/value';
+import { privateKeyToAccount } from 'viem/accounts';
+import { cliConfigSchema } from '../config/config.schema.js';
+import { SWARM_URL } from '../constants.js';
+import { getConfigName, getConfigNameFromCredentials, readJsonFile } from '../utils/helper.js';
+export class AccountServiceError extends Error {
+}
+export class InvalidPrivateKeyError extends AccountServiceError {
+}
+export class InvalidAccountConfigError extends AccountServiceError {
+}
+export class AccountService {
+    configFileManager;
+    constructor(configFileManager) {
+        this.configFileManager = configFileManager;
+    }
+    createAccountFromKey(privateKey) {
+        try {
+            const account = privateKeyToAccount(privateKey);
+            return {
+                address: account.address,
+                privateKey: privateKey,
+            };
+        }
+        catch {
+            throw new InvalidPrivateKeyError('Invalid private key provided.');
+        }
+    }
+    async loadConfigFromPath(configPath) {
+        try {
+            const config = await readJsonFile({ path: configPath });
+            if (!Value.Check(cliConfigSchema, config)) {
+                throw new InvalidAccountConfigError("Account doesn't match required schema");
+            }
+            if (!config.account?.privateKey) {
+                throw new InvalidAccountConfigError('Account private key is required for import.');
+            }
+            return config;
+        }
+        catch (error) {
+            if (error instanceof AccountServiceError) {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new InvalidAccountConfigError(message);
+        }
+    }
+    resolveConfigFileName(configPath, config, name) {
+        if (name) {
+            return getConfigName(name);
+        }
+        const normalizedName = config.name?.trim();
+        if (normalizedName) {
+            return getConfigName(normalizedName);
+        }
+        if (config.account?.privateKey) {
+            const swarmUrl = (config.swarmUrl ?? SWARM_URL).trim();
+            return getConfigNameFromCredentials(config.account.privateKey, swarmUrl);
+        }
+        const baseName = path.basename(configPath, path.extname(configPath));
+        return getConfigName(baseName);
+    }
+    async configExists(configFile) {
+        return this.configFileManager.configExists(configFile);
+    }
+    async getConfigsWithNames() {
+        return this.configFileManager.getConfigsWithNames();
+    }
+    async getConfigData(configFile) {
+        return this.configFileManager.getConfigData(configFile);
+    }
+    async setCurrentConfig(configFile) {
+        await this.configFileManager.setCurrentConfig(configFile);
+    }
+    async importConfig(sourcePath, name) {
+        return this.configFileManager.importConfig(sourcePath, name);
+    }
+    async createConfigIfMissing(configFile, displayName, swarmUrl, account, authUrl) {
+        if (await this.configExists(configFile)) {
+            const existingConfig = await this.configFileManager.getConfigData(configFile);
+            const existingKey = existingConfig?.account?.privateKey?.trim().toLowerCase();
+            const existingUrl = (existingConfig?.swarmUrl ?? SWARM_URL).trim();
+            const newKey = account.privateKey.trim().toLowerCase();
+            if (!existingKey || existingKey !== newKey || existingUrl !== swarmUrl) {
+                throw new Error(`Account name "${displayName}" is already used by another account.`);
+            }
+            const nameUpdate = await this.configFileManager.updateConfigName(configFile, displayName);
+            const updatedAuthUrl = authUrl
+                ? await this.configFileManager.updateConfigAuthUrl(nameUpdate.fileName, authUrl)
+                : false;
+            return {
+                created: false,
+                updatedName: nameUpdate.updated,
+                updatedAuthUrl,
+                configFile: nameUpdate.fileName,
+            };
+        }
+        const createdFile = await this.configFileManager.createConfig(configFile, displayName, swarmUrl, account, authUrl);
+        return {
+            created: true,
+            updatedName: false,
+            updatedAuthUrl: Boolean(authUrl),
+            configFile: createdFile,
+        };
+    }
+    async updateConfigDisplayName(configFile, displayName) {
+        if (!displayName) {
+            return { status: 'skipped', configFile };
+        }
+        const updated = await this.configFileManager.updateConfigName(configFile, displayName);
+        return {
+            status: updated.updated ? 'updated' : 'unchanged',
+            configFile: updated.fileName,
+        };
+    }
+    async updateConfigAuthUrl(configFile, authUrl) {
+        if (!authUrl) {
+            return 'skipped';
+        }
+        const updated = await this.configFileManager.updateConfigAuthUrl(configFile, authUrl);
+        return updated ? 'updated' : 'unchanged';
+    }
+    async findConfigsByPrivateKey(privateKey, swarmUrl, matchSwarmUrl) {
+        const normalizedKey = privateKey.trim().toLowerCase();
+        const configs = await this.configFileManager.getConfigsWithNames();
+        const matches = [];
+        for (const config of configs) {
+            const configData = await this.configFileManager.getConfigData(config.file);
+            const storedKey = configData?.account?.privateKey?.toLowerCase();
+            const storedUrl = (configData?.swarmUrl ?? SWARM_URL).trim();
+            const keyMatches = storedKey === normalizedKey;
+            const urlMatches = !matchSwarmUrl || storedUrl === swarmUrl;
+            if (keyMatches && urlMatches) {
+                matches.push(config);
+            }
+        }
+        return matches;
+    }
+}

package/dist/services/asset.service.d.ts

@@ -0,0 +1,35 @@
+import type pino from 'pino';
+import type { z } from 'zod';
+import { AssetCreateSchema, type AssetSchema, AssetUpdateSchema, type DockerHubCredentialsSchema, type GitHubCredentialsSchema, type GoogleDocsCredentialsSchema, type S3CredentialsSchema, type StorjCredentialsSchema, type SwarmClient } from '../lib/swarm-client/index.js';
+export { SourceType, AssetType } from '../lib/swarm-client/index.js';
+export declare class AssetError extends Error {
+}
+export declare class AssetNotFoundError extends AssetError {
+}
+export declare class AssetValidationError extends AssetError {
+}
+export type Asset = z.infer<typeof AssetSchema>;
+export type AssetCreateInput = z.infer<typeof AssetCreateSchema>;
+export type AssetUpdateInput = z.infer<typeof AssetUpdateSchema>;
+export type StorjCredentials = z.infer<typeof StorjCredentialsSchema>;
+export type S3Credentials = z.infer<typeof S3CredentialsSchema>;
+export type DockerHubCredentials = z.infer<typeof DockerHubCredentialsSchema>;
+export type GitHubCredentials = z.infer<typeof GitHubCredentialsSchema>;
+export type GoogleDocsCredentials = z.infer<typeof GoogleDocsCredentialsSchema>;
+export type AssetCredentials = StorjCredentials | S3Credentials | DockerHubCredentials | GitHubCredentials | GoogleDocsCredentials;
+export declare class AssetService {
+    private readonly swarmClient;
+    private readonly logger;
+    constructor(swarmClient: SwarmClient, logger: pino.BaseLogger);
+    validateCreatePayload(payload: unknown): AssetCreateInput;
+    validateUpdatePayload(payload: unknown): AssetUpdateInput;
+    createAsset(payload: AssetCreateInput): Promise<Asset>;
+    deleteAsset(id: string): Promise<{
+        success: boolean;
+    }>;
+    findAssetById(id: string): Promise<Asset | undefined>;
+    findAssetByName(name: string): Promise<Asset | undefined>;
+    listAssets(): Promise<Asset[]>;
+    updateAsset(id: string, payload: AssetUpdateInput): Promise<Asset>;
+    private formatErrorMessage;
+}

package/dist/services/asset.service.js

@@ -0,0 +1,120 @@
+import { AssetCreateSchema, AssetUpdateSchema, } from '../lib/swarm-client/index.js';
+export { SourceType, AssetType } from '../lib/swarm-client/index.js';
+export class AssetError extends Error {
+}
+export class AssetNotFoundError extends AssetError {
+}
+export class AssetValidationError extends AssetError {
+}
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+export class AssetService {
+    swarmClient;
+    logger;
+    constructor(swarmClient, logger) {
+        this.swarmClient = swarmClient;
+        this.logger = logger;
+    }
+    validateCreatePayload(payload) {
+        const asset = AssetCreateSchema.safeParse(payload);
+        if (asset.success) {
+            return asset.data;
+        }
+        this.logger.error(asset.error);
+        throw new AssetValidationError('Incorrect input');
+    }
+    validateUpdatePayload(payload) {
+        const asset = AssetUpdateSchema.safeParse(payload);
+        if (asset.success) {
+            return asset.data;
+        }
+        this.logger.error(asset.error);
+        throw new AssetValidationError('Incorrect input');
+    }
+    async createAsset(payload) {
+        const sanitized = this.validateCreatePayload(payload);
+        const createResponse = await this.swarmClient.asset.create({
+            body: sanitized,
+        });
+        if (createResponse.status !== 201) {
+            throw new AssetError(this.formatErrorMessage(createResponse.body, 'Asset create failed'));
+        }
+        const body = createResponse.body;
+        this.logger.info({ assetId: body.id }, 'Asset created');
+        return body;
+    }
+    async deleteAsset(id) {
+        const response = await this.swarmClient.asset.delete({
+            params: { id },
+        });
+        if (response.status === 404) {
+            throw new AssetNotFoundError(`Asset not found: ${id}`);
+        }
+        if (response.status !== 200) {
+            throw new AssetError(this.formatErrorMessage(response.body, 'Asset delete failed'));
+        }
+        const result = response.body;
+        if (!result.success) {
+            throw new AssetError('Asset delete failed');
+        }
+        this.logger.info({ assetId: id }, 'Asset deleted');
+        return result;
+    }
+    async findAssetById(id) {
+        const response = await this.swarmClient.asset.get({
+            params: { id },
+        });
+        if (response.status === 404) {
+            return undefined;
+        }
+        if (response.status !== 200) {
+            throw new AssetError(this.formatErrorMessage(response.body, 'Asset lookup failed'));
+        }
+        return response.body;
+    }
+    async findAssetByName(name) {
+        const response = await this.swarmClient.asset.search({
+            query: { name },
+        });
+        if (response.status !== 200) {
+            throw new AssetError(this.formatErrorMessage(response.body, 'Asset lookup failed'));
+        }
+        const [assets] = response.body;
+        return assets;
+    }
+    async listAssets() {
+        const response = await this.swarmClient.asset.search();
+        if (response.status !== 200) {
+            throw new AssetError(this.formatErrorMessage(response.body, 'Asset list failed'));
+        }
+        return response.body;
+    }
+    async updateAsset(id, payload) {
+        const sanitized = this.validateUpdatePayload(payload);
+        const updateResponse = await this.swarmClient.asset.update({
+            body: sanitized,
+            params: { id },
+        });
+        if (updateResponse.status === 404) {
+            throw new AssetNotFoundError(`Asset not found: ${id}`);
+        }
+        if (updateResponse.status !== 200) {
+            throw new AssetError(this.formatErrorMessage(updateResponse.body, 'Asset update failed'));
+        }
+        const updated = updateResponse.body;
+        this.logger.info({ assetId: id }, 'Asset updated');
+        return updated;
+    }
+    formatErrorMessage(body, fallbackMessage) {
+        if (!isRecord(body)) {
+            return fallbackMessage;
+        }
+        const message = body.message;
+        if (Array.isArray(message)) {
+            return message.join(', ');
+        }
+        if (typeof message === 'string' && message.trim()) {
+            return message;
+        }
+        return fallbackMessage;
+    }
+}

package/dist/services/auth.service.d.ts

@@ -1,4 +1,3 @@
-import type { ProviderClient } from '@super-protocol/provider-client';
 import type pino from 'pino';
 import type { AccountManager } from '../managers/account-manager.js';
 import type { ConfigManager } from '../managers/config-manager.js';
@@ -7,13 +6,12 @@ export declare class AuthError extends Error {
 export declare class AuthService {
     private readonly accountManager;
     private readonly configManager;
-    private readonly providerClient;
     private readonly logger;
-    constructor(accountManager: AccountManager, configManager: ConfigManager, providerClient: ProviderClient, logger: pino.BaseLogger);
-    private hasValidRefreshCookie;
+    private authClient;
+    constructor(accountManager: AccountManager, configManager: ConfigManager, logger: pino.BaseLogger);
+    private buildSiweMessage;
+    private hasActiveSession;
     auth(options?: {
         force?: boolean;
     }): Promise<void>;
-    private getTokens;
-    private getUserNonce;
 }

package/dist/services/auth.service.js

@@ -1,159 +1,149 @@
-import { decode } from 'jsonwebtoken';
-import { CookieJar } from 'tough-cookie';
-import { PROVIDER_URL } from '../constants.js';
+import { createAuthClient, } from 'better-auth/client';
+import { siweClient } from 'better-auth/client/plugins';
+import { AUTH_PATH } from '../constants.js';
+const DEFAULT_CHAIN_ID = 1;
+const SIWE_VERSION = '1';
 export class AuthError extends Error {
 }
-function isAccessKeyExpired(accessKey) {
-    try {
-        const payload = decode(accessKey);
-        if (!payload || typeof payload.exp !== 'number') {
-            return true;
+const getErrorMessage = (error, fallback) => {
+    if (!error) {
+        return fallback;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (typeof error === 'object' && 'message' in error) {
+        const message = error.message;
+        if (typeof message === 'string' && message.length > 0) {
+            return message;
         }
-        const now = Math.floor(Date.now() / 1000);
-        return now >= payload.exp;
+    }
+    try {
+        return JSON.stringify(error);
     }
     catch {
-        return true;
+        return fallback;
     }
-}
-function isCookieExpired(cookie) {
-    if (!cookie.expires || cookie.expires === 'Infinity') {
-        return false;
+};
+const getSessionExpiresAt = (value) => {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
     }
-    const expiresAt = cookie.expires.getTime();
-    if (!Number.isFinite(expiresAt)) {
-        return true;
+    if (typeof value === 'string') {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : null;
     }
-    return Date.now() >= expiresAt;
-}
+    if (value instanceof Date) {
+        const time = value.getTime();
+        return Number.isFinite(time) ? time : null;
+    }
+    return null;
+};
 export class AuthService {
     accountManager;
     configManager;
-    providerClient;
     logger;
-    constructor(accountManager, configManager, providerClient, logger) {
+    authClient;
+    constructor(accountManager, configManager, logger) {
         this.accountManager = accountManager;
         this.configManager = configManager;
-        this.providerClient = providerClient;
         this.logger = logger;
+        this.authClient = createAuthClient({
+            baseURL: this.configManager.getAuthUrl(),
+            basePath: AUTH_PATH,
+            plugins: [siweClient()],
+        });
     }
-    async hasValidRefreshCookie(baseUrl) {
-        let stored;
-        try {
-            stored = await this.configManager.getCookies();
-        }
-        catch (error) {
-            this.logger.warn({ err: error }, 'Failed to read cookies from config');
-            return false;
-        }
-        if (!stored || typeof stored !== 'object') {
-            return false;
+    buildSiweMessage({ address, chainId, domain, issuedAt, nonce, statement, uri, version, }) {
+        const lines = [`${domain} wants you to sign in with your Ethereum account:`, address, ''];
+        if (statement) {
+            lines.push(statement, '');
         }
+        lines.push(`URI: ${uri}`, `Version: ${version}`, `Chain ID: ${chainId}`, `Nonce: ${nonce}`, `Issued At: ${issuedAt}`);
+        return lines.join('\n');
+    }
+    async hasActiveSession(accessKey) {
         try {
-            const jar = CookieJar.fromJSON(stored);
-            const cookies = await jar.getCookies(baseUrl, { expire: false });
-            return cookies.some((cookie) => cookie.key.toLowerCase().includes('refresh') && cookie.value && !isCookieExpired(cookie));
+            const { data, error } = await this.authClient.getSession({
+                fetchOptions: {
+                    headers: {
+                        authorization: `Bearer ${accessKey}`,
+                    },
+                },
+            });
+            if (error || !data || typeof data !== 'object' || !('session' in data)) {
+                return false;
+            }
+            const session = data.session;
+            if (!session) {
+                return false;
+            }
+            const expiresAt = getSessionExpiresAt(session.expiresAt);
+            if (expiresAt === null || expiresAt <= Date.now()) {
+                return false;
+            }
+            return true;
         }
         catch (error) {
-            this.logger.warn({ err: error }, 'Failed to parse cookies');
+            this.logger.debug({ err: error }, 'Failed to validate session with access token');
             return false;
         }
     }
     async auth(options = {}) {
         if (!options.force) {
-            const credentials = await this.configManager.getCredentials();
+            const credentials = this.configManager.getCredentials();
             const accessKey = credentials?.accessKey;
-            if (accessKey && !isAccessKeyExpired(accessKey)) {
-                this.logger.debug('Access key is not expired, skipping authorization');
-                return;
-            }
             if (accessKey) {
-                const providerUrl = (await this.configManager.get('providerUrl')) || PROVIDER_URL;
-                const hasRefreshCookie = await this.hasValidRefreshCookie(providerUrl);
-                if (hasRefreshCookie) {
-                    this.logger.debug('Access key expired but refresh cookie exists, skipping authorization');
+                const hasSession = await this.hasActiveSession(accessKey);
+                if (hasSession) {
+                    this.logger.debug('Access token is valid, skipping authorization');
                     return;
                 }
             }
         }
         const address = this.accountManager.getAddress();
-        const { error: nonceError, user } = await this.getUserNonce(address);
-        if (nonceError && nonceError.statusCode === 404) {
-            this.logger.debug('Nonce error call sign up');
-            const { data: nonceResponse, error: signUpError } = await this.providerClient.POST('/api/auth/sign-up', {
-                body: {
-                    address,
-                },
-            });
-            if (signUpError && signUpError.statusCode === 409) {
-                this.logger.debug({ signUpError }, 'Error signing up');
-                const { error: nonceError, user } = await this.getUserNonce(address);
-                this.logger.debug({ nonceError, user }, 'Requesting nonce again');
-                if (user?.nonce) {
-                    await this.getTokens(user.nonce);
-                }
-                else {
-                    throw new AuthError('User exists but nonce is unavailable. Please try again or contact support.');
-                }
-            }
-            else if (signUpError) {
-                this.logger.error({ signUpError }, 'Sign-up failed');
-                throw new AuthError('Sign-up failed. Please try again later.');
-            }
-            else {
-                const nonce = nonceResponse?.nonce;
-                if (!nonce) {
-                    this.logger.error({ response: nonceResponse }, 'Unexpected sign-up response');
-                    throw new AuthError('Provider did not return a nonce.');
-                }
-                await this.getTokens(nonce);
-            }
-        }
-        else if (user?.nonce) {
-            this.logger.debug({ user }, 'Requesting for existed user');
-            await this.getTokens(user.nonce);
+        const chainId = DEFAULT_CHAIN_ID;
+        const { data: nonceResponse, error: nonceError } = await this.authClient.siwe.nonce({
+            walletAddress: address,
+            chainId,
+        });
+        if (nonceError) {
+            this.logger.error({ nonceError }, 'Failed to request SIWE nonce');
+            throw new AuthError(getErrorMessage(nonceError, 'Failed to request SIWE nonce.'));
         }
-        else {
-            throw new AuthError('Unable to retrieve authentication nonce. Please try again later or contact support if the issue persists.');
+        const nonce = nonceResponse?.nonce;
+        if (!nonce) {
+            this.logger.error({ response: nonceResponse }, 'Unexpected nonce response');
+            throw new AuthError('Provider did not return a nonce.');
         }
-    }
-    async getTokens(nonce) {
-        const signature = await this.accountManager.createSign(nonce);
-        const { data: tokenResponse, error } = await this.providerClient.POST('/api/auth/token', {
-            body: {
-                address: this.accountManager.getAddress(),
-                provider: 'sp-cli',
-                signature,
-            },
+        const providerOrigin = new URL(this.configManager.getSwarmUrl());
+        const message = this.buildSiweMessage({
+            address,
+            chainId,
+            domain: providerOrigin.host,
+            issuedAt: new Date().toISOString(),
+            nonce,
+            uri: providerOrigin.origin,
+            version: SIWE_VERSION,
+        });
+        const signature = await this.accountManager.createSign(message);
+        const { data: verifyResponse, error: verifyError } = await this.authClient.siwe.verify({
+            message,
+            signature,
+            walletAddress: address,
+            chainId,
         });
-        if (error) {
-            this.logger.error({ err: error }, 'Token exchange failed');
-            throw new AuthError(error.message);
+        if (verifyError) {
+            this.logger.error({ verifyError }, 'SIWE verification failed');
+            throw new AuthError(getErrorMessage(verifyError, 'SIWE verification failed.'));
         }
-        const { accessToken } = tokenResponse || {};
-        if (!accessToken) {
-            this.logger.error({ response: tokenResponse }, 'Unexpected token response');
-            throw new AuthError('Provider returned an unexpected token response.');
+        const token = verifyResponse?.token;
+        if (!token) {
+            this.logger.error({ response: verifyResponse }, 'Unexpected SIWE verification response');
+            throw new AuthError('Provider did not return a session token.');
         }
         await this.configManager.setCredentials({
-            accessKey: accessToken,
+            accessKey: token,
         });
     }
-    async getUserNonce(address) {
-        try {
-            const { data, error } = await this.providerClient.GET('/api/users/nonce/{address}', {
-                params: {
-                    path: {
-                        address,
-                    },
-                },
-            });
-            this.logger.debug({ data, error }, 'Getting user nonce');
-            return { error, user: data };
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Error request nonce');
-            throw new AuthError('Connection failure, please try again later');
-        }
-    }
 }

package/dist/utils/helper.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import * as fs from 'node:fs/promises';
 import path from 'node:path';
-export const getConfigName = (name) => `${name.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-')}.config.json`;
+export const getConfigName = (name) => `${name.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-')}.json`;
 export const getConfigNameFromCredentials = (privateKey, url) => {
     const normalizedKey = privateKey.trim();
     const normalizedUrl = url.trim();
@@ -14,7 +14,7 @@ export const getConfigNameFromCredentials = (privateKey, url) => {
     hashBuilder.update('|');
     hashBuilder.update(normalizedUrl);
     const hash = hashBuilder.digest('hex');
-    return `${hash}.config.json`;
+    return `${hash}.json`;
 };
 export const preparePath = (rawPath) => {
     if (path.isAbsolute(rawPath))