@trading-boy/cli 1.12.0 → 2.0.1

package/dist/commands/strategy-cmd.js

@@ -1,335 +0,0 @@
-import { Option } from 'commander';
-import chalk from 'chalk';
-import { createLogger, generateRegimeBehavior } from '@trading-boy/core';
-import { apiRequest } from '../api-client.js';
-import { padRight, handleApiError, ensureRemote } from '../utils.js';
-// ─── Logger ───
-const logger = createLogger('cli-strategy');
-// ─── Helpers ───
-function formatShortDate(isoString) {
-    try {
-        return new Date(isoString).toISOString().slice(0, 16).replace('T', ' ');
-    }
-    catch {
-        return isoString;
-    }
-}
-// ─── Formatters ───
-export function formatStrategyDetail(s) {
-    const lines = [];
-    lines.push('');
-    lines.push(chalk.bold.cyan(`  Strategy — ${s.name}`));
-    lines.push(chalk.gray('  ' + '─'.repeat(56)));
-    lines.push('');
-    lines.push(`  ${chalk.gray('ID:')}               ${chalk.white(s.id)}`);
-    lines.push(`  ${chalk.gray('Version:')}          ${chalk.white(String(s.version))}`);
-    lines.push(`  ${chalk.gray('Agent ID:')}         ${chalk.white(s.agentId)}`);
-    lines.push(`  ${chalk.gray('Trader ID:')}        ${chalk.white(s.traderId)}`);
-    lines.push(`  ${chalk.gray('Tenant ID:')}        ${chalk.dim(s.tenantId)}`);
-    lines.push(`  ${chalk.gray('Active:')}           ${s.active ? chalk.green('YES') : chalk.red('NO')}`);
-    lines.push('');
-    lines.push(`  ${chalk.gray('Tokens:')}           ${chalk.white(s.tokens.join(', ') || chalk.dim('none'))}`);
-    lines.push(`  ${chalk.gray('Setup Types:')}      ${chalk.white(s.setupTypes.join(', ') || chalk.dim('none'))}`);
-    if (s.narrativePreferences.length > 0) {
-        lines.push(`  ${chalk.gray('Narratives:')}       ${chalk.white(s.narrativePreferences.join(', '))}`);
-    }
-    if (Object.keys(s.signalWeights).length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('  Signal Weights'));
-        for (const [signal, weight] of Object.entries(s.signalWeights)) {
-            lines.push(`    ${chalk.gray(signal + ':')} ${chalk.white(weight.toFixed(3))}`);
-        }
-    }
-    if (Object.keys(s.riskLimits).length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('  Risk Limits'));
-        for (const [key, val] of Object.entries(s.riskLimits)) {
-            lines.push(`    ${chalk.gray(key + ':')} ${chalk.white(JSON.stringify(val))}`);
-        }
-    }
-    if (Object.keys(s.regimeBehavior).length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('  Regime Behavior'));
-        for (const [regime, behavior] of Object.entries(s.regimeBehavior)) {
-            lines.push(`    ${chalk.gray(regime + ':')} ${chalk.white(JSON.stringify(behavior))}`);
-        }
-    }
-    lines.push('');
-    lines.push(`  ${chalk.gray('Created:')}          ${chalk.dim(formatShortDate(s.createdAt))}`);
-    lines.push(`  ${chalk.gray('Updated:')}          ${chalk.dim(formatShortDate(s.updatedAt))}`);
-    lines.push('');
-    return lines.join('\n');
-}
-export function formatStrategyList(response) {
-    const lines = [];
-    lines.push('');
-    lines.push(chalk.bold.cyan('  Agent Strategies'));
-    lines.push(chalk.gray('  ' + '─'.repeat(96)));
-    lines.push('');
-    if (response.strategies.length === 0) {
-        lines.push(`  ${chalk.dim('No strategies found.')}`);
-        lines.push('');
-        return lines.join('\n');
-    }
-    // Header
-    lines.push('  ' +
-        padRight('Name', 24) +
-        padRight('ID', 30) +
-        padRight('Tokens', 20) +
-        padRight('v', 4) +
-        padRight('Active', 8) +
-        'Updated');
-    lines.push('  ' + '─'.repeat(96));
-    for (const s of response.strategies) {
-        const activeStr = s.active ? chalk.green('YES') : chalk.red('NO');
-        const tokensStr = s.tokens.slice(0, 3).join(',') + (s.tokens.length > 3 ? '…' : '');
-        lines.push('  ' +
-            padRight(s.name, 24) +
-            padRight(chalk.dim(s.id), 30) +
-            padRight(tokensStr || chalk.dim('-'), 20) +
-            padRight(String(s.version), 4) +
-            padRight(activeStr, 8) +
-            chalk.dim(formatShortDate(s.updatedAt)));
-    }
-    lines.push('');
-    lines.push(`  ${chalk.gray(`Showing ${response.strategies.length} of ${response.total} (offset: ${response.offset})`)}`);
-    lines.push('');
-    return lines.join('\n');
-}
-export function formatHistoryList(response) {
-    const lines = [];
-    lines.push('');
-    lines.push(chalk.bold.cyan(`  Strategy History — ${response.strategyId}`));
-    lines.push(chalk.gray('  ' + '─'.repeat(80)));
-    lines.push('');
-    if (response.history.length === 0) {
-        lines.push(`  ${chalk.dim('No history entries found.')}`);
-        lines.push('');
-        return lines.join('\n');
-    }
-    lines.push('  ' +
-        padRight('v', 4) +
-        padRight('Name', 28) +
-        padRight('Tokens', 24) +
-        padRight('Setups', 20) +
-        'Changed At');
-    lines.push('  ' + '─'.repeat(80));
-    for (const entry of response.history) {
-        const tokensStr = entry.tokens.slice(0, 3).join(',') + (entry.tokens.length > 3 ? '…' : '');
-        const setupsStr = entry.setupTypes.slice(0, 2).join(',') + (entry.setupTypes.length > 2 ? '…' : '');
-        lines.push('  ' +
-            padRight(String(entry.version), 4) +
-            padRight(entry.name, 28) +
-            padRight(tokensStr || chalk.dim('-'), 24) +
-            padRight(setupsStr || chalk.dim('-'), 20) +
-            chalk.dim(formatShortDate(entry.changedAt)));
-    }
-    lines.push('');
-    return lines.join('\n');
-}
-// ─── Command Registration ───
-export function registerStrategyCommand(program) {
-    const strategy = program
-        .command('strategy')
-        .description('Manage agent strategies (token watch-lists, setup types, signal weights)');
-    // ─── strategy create ───
-    strategy
-        .command('create')
-        .description('Create a new agent strategy')
-        .requiredOption('--name <name>', 'Strategy name')
-        .requiredOption('--trader-id <id>', 'Trader ID')
-        .requiredOption('--agent-id <id>', 'Agent ID')
-        .requiredOption('--tokens <tokens>', 'Comma-separated token symbols')
-        .option('--setups <types>', 'Comma-separated setup types')
-        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
-        .action(async (options) => {
-        if (!(await ensureRemote()))
-            return;
-        const tokens = options.tokens.split(',').map((t) => t.trim().toUpperCase()).filter(Boolean);
-        const setupTypes = options.setups
-            ? options.setups.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean)
-            : ['BREAKOUT'];
-        const body = {
-            name: options.name,
-            traderId: options.traderId,
-            agentId: options.agentId,
-            tokens,
-            setupTypes,
-            regimeBehavior: generateRegimeBehavior(setupTypes),
-            riskLimits: {
-                maxDrawdown: 0.2,
-                maxConcurrentPositions: 5,
-                maxExposurePerToken: 0.3,
-                maxCorrelatedExposure: 0.5,
-            },
-            signalWeights: { price: 0.3, volume: 0.2, momentum: 0.2, sentiment: 0.15, onchain: 0.15 },
-            narrativePreferences: [],
-        };
-        try {
-            const result = await apiRequest('/api/v1/strategies', {
-                method: 'POST',
-                body,
-            });
-            if (options.format === 'json') {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log(formatStrategyDetail(result));
-            }
-        }
-        catch (error) {
-            handleApiError(error, 'Strategy create failed', logger);
-        }
-    });
-    // ─── strategy list ───
-    strategy
-        .command('list')
-        .description('List strategies for a trader')
-        .requiredOption('--trader-id <id>', 'Trader ID')
-        .option('--agent-id <id>', 'Filter by agent ID')
-        .option('--limit <n>', 'Maximum results', '20')
-        .option('--offset <n>', 'Pagination offset', '0')
-        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
-        .action(async (options) => {
-        if (!(await ensureRemote()))
-            return;
-        const params = new URLSearchParams();
-        params.set('traderId', options.traderId);
-        if (options.agentId)
-            params.set('agentId', options.agentId);
-        params.set('limit', options.limit);
-        params.set('offset', options.offset);
-        try {
-            const result = await apiRequest(`/api/v1/strategies?${params.toString()}`);
-            if (options.format === 'json') {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log(formatStrategyList(result));
-            }
-        }
-        catch (error) {
-            handleApiError(error, 'Strategy list failed', logger);
-        }
-    });
-    // ─── strategy show <id> ───
-    strategy
-        .command('show <id>')
-        .description('Show full details for a strategy')
-        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
-        .action(async (id, options) => {
-        if (!(await ensureRemote()))
-            return;
-        try {
-            const result = await apiRequest(`/api/v1/strategies/${encodeURIComponent(id)}`);
-            if (options.format === 'json') {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log(formatStrategyDetail(result));
-            }
-        }
-        catch (error) {
-            handleApiError(error, 'Strategy show failed', logger);
-        }
-    });
-    // ─── strategy update <id> ───
-    strategy
-        .command('update <id>')
-        .description('Update a strategy')
-        .option('--name <name>', 'New strategy name')
-        .option('--tokens <tokens>', 'New comma-separated token symbols (replaces existing)')
-        .option('--setups <types>', 'New comma-separated setup types (replaces existing)')
-        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
-        .action(async (id, options) => {
-        if (!(await ensureRemote()))
-            return;
-        const body = {};
-        if (options.name) {
-            body.name = options.name;
-        }
-        if (options.tokens) {
-            body.tokens = options.tokens.split(',').map((t) => t.trim().toUpperCase()).filter(Boolean);
-        }
-        if (options.setups) {
-            body.setupTypes = options.setups.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean);
-        }
-        if (Object.keys(body).length === 0) {
-            console.error(chalk.red('Error: Provide at least one of --name, --tokens, or --setups to update.'));
-            process.exitCode = 1;
-            return;
-        }
-        try {
-            const result = await apiRequest(`/api/v1/strategies/${encodeURIComponent(id)}`, { method: 'PUT', body });
-            if (options.format === 'json') {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log(formatStrategyDetail(result));
-            }
-        }
-        catch (error) {
-            handleApiError(error, 'Strategy update failed', logger);
-        }
-    });
-    // ─── strategy history <id> ───
-    strategy
-        .command('history <id>')
-        .description('Show version history for a strategy')
-        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
-        .action(async (id, options) => {
-        if (!(await ensureRemote()))
-            return;
-        try {
-            const result = await apiRequest(`/api/v1/strategies/${encodeURIComponent(id)}/history`);
-            if (options.format === 'json') {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log(formatHistoryList(result));
-            }
-        }
-        catch (error) {
-            handleApiError(error, 'Strategy history failed', logger);
-        }
-    });
-    // ─── strategy export ───
-    strategy
-        .command('export')
-        .description('Export a strategy in json, elizaos, or freqtrade format')
-        .requiredOption('--id <id>', 'Strategy ID to export')
-        .addOption(new Option('--format <format>', 'Export format')
-        .choices(['json', 'elizaos', 'freqtrade'])
-        .default('json'))
-        .option('--output <file>', 'Write output to a file instead of stdout')
-        .action(async (options) => {
-        if (!(await ensureRemote()))
-            return;
-        try {
-            const result = await apiRequest(`/api/v1/strategies/${encodeURIComponent(options.id)}/export?format=${encodeURIComponent(options.format)}`);
-            const output = JSON.stringify(result, null, 2);
-            if (options.output) {
-                const { writeFile } = await import('node:fs/promises');
-                const { resolve } = await import('node:path');
-                const resolved = resolve(options.output);
-                // Block writes to system directories
-                const blocked = ['/etc', '/usr', '/bin', '/sbin', '/var', '/lib', '/boot', '/sys', '/proc', '/dev'];
-                if (blocked.some((dir) => resolved.startsWith(dir + '/'))) {
-                    console.error(chalk.red(`Error: --output must not write to system directories.`));
-                    console.error(chalk.dim(`  Resolved: ${resolved}`));
-                    process.exitCode = 1;
-                    return;
-                }
-                await writeFile(resolved, output + '\n', 'utf-8');
-                console.log(chalk.green(`Strategy exported to ${resolved}`));
-            }
-            else {
-                console.log(output);
-            }
-        }
-        catch (error) {
-            handleApiError(error, 'Strategy export failed', logger);
-        }
-    });
-}
-//# sourceMappingURL=strategy-cmd.js.map

package/dist/commands/subscribe.d.ts

@@ -1,78 +0,0 @@
-import { Command } from 'commander';
-export interface CheckoutResponse {
-    checkoutUrl: string;
-    provisioningToken: string;
-}
-export interface ProvisionResponse {
-    status: 'pending' | 'ready' | 'expired' | 'already_retrieved' | 'not_found';
-    apiKey?: string;
-    keyPrefix?: string;
-    email?: string;
-    plan?: string;
-}
-export interface PollResult {
-    success: boolean;
-    apiKey?: string;
-    keyPrefix?: string;
-    email?: string;
-    plan?: string;
-    error?: string;
-}
-export interface CryptoCheckoutResponse {
-    reference: string;
-    provisioningToken: string;
-    merchantWallet: string;
-    amountUsdc: number;
-    tokenSymbol: string;
-    network: string;
-    plan: string;
-    solanaPayUrl: string;
-    solanaReference: string;
-}
-export interface CryptoVerifyResponse {
-    status: 'pending' | 'confirmed' | 'not_found' | 'expired';
-}
-/**
- * Create a Stripe Checkout session via the API.
- * This is a public endpoint — no auth needed.
- */
-export declare function createCheckoutSession(email: string, plan?: string): Promise<CheckoutResponse>;
-/**
- * Poll the provisioning endpoint for the API key.
- * Returns normalized ProvisionResponse regardless of HTTP status.
- */
-export declare function pollProvisioningToken(token: string): Promise<ProvisionResponse>;
-/**
- * Create a crypto (USDC) checkout session via the API.
- * Public endpoint — no auth needed.
- */
-export declare function createCryptoCheckout(email: string, plan?: string): Promise<CryptoCheckoutResponse>;
-/**
- * Check if a USDC payment has been confirmed on Solana.
- */
-export declare function checkCryptoPayment(reference: string): Promise<CryptoVerifyResponse>;
-/**
- * Poll until USDC payment is confirmed on Solana, then poll for provisioned API key.
- */
-export declare function pollCryptoPayment(reference: string, provisioningToken: string, onTick?: (elapsed: number, phase: 'payment' | 'provisioning') => void): Promise<PollResult>;
-/**
- * Poll the provisioning endpoint until a key is ready or timeout.
- */
-export declare function pollForApiKey(token: string, onTick?: (elapsed: number) => void): Promise<PollResult>;
-/**
- * Save API credentials using the credential storage module.
- */
-export declare function saveApiKey(apiKey: string, metadata: {
-    keyPrefix?: string;
-    email?: string;
-    plan?: string;
-}): Promise<void>;
-export declare function formatSubscribeSuccess(result: PollResult): string;
-export declare function registerSubscribeCommand(program: Command): void;
-export interface RegisterResponse {
-    apiKey: string;
-    keyPrefix: string;
-    email: string;
-    plan: string;
-}
-//# sourceMappingURL=subscribe.d.ts.map