minara 0.1.0

package/dist/api/limitorder.d.ts

@@ -0,0 +1,13 @@
+import type { CreateLimitOrderDto, UpdateLimitOrderDto, LimitOrderInfo } from '../types.js';
+/** Create a limit order */
+export declare function createLimitOrder(token: string, dto: CreateLimitOrderDto): Promise<import("../types.js").ApiResponse<LimitOrderInfo>>;
+/** List user's limit orders */
+export declare function listLimitOrders(token: string): Promise<import("../types.js").ApiResponse<LimitOrderInfo[]>>;
+/** Get limit order by ID */
+export declare function getLimitOrder(token: string, id: string): Promise<import("../types.js").ApiResponse<LimitOrderInfo>>;
+/** Update limit order */
+export declare function updateLimitOrder(token: string, id: string, dto: UpdateLimitOrderDto): Promise<import("../types.js").ApiResponse<LimitOrderInfo>>;
+/** Delete limit order */
+export declare function deleteLimitOrder(token: string, id: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Cancel limit order */
+export declare function cancelLimitOrder(token: string, id: string): Promise<import("../types.js").ApiResponse<void>>;

package/dist/api/limitorder.js

@@ -0,0 +1,25 @@
+import { get, post, patch, del } from './client.js';
+/** Create a limit order */
+export function createLimitOrder(token, dto) {
+    return post('/limit-order', { token, body: dto });
+}
+/** List user's limit orders */
+export function listLimitOrders(token) {
+    return get('/limit-order', { token });
+}
+/** Get limit order by ID */
+export function getLimitOrder(token, id) {
+    return get(`/limit-order/${encodeURIComponent(id)}`, { token });
+}
+/** Update limit order */
+export function updateLimitOrder(token, id, dto) {
+    return patch(`/limit-order/${encodeURIComponent(id)}`, { token, body: dto });
+}
+/** Delete limit order */
+export function deleteLimitOrder(token, id) {
+    return del(`/limit-order/${encodeURIComponent(id)}`, { token });
+}
+/** Cancel limit order */
+export function cancelLimitOrder(token, id) {
+    return post(`/limit-order/${encodeURIComponent(id)}/cancel`, { token });
+}

package/dist/api/perps.d.ts

@@ -0,0 +1,27 @@
+import type { PerpsDepositDto, PerpsWithdrawDto, PerpsPlaceOrdersDto, PerpsCancelOrdersDto, UpdateLeverageDto } from '../types.js';
+/** Deposit USDC to perps (min 5 USDC) */
+export declare function deposit(token: string, dto: PerpsDepositDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Withdraw USDC from perps */
+export declare function withdraw(token: string, dto: PerpsWithdrawDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Place perp orders */
+export declare function placeOrders(token: string, dto: PerpsPlaceOrdersDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Cancel perp orders */
+export declare function cancelOrders(token: string, dto: PerpsCancelOrdersDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Modify existing orders */
+export declare function modifyOrders(token: string, dto: PerpsCancelOrdersDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Update leverage */
+export declare function updateLeverage(token: string, dto: UpdateLeverageDto): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get all positions */
+export declare function getPositions(token: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get completed trades */
+export declare function getCompletedTrades(token: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get token prices */
+export declare function getTokenPrices(token: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get fund records */
+export declare function getFundRecords(token: string, page: number, limit: number): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get equity history chart */
+export declare function getEquityHistory(token: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get all decisions */
+export declare function getDecisions(token: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Claim rewards */
+export declare function claimRewards(token: string): Promise<import("../types.js").ApiResponse<unknown>>;

package/dist/api/perps.js

@@ -0,0 +1,53 @@
+import { get, post } from './client.js';
+/** Deposit USDC to perps (min 5 USDC) */
+export function deposit(token, dto) {
+    return post('/v1/tx/perps/deposit', { token, body: dto });
+}
+/** Withdraw USDC from perps */
+export function withdraw(token, dto) {
+    return post('/v1/tx/perps/withdraw', { token, body: dto });
+}
+/** Place perp orders */
+export function placeOrders(token, dto) {
+    return post('/v1/tx/perps/place-orders', { token, body: dto });
+}
+/** Cancel perp orders */
+export function cancelOrders(token, dto) {
+    return post('/v1/tx/perps/cancel-orders', { token, body: dto });
+}
+/** Modify existing orders */
+export function modifyOrders(token, dto) {
+    return post('/v1/tx/perps/modify-orders', { token, body: dto });
+}
+/** Update leverage */
+export function updateLeverage(token, dto) {
+    return post('/v1/tx/perps/update-leverage', { token, body: dto });
+}
+/** Get all positions */
+export function getPositions(token) {
+    return get('/v1/tx/perps/positions/all', { token });
+}
+/** Get completed trades */
+export function getCompletedTrades(token) {
+    return get('/v1/tx/perps/completed-trades/all', { token });
+}
+/** Get token prices */
+export function getTokenPrices(token) {
+    return get('/v1/tx/perps/token/prices', { token });
+}
+/** Get fund records */
+export function getFundRecords(token, page, limit) {
+    return get('/v1/tx/perps/fund-records', { token, query: { page, limit } });
+}
+/** Get equity history chart */
+export function getEquityHistory(token) {
+    return get('/v1/tx/perps/equity-history-chart/all', { token });
+}
+/** Get all decisions */
+export function getDecisions(token) {
+    return get('/v1/tx/perps/decisions/all', { token });
+}
+/** Claim rewards */
+export function claimRewards(token) {
+    return post('/v1/tx/perps/claim-rewards', { token });
+}

package/dist/api/tokens.d.ts

@@ -0,0 +1,20 @@
+/** Get trending tokens */
+export declare function getTrendingTokens(): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Search tokens by keyword */
+export declare function searchTokens(keyword: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get project info for a token */
+export declare function getProjectInfo(symbol: string, address: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get trending stocks */
+export declare function getTrendingStocks(): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Search stocks */
+export declare function searchStocks(keyword: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get stock info */
+export declare function getStockInfo(symbol: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Discover tokens by risk preference */
+export declare function discoverTokens(riskPreference: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get events */
+export declare function getEvents(page: string, pageSize: string, version: string, language: string): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get fear & greed index */
+export declare function getFearGreedIndex(): Promise<import("../types.js").ApiResponse<unknown>>;
+/** Get bitcoin metrics */
+export declare function getBitcoinMetrics(): Promise<import("../types.js").ApiResponse<unknown>>;

package/dist/api/tokens.js

@@ -0,0 +1,41 @@
+import { get } from './client.js';
+/** Get trending tokens */
+export function getTrendingTokens() {
+    return get('/tokens/trending-tokens');
+}
+/** Search tokens by keyword */
+export function searchTokens(keyword) {
+    return get('/tokens/search-tokens', { query: { keyword } });
+}
+/** Get project info for a token */
+export function getProjectInfo(symbol, address) {
+    return get('/tokens/project-info', { query: { symbol, address } });
+}
+/** Get trending stocks */
+export function getTrendingStocks() {
+    return get('/stocks/trending-stocks');
+}
+/** Search stocks */
+export function searchStocks(keyword) {
+    return get('/stocks/search-stocks', { query: { keyword } });
+}
+/** Get stock info */
+export function getStockInfo(symbol) {
+    return get('/stocks/get-stock-info', { query: { symbol } });
+}
+/** Discover tokens by risk preference */
+export function discoverTokens(riskPreference) {
+    return get('/discover/tokens', { query: { riskPreference } });
+}
+/** Get events */
+export function getEvents(page, pageSize, version, language) {
+    return get('/discover/events', { query: { page, pageSize, version, language } });
+}
+/** Get fear & greed index */
+export function getFearGreedIndex() {
+    return get('/discover/fear-greed-index');
+}
+/** Get bitcoin metrics */
+export function getBitcoinMetrics() {
+    return get('/discover/bitcoin-metrics');
+}

package/dist/api/tradeconfig.d.ts

@@ -0,0 +1,9 @@
+import type { UserTradeConfig } from '../types.js';
+/** Get user trade config */
+export declare function getTradeConfig(token: string): Promise<import("../types.js").ApiResponse<UserTradeConfig>>;
+/** Create or update trade config */
+export declare function upsertTradeConfig(token: string, config: UserTradeConfig): Promise<import("../types.js").ApiResponse<UserTradeConfig>>;
+/** Delete trade config */
+export declare function deleteTradeConfig(token: string): Promise<import("../types.js").ApiResponse<void>>;
+/** Get gas fees */
+export declare function getGasFees(token: string): Promise<import("../types.js").ApiResponse<unknown>>;

package/dist/api/tradeconfig.js

@@ -0,0 +1,17 @@
+import { get, post, del } from './client.js';
+/** Get user trade config */
+export function getTradeConfig(token) {
+    return get('/user-trade-config', { token });
+}
+/** Create or update trade config */
+export function upsertTradeConfig(token, config) {
+    return post('/user-trade-config', { token, body: config });
+}
+/** Delete trade config */
+export function deleteTradeConfig(token) {
+    return del('/user-trade-config', { token });
+}
+/** Get gas fees */
+export function getGasFees(token) {
+    return get('/user-trade-config/gas-fees', { token });
+}

package/dist/auth-refresh.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Session refresh module.
+ *
+ * When the API returns 401, this module provides an interactive re-login
+ * flow so the user doesn't have to manually run `minara login` again.
+ *
+ * Imported DYNAMICALLY by api/client.ts to avoid circular dependencies:
+ *   client.ts → (dynamic) auth-refresh.ts → api/auth.ts → client.ts
+ */
+/**
+ * Attempt to re-authenticate interactively.
+ *
+ * @returns The new access token on success, or `null` on failure / user decline.
+ */
+export declare function attemptReAuth(): Promise<string | null>;

package/dist/auth-refresh.js

@@ -0,0 +1,94 @@
+/**
+ * Session refresh module.
+ *
+ * When the API returns 401, this module provides an interactive re-login
+ * flow so the user doesn't have to manually run `minara login` again.
+ *
+ * Imported DYNAMICALLY by api/client.ts to avoid circular dependencies:
+ *   client.ts → (dynamic) auth-refresh.ts → api/auth.ts → client.ts
+ */
+import { confirm, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { loadCredentials, saveCredentials } from './config.js';
+import { sendEmailCode, verifyEmailCode } from './api/auth.js';
+/**
+ * Attempt to re-authenticate interactively.
+ *
+ * @returns The new access token on success, or `null` on failure / user decline.
+ */
+export async function attemptReAuth() {
+    try {
+        console.log('');
+        console.log(chalk.yellow('⚠'), chalk.yellow('Your session has expired or is invalid.'));
+        // ── Ask user whether to re-login ──────────────────────────────────
+        const wantReLogin = await confirm({
+            message: 'Would you like to re-login now?',
+            default: true,
+        });
+        if (!wantReLogin) {
+            console.log(chalk.dim('Run `minara login` to manually refresh your session.'));
+            return null;
+        }
+        // ── Determine email ─────────────────────────────────────────────────
+        const creds = loadCredentials();
+        let email = creds?.email;
+        if (!email) {
+            email = await input({
+                message: 'Email address:',
+                validate: (v) => (v.includes('@') ? true : 'Enter a valid email'),
+            });
+        }
+        else {
+            console.log(chalk.dim(`Sending verification code to ${email}…`));
+        }
+        // ── Send code ───────────────────────────────────────────────────────
+        const codeRes = await sendEmailCode({ email, platform: 'cli' });
+        if (!codeRes.success) {
+            console.error(chalk.red('✖'), `Failed to send code: ${codeRes.error?.message ?? 'Unknown error'}`);
+            return null;
+        }
+        console.log(chalk.green('✔'), `Verification code sent to ${chalk.cyan(email)}`);
+        // ── Get code from user ──────────────────────────────────────────────
+        const code = await input({
+            message: 'Enter verification code:',
+            validate: (v) => (v.length > 0 ? true : 'Code is required'),
+        });
+        // ── Verify ──────────────────────────────────────────────────────────
+        const verifyRes = await verifyEmailCode({
+            email,
+            code,
+            channel: 'cli',
+            deviceType: 'cli',
+        });
+        if (!verifyRes.success || !verifyRes.data) {
+            console.error(chalk.red('✖'), `Verification failed: ${verifyRes.error?.message ?? 'Invalid code'}`);
+            return null;
+        }
+        const user = verifyRes.data;
+        const newToken = user.access_token;
+        if (!newToken) {
+            console.error(chalk.red('✖'), 'No access token in response.');
+            return null;
+        }
+        // ── Save new credentials ────────────────────────────────────────────
+        saveCredentials({
+            accessToken: newToken,
+            userId: user.id,
+            email: user.email ?? email,
+            displayName: user.displayName,
+        });
+        console.log(chalk.green('✔'), 'Re-login successful! Retrying your request…');
+        console.log('');
+        return newToken;
+    }
+    catch (err) {
+        // Handle Ctrl+C or closed prompt
+        if (err instanceof Error && (err.message.includes('closed') || err.message.includes('aborted'))) {
+            console.log(chalk.dim('\nRe-login cancelled.'));
+        }
+        else {
+            console.error(chalk.red('✖'), `Re-login error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return null;
+    }
+}

package/dist/commands/account.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const accountCommand: Command;

package/dist/commands/account.js

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getCurrentUser } from '../api/auth.js';
+import { requireAuth } from '../config.js';
+import { error, spinner } from '../utils.js';
+export const accountCommand = new Command('account')
+    .alias('me')
+    .description('View your Minara account info')
+    .action(async () => {
+    const creds = requireAuth();
+    const spin = spinner('Fetching account info…');
+    const res = await getCurrentUser(creds.accessToken);
+    spin.stop();
+    if (!res.success || !res.data) {
+        error(res.error?.message ?? 'Failed to fetch account info');
+        process.exit(1);
+    }
+    const u = res.data;
+    console.log('');
+    console.log(chalk.bold('Account Info:'));
+    if (u.displayName)
+        console.log(`  Name        : ${chalk.cyan(u.displayName)}`);
+    if (u.email)
+        console.log(`  Email       : ${chalk.cyan(u.email)}`);
+    if (u.username)
+        console.log(`  Username    : ${u.username}`);
+    if (u.id)
+        console.log(`  User ID     : ${chalk.dim(u.id)}`);
+    if (u.invitationCode)
+        console.log(`  Invite Code : ${u.invitationCode}`);
+    if (u.wallets && Object.keys(u.wallets).length > 0) {
+        console.log(`  Wallets:`);
+        for (const [type, addr] of Object.entries(u.wallets)) {
+            console.log(`    ${chalk.dim(type)} : ${addr}`);
+        }
+    }
+    if (u.accounts && Object.keys(u.accounts).length > 0) {
+        console.log(`  Linked:`);
+        for (const provider of Object.keys(u.accounts)) {
+            console.log(`    ${chalk.green('✔')} ${provider}`);
+        }
+    }
+    console.log('');
+});

package/dist/commands/assets.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const assetsCommand: Command;

package/dist/commands/assets.js

@@ -0,0 +1,26 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getAssets } from '../api/crosschain.js';
+import { requireAuth } from '../config.js';
+import { error, spinner } from '../utils.js';
+export const assetsCommand = new Command('assets')
+    .description('View your wallet assets across chains')
+    .action(async () => {
+    const creds = requireAuth();
+    const spin = spinner('Fetching assets…');
+    const res = await getAssets(creds.accessToken);
+    spin.stop();
+    if (!res.success || !res.data) {
+        error(res.error?.message ?? 'Failed to fetch assets');
+        process.exit(1);
+    }
+    const data = res.data;
+    if (Array.isArray(data) && data.length === 0) {
+        console.log(chalk.dim('No assets found.'));
+        return;
+    }
+    console.log('');
+    console.log(chalk.bold('Your Assets:'));
+    console.log(JSON.stringify(data, null, 2));
+    console.log('');
+});

package/dist/commands/chat.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const chatCommand: Command;

package/dist/commands/chat.js

@@ -0,0 +1,184 @@
+import { Command } from 'commander';
+import { select } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { sendChatStream, listChats, getMemories } from '../api/chat.js';
+import { requireAuth } from '../config.js';
+import { error, info, spinner } from '../utils.js';
+import { createInterface } from 'node:readline';
+import { randomUUID } from 'node:crypto';
+/** Parse SSE stream and yield text chunks */
+async function* parseSSE(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return;
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            if (line.startsWith('data:')) {
+                const data = line.slice(5).trim();
+                if (data === '[DONE]')
+                    return;
+                try {
+                    const parsed = JSON.parse(data);
+                    // Extract text content from various SSE event formats
+                    const text = parsed?.choices?.[0]?.delta?.content
+                        ?? parsed?.content
+                        ?? parsed?.text
+                        ?? parsed?.data?.text
+                        ?? (typeof parsed === 'string' ? parsed : null);
+                    if (text)
+                        yield text;
+                }
+                catch {
+                    // Non-JSON data line — might be raw text
+                    if (data && data !== '[DONE]')
+                        yield data;
+                }
+            }
+        }
+    }
+}
+export const chatCommand = new Command('chat')
+    .description('Chat with Minara AI assistant')
+    .argument('[message]', 'Send a single message (non-interactive)')
+    .option('-c, --chat-id <id>', 'Continue existing chat')
+    .option('--list', 'List past chats')
+    .option('--history <chatId>', 'Show chat history')
+    .option('--thinking', 'Enable thinking/degen mode')
+    .option('--deep-research', 'Enable deep research mode')
+    .action(async (messageArg, opts) => {
+    const creds = requireAuth();
+    // ── List chats ───────────────────────────────────────────────────────
+    if (opts?.list) {
+        const spin = spinner('Fetching chats…');
+        const res = await listChats(creds.accessToken);
+        spin.stop();
+        if (!res.success || !res.data) {
+            error(res.error?.message ?? 'Failed');
+            process.exit(1);
+        }
+        const chats = res.data;
+        if (!chats || chats.length === 0) {
+            console.log(chalk.dim('No chats yet.'));
+            return;
+        }
+        for (const c of chats) {
+            console.log(`  ${chalk.bold((c.chatId ?? '').slice(0, 12))}…  ${c.name ?? '(untitled)'}  ${chalk.dim(c.updatedAt ?? '')}`);
+        }
+        return;
+    }
+    // ── Show history ─────────────────────────────────────────────────────
+    if (opts?.history) {
+        const spin = spinner('Loading history…');
+        const res = await getMemories(creds.accessToken, opts.history);
+        spin.stop();
+        if (!res.success || !res.data) {
+            error(res.error?.message ?? 'Failed');
+            process.exit(1);
+        }
+        const memories = res.data;
+        for (const m of memories) {
+            const prefix = m.role === 'user' ? chalk.blue.bold('You   ') : chalk.green.bold('Minara');
+            const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+            console.log(`${prefix}: ${content}`);
+        }
+        return;
+    }
+    // ── Chat context ─────────────────────────────────────────────────────
+    let chatId = opts?.chatId;
+    if (!chatId && !messageArg) {
+        const mode = await select({
+            message: 'Chat mode:',
+            choices: [
+                { name: 'Start a new conversation', value: 'new' },
+                { name: 'Continue existing conversation', value: 'continue' },
+            ],
+        });
+        if (mode === 'continue') {
+            const spin = spinner('Fetching chats…');
+            const res = await listChats(creds.accessToken);
+            spin.stop();
+            const chats = res.data;
+            if (chats && chats.length > 0) {
+                chatId = await select({
+                    message: 'Select chat:',
+                    choices: chats.map((c) => ({
+                        name: `${(c.chatId ?? '').slice(0, 12)}…  ${c.name ?? '(untitled)'}`,
+                        value: c.chatId,
+                    })),
+                });
+            }
+            else {
+                info('No existing chats. Starting new.');
+            }
+        }
+    }
+    if (!chatId)
+        chatId = randomUUID();
+    // ── Send single message ──────────────────────────────────────────────
+    async function sendAndPrint(msg) {
+        process.stdout.write(`${chalk.green.bold('Minara')}: `);
+        const response = await sendChatStream(creds.accessToken, {
+            chatId,
+            message: { role: 'user', content: msg },
+            thinking: opts?.thinking,
+            deepresearch: opts?.deepResearch,
+            chartOptions: { chartsCountRecommendedLimit: 0 },
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            console.log('');
+            error(`API error ${response.status}: ${body}`);
+            return;
+        }
+        for await (const chunk of parseSSE(response)) {
+            process.stdout.write(chunk);
+        }
+        console.log('\n');
+    }
+    if (messageArg) {
+        await sendAndPrint(messageArg);
+        return;
+    }
+    // ── REPL ─────────────────────────────────────────────────────────────
+    console.log('');
+    console.log(chalk.bold('Minara AI Chat'));
+    console.log(chalk.dim('Type your message. "exit" to quit, "/new" for new chat, "/help" for commands.'));
+    console.log('');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const prompt = () => new Promise((resolve) => {
+        rl.question(chalk.blue('You: '), resolve);
+    });
+    rl.on('close', () => { console.log(chalk.dim('\nGoodbye!')); process.exit(0); });
+    while (true) {
+        const userMsg = (await prompt()).trim();
+        if (!userMsg)
+            continue;
+        if (userMsg.toLowerCase() === 'exit' || userMsg.toLowerCase() === 'quit') {
+            console.log(chalk.dim('Goodbye!'));
+            rl.close();
+            break;
+        }
+        if (userMsg === '/new') {
+            chatId = randomUUID();
+            info('New conversation started.');
+            continue;
+        }
+        if (userMsg === '/id') {
+            console.log(chalk.dim(`Chat ID: ${chatId}`));
+            continue;
+        }
+        if (userMsg === '/help') {
+            console.log(chalk.dim('  /new  — New conversation\n  /id   — Show chat ID\n  exit  — Quit'));
+            continue;
+        }
+        await sendAndPrint(userMsg);
+    }
+});

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const configCommand: Command;

package/dist/commands/config.js

@@ -0,0 +1,48 @@
+import { Command } from 'commander';
+import { input, select } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { loadConfig, saveConfig, getMinaraDir } from '../config.js';
+import { success, info } from '../utils.js';
+export const configCommand = new Command('config')
+    .description('View or update CLI configuration')
+    .action(async () => {
+    const action = await select({
+        message: 'Configuration:',
+        choices: [
+            { name: 'Show current config', value: 'show' },
+            { name: 'Set base URL', value: 'baseUrl' },
+            { name: 'Show config directory path', value: 'path' },
+        ],
+    });
+    const config = loadConfig();
+    switch (action) {
+        case 'show':
+            console.log('');
+            console.log(chalk.bold('Current Configuration:'));
+            console.log(`  Base URL    : ${chalk.cyan(config.baseUrl)}`);
+            console.log(`  Config Dir  : ${chalk.dim(getMinaraDir())}`);
+            console.log('');
+            break;
+        case 'baseUrl': {
+            const url = await input({
+                message: 'Base URL:',
+                default: config.baseUrl,
+                validate: (v) => {
+                    try {
+                        new URL(v);
+                        return true;
+                    }
+                    catch {
+                        return 'Please enter a valid URL';
+                    }
+                },
+            });
+            saveConfig({ baseUrl: url });
+            success(`Base URL set to ${url}`);
+            break;
+        }
+        case 'path':
+            info(`Config directory: ${getMinaraDir()}`);
+            break;
+    }
+});

package/dist/commands/copy-trade.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const copyTradeCommand: Command;