@dawnai/cli 1.0.3

package/README.md

@@ -0,0 +1,57 @@
+# @dawnai/cli
+
+Standalone user-facing CLI for Dawn.
+
+## Install
+
+```bash
+npm install -g @dawnai/cli
+```
+
+Verify:
+
+```bash
+dawn --version
+```
+
+## Usage
+
+```bash
+dawn auth login
+dawn auth status
+dawn auth logout
+
+dawn account overview
+dawn account fund
+dawn account wallet
+
+dawn strategy list
+dawn strategy create "<text>"
+dawn strategy status <id>
+dawn strategy revise <id> "<text>"
+dawn strategy rules <id> list
+dawn strategy rules <id> approve <rule-index>
+dawn strategy rules <id> approve-all
+dawn strategy code <id> status
+dawn strategy code <id> generate
+dawn strategy code <id> export [--out <path>] [--json]
+dawn strategy code <id> upload <path-to-file>
+dawn strategy launch <id> --budget <usd> [--live] [--hours N]
+
+dawn run list
+dawn run status <id>
+dawn run logs <id> [--limit N]
+dawn run stop <id>
+```
+
+## Environment Variables
+
+| Variable | Description |
+|---|---|
+| `DAWN_JWT_TOKEN` | Auth token for headless/CI/agent environments. Set this to skip `dawn auth login`. |
+| `DAWN_CLI_HOME` | Override config directory (default: `~/.dawn-cli`). |
+
+## Notes
+
+- Auth token is stored at `~/.dawn-cli/config.json`.
+- `dawn account fund` prints the wallet address and Polygon USDC deposit instructions.

package/dist/index.js

@@ -0,0 +1,1266 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+const CLI_VERSION = '1.0.3';
+const DAWN_API_BASE_URL = 'https://api.dawn.ai';
+const FUNDING_LINK_TEMPLATE = process.env.DAWN_HELIO_LINK_TEMPLATE || '';
+const CLI_HOME = process.env.DAWN_CLI_HOME || path.join(os.homedir(), '.dawn-cli');
+const CONFIG_PATH = path.join(CLI_HOME, 'config.json');
+async function ensureDir() {
+    await fs.mkdir(CLI_HOME, { recursive: true });
+}
+async function loadConfig() {
+    try {
+        const raw = await fs.readFile(CONFIG_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+async function saveConfig(config) {
+    await ensureDir();
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+async function getApiBaseUrl(config) {
+    const envBaseUrl = process.env.DAWN_API_BASE_URL;
+    const configBaseUrl = typeof config.apiBaseUrl === 'string' ? config.apiBaseUrl : undefined;
+    const explicitBaseUrl = envBaseUrl || configBaseUrl;
+    if (explicitBaseUrl && explicitBaseUrl !== DAWN_API_BASE_URL) {
+        throw new Error(`Invalid DAWN_API_BASE_URL: ${explicitBaseUrl}. This CLI only supports ${DAWN_API_BASE_URL}.`);
+    }
+    return DAWN_API_BASE_URL;
+}
+function getAuthToken(config) {
+    const configToken = typeof config.token === 'string' ? config.token : null;
+    return process.env.DAWN_JWT_TOKEN || configToken;
+}
+function formatNumeric(value, fallback = 0) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+function formatUsd(value) {
+    return `$${formatNumeric(value).toLocaleString('en-US', {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    })}`;
+}
+function formatPercent(value) {
+    return `${formatNumeric(value).toLocaleString('en-US', {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    })}%`;
+}
+function printSection(title) {
+    console.log('');
+    console.log(title);
+    console.log('-'.repeat(title.length));
+}
+function printKeyValue(label, value) {
+    console.log(`${label.padEnd(22)} ${value}`);
+}
+function shortId(id) {
+    const raw = String(id ?? '');
+    if (raw.length <= 14) {
+        return raw;
+    }
+    return `${raw.slice(0, 8)}...${raw.slice(-4)}`;
+}
+function formatTimestamp(iso) {
+    if (!iso) {
+        return 'unknown';
+    }
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime())) {
+        return iso;
+    }
+    return date.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+function printUsage() {
+    console.log(`Usage:
+  dawn auth login
+  dawn auth status
+  dawn auth logout
+
+  dawn account overview
+  dawn account fund
+  dawn account wallet
+
+  dawn strategy list
+  dawn strategy create <text>
+  dawn strategy status <id>
+  dawn strategy revise <id> <text>
+  dawn strategy rules <id> list
+  dawn strategy rules <id> approve <rule-index>
+  dawn strategy rules <id> approve-all
+  dawn strategy code <id> status
+  dawn strategy code <id> generate
+  dawn strategy code <id> export [--out <path>] [--json]
+  dawn strategy code <id> upload <path-to-file>
+  dawn strategy launch <id> --budget <usd> [--live] [--hours N]
+
+  dawn run list
+  dawn run status <id>
+  dawn run logs <id> [--limit N]
+  dawn run stop <id>
+
+  dawn --version
+
+Environment variables:
+  DAWN_JWT_TOKEN       Auth token for headless/CI environments (skip dawn auth login)
+  DAWN_CLI_HOME        Override config directory (default: ~/.dawn-cli)
+`);
+}
+function parseFlags(args) {
+    const flags = {};
+    const positional = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            if (!next || next.startsWith('--')) {
+                flags[key] = true;
+            }
+            else {
+                flags[key] = next;
+                i += 1;
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { flags, positional };
+}
+function isStringMap(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.values(value).every((v) => typeof v === 'string'));
+}
+function extractCodeMap(payload) {
+    if (isStringMap(payload)) {
+        return payload;
+    }
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const preferredKeys = ['code', 'files', 'rawCode', 'sourceFiles'];
+    const record = payload;
+    for (const key of preferredKeys) {
+        if (key in record) {
+            const extracted = extractCodeMap(record[key]);
+            if (extracted) {
+                return extracted;
+            }
+        }
+    }
+    if (Array.isArray(payload)) {
+        for (const item of payload) {
+            const extracted = extractCodeMap(item);
+            if (extracted) {
+                return extracted;
+            }
+        }
+        return null;
+    }
+    for (const value of Object.values(record)) {
+        const extracted = extractCodeMap(value);
+        if (extracted) {
+            return extracted;
+        }
+    }
+    return null;
+}
+function printConversationStatus(conversationId, conversation, latestVersion, generationStatus, strategies) {
+    const convoName = conversation.name || '(untitled)';
+    const messageStatus = conversation.status || 'unknown';
+    const agentActivity = conversation.lastHeartbeat ? 'active' : 'idle';
+    const updated = conversation.updatedAt || 'unknown';
+    console.log(`Conversation: ${conversationId} (${convoName})`);
+    console.log(`Conversation state: messages=${messageStatus}, agent=${agentActivity}`);
+    console.log(`Conversation updatedAt: ${updated}`);
+    if (!latestVersion?.id) {
+        console.log('Latest version: none');
+        console.log('Code generation: no version available');
+    }
+    else {
+        const versionId = String(latestVersion.id);
+        const generationFromVersion = latestVersion.metadata?.generation || null;
+        const effectiveGeneration = generationStatus || generationFromVersion;
+        const generationState = effectiveGeneration?.status ||
+            (latestVersion.codeCreatedAt ? 'completed' : 'pending');
+        const generationRunning = generationStatus?.isRunning || generationState === 'running';
+        const hasCode = Boolean(latestVersion.codeCreatedAt);
+        console.log(`Latest version: ${versionId}${latestVersion.elapsedTime ? ` (${latestVersion.elapsedTime})` : ''}`);
+        console.log(`Code generation: ${generationState}${generationRunning ? ' (in progress)' : ''}${hasCode ? ' | code_ready=true' : ' | code_ready=false'}`);
+        if (effectiveGeneration?.error) {
+            console.log(`Generation error: ${effectiveGeneration.error}`);
+        }
+        if (effectiveGeneration?.completedAt) {
+            console.log(`Generation completedAt: ${effectiveGeneration.completedAt}`);
+        }
+    }
+    if (!strategies.length) {
+        console.log('Execution: not launched');
+        return;
+    }
+    const runningCount = strategies.filter((s) => Boolean(s.isRunning)).length;
+    const latestRun = strategies[0];
+    const latestRunId = latestRun?.id ?? 'unknown';
+    const latestRunType = latestRun?.strategyType || 'unknown';
+    const latestRunState = latestRun?.isRunning ? 'running' : 'stopped';
+    const latestRunTerminateAt = latestRun?.terminateAt || 'unknown';
+    const latestRunPnl = latestRun?.totalPnl || '0';
+    console.log(`Execution: ${runningCount}/${strategies.length} running`);
+    console.log(`Latest run: id=${latestRunId}, type=${latestRunType}, state=${latestRunState}, terminateAt=${latestRunTerminateAt}, totalPnl=${latestRunPnl}`);
+}
+function renderStrategyRules(version) {
+    const rules = Array.isArray(version.strategy?.rules) ? version.strategy?.rules : [];
+    const approved = new Set(version.metadata?.generation?.approvedRuleIndices || []);
+    const generationStatus = version.metadata?.generation?.status || 'unknown';
+    console.log(`Version: ${version.id ?? 'unknown'}`);
+    console.log(`Generation status: ${generationStatus}`);
+    console.log(`Rules: ${rules.length}`);
+    if (!rules.length) {
+        console.log('No rules found on latest version.');
+        return;
+    }
+    for (let i = 0; i < rules.length; i += 1) {
+        const rule = rules[i];
+        const isApproved = approved.has(i);
+        const type = rule.type || 'execution';
+        const name = rule.name || '(unnamed rule)';
+        const condition = (rule.condition || '').replace(/\s+/g, ' ').trim();
+        const preview = condition.length > 140 ? `${condition.slice(0, 137)}...` : condition;
+        console.log(`[${i}] ${isApproved ? '[approved]' : '[needs-approval]'} (${type}) ${name}`);
+        if (preview) {
+            console.log(`     ${preview}`);
+        }
+    }
+}
+async function getLatestStrategyVersion(config, conversationId, withCode) {
+    const latest = (await apiFetch(config, `/conversations/${conversationId}/latest-version?withCode=${withCode ? 'true' : 'false'}`));
+    return latest || null;
+}
+async function apiFetch(config, endpoint, options = {}) {
+    const apiBaseUrl = await getApiBaseUrl(config);
+    const token = getAuthToken(config);
+    const headers = {
+        'Content-Type': 'application/json',
+        ...options.headers,
+    };
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    const response = await fetch(`${apiBaseUrl}${endpoint}`, {
+        ...options,
+        headers,
+    });
+    const text = await response.text();
+    let body = null;
+    try {
+        body = text ? JSON.parse(text) : null;
+    }
+    catch {
+        body = text || null;
+    }
+    if (!response.ok) {
+        const errorBody = body && typeof body === 'object' ? body : null;
+        const message = (typeof errorBody?.message === 'string' && errorBody.message) ||
+            (typeof errorBody?.error === 'string' && errorBody.error) ||
+            (typeof body === 'string' && body) ||
+            response.statusText ||
+            `Request failed: ${response.status}`;
+        throw new Error(`${message} (${response.status} ${response.statusText} — ${endpoint})`);
+    }
+    return body;
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
+        return;
+    }
+    if (platform === 'win32') {
+        spawn('cmd', ['/c', 'start', '', url], {
+            stdio: 'ignore',
+            detached: true,
+        }).unref();
+        return;
+    }
+    spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+}
+async function handleAuth(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`Usage:
+  dawn auth login
+  dawn auth status
+  dawn auth logout
+
+For headless/CI environments, set the DAWN_JWT_TOKEN environment variable
+instead of using interactive login.`);
+        return;
+    }
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        throw new Error('Usage: dawn auth <login|status|logout>');
+    }
+    if (subcommand === 'status') {
+        const config = await loadConfig();
+        const token = getAuthToken(config);
+        if (!token) {
+            console.log('Not authenticated.');
+            return;
+        }
+        console.log('Authenticated.');
+        return;
+    }
+    if (subcommand === 'logout') {
+        const config = await loadConfig();
+        const nextConfig = { ...config };
+        delete nextConfig.token;
+        await saveConfig(nextConfig);
+        console.log('Logged out. Local token removed.');
+        return;
+    }
+    if (subcommand !== 'login') {
+        throw new Error(`Unknown auth command: ${subcommand}`);
+    }
+    const loginArgs = rest;
+    const { flags } = parseFlags(loginArgs);
+    const config = await loadConfig();
+    await new Promise((resolve, reject) => {
+        const timeoutMs = 180000;
+        let isSettled = false;
+        let timeoutId = null;
+        const settle = (callback) => {
+            if (isSettled) {
+                return;
+            }
+            isSettled = true;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            callback();
+        };
+        const resolveOnce = () => {
+            settle(resolve);
+        };
+        const rejectOnce = (error) => {
+            settle(() => reject(error));
+        };
+        const closeServer = () => {
+            try {
+                server.close();
+            }
+            catch {
+                // no-op
+            }
+        };
+        const server = http.createServer(async (req, res) => {
+            try {
+                const reqUrl = new URL(req.url || '/', 'http://127.0.0.1');
+                if (reqUrl.pathname !== '/callback') {
+                    res.statusCode = 404;
+                    res.end('Not found');
+                    return;
+                }
+                const token = reqUrl.searchParams.get('token');
+                const error = reqUrl.searchParams.get('error');
+                if (error) {
+                    res.statusCode = 200;
+                    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                    res.end('<h3>Authentication failed. You can close this window.</h3>');
+                    closeServer();
+                    rejectOnce(new Error(`Auth failed: ${error}`));
+                    return;
+                }
+                if (!token) {
+                    res.statusCode = 200;
+                    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                    res.end('<h3>Missing token. You can close this window.</h3>');
+                    closeServer();
+                    rejectOnce(new Error('Missing token in auth callback.'));
+                    return;
+                }
+                const latestConfig = await loadConfig();
+                await saveConfig({ ...latestConfig, token });
+                res.statusCode = 200;
+                res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                res.end('<h3>Authentication complete. You can close this window.</h3>');
+                closeServer();
+                resolveOnce();
+            }
+            catch (error) {
+                closeServer();
+                rejectOnce(error);
+            }
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (!addr || typeof addr === 'string') {
+                rejectOnce(new Error('Failed to open local auth callback server.'));
+                return;
+            }
+            const redirect = `http://127.0.0.1:${addr.port}/callback`;
+            void (async () => {
+                try {
+                    const apiBaseUrl = await getApiBaseUrl(config);
+                    const authUrl = `${apiBaseUrl}/v1/auth/google/?redirect=${encodeURIComponent(redirect)}`;
+                    console.log(`Using API: ${apiBaseUrl}`);
+                    console.log('Opening browser for Dawn auth...');
+                    openBrowser(authUrl);
+                    console.log('Waiting for authentication callback...');
+                }
+                catch (error) {
+                    rejectOnce(error);
+                }
+            })();
+        });
+        timeoutId = setTimeout(() => {
+            closeServer();
+            rejectOnce(new Error('Timed out waiting for authentication callback.'));
+        }, timeoutMs);
+    });
+    console.log('Authentication successful.');
+}
+async function ensureWallet(config) {
+    let wallet = (await apiFetch(config, '/wallet/my-wallet'));
+    if (wallet && wallet.wallet === null) {
+        wallet = null;
+    }
+    if (!wallet) {
+        const created = (await apiFetch(config, '/wallet/create', { method: 'POST' }));
+        if (!created?.success || !created.wallet) {
+            throw new Error(created?.error || 'Failed to create wallet.');
+        }
+        return created.wallet;
+    }
+    return wallet;
+}
+function helioLinkForAddress(address) {
+    return FUNDING_LINK_TEMPLATE.replace('{address}', encodeURIComponent(address));
+}
+function fundingLinkForAddress(address) {
+    if (!FUNDING_LINK_TEMPLATE) {
+        return null;
+    }
+    // Legacy Helio /pay links now return 404; disable them by default.
+    const isLegacyHelioPayLink = /https?:\/\/(?:app|moonpay)\.hel\.io\/pay\?/i.test(FUNDING_LINK_TEMPLATE) &&
+        FUNDING_LINK_TEMPLATE.includes('recipientAddress=');
+    if (isLegacyHelioPayLink) {
+        return null;
+    }
+    return helioLinkForAddress(address);
+}
+async function handleFund(args) {
+    const { flags } = parseFlags(args);
+    if (flags.help || flags.h) {
+        console.log('Usage:\n  dawn fund');
+        return;
+    }
+    const config = await loadConfig();
+    if (!getAuthToken(config)) {
+        throw new Error('Not authenticated. Run: dawn auth login');
+    }
+    const wallet = await ensureWallet(config);
+    if (!wallet?.proxyAddress) {
+        throw new Error('Could not determine wallet proxy address.');
+    }
+    console.log(`Wallet: ${wallet.proxyAddress}`);
+    console.log('Deposit instructions:');
+    console.log('- Send USDC on Polygon (Polygon PoS) to the wallet above.');
+    console.log('- Avoid sending tokens on other networks unless you bridge first.');
+    const link = fundingLinkForAddress(wallet.proxyAddress);
+    if (link) {
+        console.log(`Funding link: ${link}`);
+    }
+    else {
+        console.log('Funding link: not generated (legacy Helio /pay links are deprecated).');
+    }
+}
+async function handleOverview(args) {
+    const { flags } = parseFlags(args);
+    if (flags.help || flags.h) {
+        console.log('Usage:\n  dawn overview');
+        return;
+    }
+    const config = await loadConfig();
+    if (!getAuthToken(config)) {
+        throw new Error('Not authenticated. Run: dawn auth login');
+    }
+    const wallet = await ensureWallet(config);
+    if (!wallet?.proxyAddress) {
+        throw new Error('Could not determine wallet proxy address.');
+    }
+    const [walletBalanceRaw, generatedBalancesRaw] = await Promise.all([
+        apiFetch(config, '/wallet/balance'),
+        apiFetch(config, '/wallet/generated-balances'),
+    ]);
+    const walletBalance = (walletBalanceRaw || {});
+    const generatedBalances = (generatedBalancesRaw || {});
+    const walletTypes = ['funding', 'strategy', 'paper'];
+    const vaultLists = await Promise.all(walletTypes.map(async (walletType) => {
+        try {
+            const response = (await apiFetch(config, `/v1/vaults/all/${walletType}?isArchived=false`));
+            return response.vaults || [];
+        }
+        catch {
+            return [];
+        }
+    }));
+    const vaults = vaultLists.flat();
+    const vaultPositions = await Promise.all(vaults.map(async (vault) => {
+        try {
+            const response = (await apiFetch(config, `/v1/vault-metadata/${vault.id}/positions`));
+            return { vaultId: vault.id, positions: response.positions || [] };
+        }
+        catch {
+            return { vaultId: vault.id, positions: [] };
+        }
+    }));
+    const positionsByVaultId = new Map(vaultPositions.map((item) => [item.vaultId, item.positions]));
+    const aggregateVaultCurrent = vaults.reduce((sum, vault) => sum + formatNumeric(vault.totalCurrentValue), 0);
+    const aggregateVaultCost = vaults.reduce((sum, vault) => sum + formatNumeric(vault.totalCostBasis), 0);
+    const aggregateVaultPnl = vaults.reduce((sum, vault) => sum + formatNumeric(vault.totalPnl), 0);
+    console.log('Dawn Overview');
+    console.log('=============');
+    printKeyValue('Generated', formatTimestamp(new Date().toISOString()));
+    printSection('Account Balances');
+    printKeyValue('Funding wallet', wallet.proxyAddress);
+    printKeyValue('Total balance', formatUsd(walletBalance.walletBalance || '0'));
+    printKeyValue('Available (USDC.e)', formatUsd(walletBalance.availableBalance || '0'));
+    printKeyValue('Allocated to vaults', formatUsd(walletBalance.allocatedBalance || '0'));
+    printKeyValue('Wallet USDC.e', formatUsd(walletBalance.usdcBalance || '0'));
+    printKeyValue('Wallet POL', formatNumeric(generatedBalances.pol).toFixed(4));
+    printKeyValue('Wallet USDC', formatUsd(generatedBalances.usdc || '0'));
+    printKeyValue('Wallet USDC.e', formatUsd(generatedBalances.usdce || '0'));
+    printSection('Vault Summary');
+    printKeyValue('Vault count', String(vaults.length));
+    printKeyValue('Total current value', formatUsd(aggregateVaultCurrent));
+    printKeyValue('Total cost basis', formatUsd(aggregateVaultCost));
+    printKeyValue('Total PnL', `${formatUsd(aggregateVaultPnl)} (${formatPercent(aggregateVaultCost === 0 ? 0 : (aggregateVaultPnl / aggregateVaultCost) * 100)})`);
+    if (!vaults.length) {
+        console.log('No vaults found.');
+        return;
+    }
+    printSection('Vault Portfolios');
+    for (const vault of vaults) {
+        const positions = positionsByVaultId.get(vault.id) || [];
+        console.log(`\n[${vault.walletType.toUpperCase()}] ${shortId(vault.id)} | current=${formatUsd(vault.totalCurrentValue)} | cost=${formatUsd(vault.totalCostBasis)} | pnl=${formatUsd(vault.totalPnl)} (${formatPercent(vault.totalPnlPercentage)}) | strategies=${vault.strategyCount}`);
+        if (!positions.length) {
+            console.log('  (no portfolio positions)');
+            continue;
+        }
+        const sorted = [...positions].sort((a, b) => formatNumeric(b.currentValue) - formatNumeric(a.currentValue));
+        for (const position of sorted) {
+            const title = position.marketTitle ||
+                position.groupItemTitle ||
+                `asset:${shortId(position.assetId || position.id)}`;
+            console.log(`  - ${title} | value=${formatUsd(position.currentValue || '0')} | cost=${formatUsd(position.costBasis || '0')} | pnl=${formatUsd(position.unrealizedPnl || '0')} (${formatPercent(position.unrealizedPnlPercentage || '0')}) | amount=${formatNumeric(position.amount).toFixed(4)}`);
+        }
+    }
+}
+async function handleAccount(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`Usage:
+  dawn account overview
+  dawn account fund
+  dawn account wallet`);
+        return;
+    }
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        throw new Error('Missing account command.');
+    }
+    if (subcommand === 'overview') {
+        await handleOverview(rest);
+        return;
+    }
+    if (subcommand === 'fund') {
+        await handleFund(rest);
+        return;
+    }
+    if (subcommand === 'wallet') {
+        const config = await loadConfig();
+        if (!getAuthToken(config)) {
+            throw new Error('Not authenticated. Run: dawn auth login');
+        }
+        const wallet = await ensureWallet(config);
+        if (!wallet?.proxyAddress) {
+            throw new Error('Could not determine wallet proxy address.');
+        }
+        const [walletBalanceRaw, generatedBalancesRaw] = await Promise.all([
+            apiFetch(config, '/wallet/balance'),
+            apiFetch(config, '/wallet/generated-balances'),
+        ]);
+        const walletBalance = (walletBalanceRaw || {});
+        const generatedBalances = (generatedBalancesRaw || {});
+        console.log('Wallet');
+        console.log('======');
+        printKeyValue('Address', wallet.proxyAddress);
+        printKeyValue('Total balance', formatUsd(walletBalance.walletBalance || '0'));
+        printKeyValue('Available (USDC.e)', formatUsd(walletBalance.availableBalance || '0'));
+        printKeyValue('Allocated to vaults', formatUsd(walletBalance.allocatedBalance || '0'));
+        printKeyValue('Wallet USDC.e', formatUsd(walletBalance.usdcBalance || '0'));
+        printKeyValue('Wallet POL', formatNumeric(generatedBalances.pol).toFixed(4));
+        printKeyValue('Wallet USDC', formatUsd(generatedBalances.usdc || '0'));
+        printKeyValue('Wallet USDC.e', formatUsd(generatedBalances.usdce || '0'));
+        return;
+    }
+    throw new Error(`Unknown account command: ${subcommand}`);
+}
+function renderConversationList(conversations) {
+    if (!Array.isArray(conversations) || conversations.length === 0) {
+        console.log('No strategies found.');
+        return;
+    }
+    const rows = conversations.map((c) => ({
+        id: String(c.id ?? ''),
+        name: c.name || '(untitled)',
+    }));
+    const idWidth = Math.max(10, ...rows.map((row) => row.id.length));
+    console.log(`${'ID'.padEnd(idWidth)}  NAME`);
+    console.log(`${'-'.repeat(idWidth)}  ${'-'.repeat(40)}`);
+    for (const row of rows) {
+        console.log(`${row.id.padEnd(idWidth)}  ${row.name}`);
+    }
+}
+function renderAgentOverview(conversationId, conversation, strategies) {
+    console.log(`Agent ${conversationId}`);
+    console.log('='.repeat(`Agent ${conversationId}`.length));
+    printSection('Conversation');
+    printKeyValue('Name', conversation.name || '(untitled)');
+    printKeyValue('Status', conversation.status || 'unknown');
+    printKeyValue('Updated', formatTimestamp(conversation.updatedAt));
+    printKeyValue('Heartbeat', conversation.lastHeartbeat ? formatTimestamp(conversation.lastHeartbeat) : 'none');
+    printSection('Strategies');
+    if (!strategies.length) {
+        console.log('No strategies found for this agent.');
+        return;
+    }
+    const runningCount = strategies.filter((s) => Boolean(s.isRunning)).length;
+    printKeyValue('Total', String(strategies.length));
+    printKeyValue('Running', String(runningCount));
+    for (const strategy of strategies) {
+        const label = strategy.isRunning ? 'running' : 'stopped';
+        console.log(`- ${strategy.id ?? 'unknown'} | ${strategy.strategyType || 'unknown'} | ${label} | pnl=${formatUsd(strategy.totalPnl || '0')} | terminateAt=${formatTimestamp(strategy.terminateAt)}`);
+    }
+}
+async function handleStrategy(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`Usage:
+  dawn strategy list
+  dawn strategy create <text>
+  dawn strategy status <id>
+  dawn strategy revise <id> <text>
+  dawn strategy rules <id> list
+  dawn strategy rules <id> approve <rule-index>
+  dawn strategy rules <id> approve-all
+  dawn strategy code <id> status
+  dawn strategy code <id> generate
+  dawn strategy code <id> export [--out <path>] [--json]
+  dawn strategy code <id> upload <path-to-file>
+  dawn strategy launch <id> --budget <usd> [--live] [--hours N]`);
+        return;
+    }
+    const config = await loadConfig();
+    if (!getAuthToken(config)) {
+        throw new Error('Not authenticated. Run: dawn auth login');
+    }
+    const [primaryCommand, ...rest] = args;
+    if (!primaryCommand) {
+        throw new Error('Missing strategy command.');
+    }
+    if (!['list', 'create', 'status', 'revise', 'rules', 'code', 'launch'].includes(primaryCommand)) {
+        throw new Error(`Unknown strategy command: ${primaryCommand}. Run \`dawn strategy --help\` for available commands.`);
+    }
+    let subcommand = primaryCommand;
+    if (primaryCommand === 'rules') {
+        const conversationId = rest[0];
+        const action = rest[1];
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy rules <id> <list|approve <rule-index>|approve-all>');
+        }
+        if (action === 'list') {
+            subcommand = '__rules-list';
+            rest.splice(0, rest.length, conversationId);
+        }
+        else if (action === 'approve') {
+            subcommand = '__rules-approve';
+            rest.splice(0, rest.length, conversationId, rest[2] || '');
+        }
+        else if (action === 'approve-all') {
+            subcommand = '__rules-approve-all';
+            rest.splice(0, rest.length, conversationId);
+        }
+        else {
+            throw new Error('Usage: dawn strategy rules <id> <list|approve <rule-index>|approve-all>');
+        }
+    }
+    if (primaryCommand === 'code') {
+        const conversationId = rest[0];
+        const action = rest[1];
+        const tail = rest.slice(2);
+        if (!conversationId || !action) {
+            throw new Error('Usage: dawn strategy code <id> <status|generate|export|upload> [args]');
+        }
+        if (action === 'status') {
+            subcommand = '__status';
+            rest.splice(0, rest.length, conversationId);
+        }
+        else if (action === 'generate') {
+            subcommand = '__generate';
+            rest.splice(0, rest.length, conversationId);
+        }
+        else if (action === 'export') {
+            subcommand = '__raw-code';
+            rest.splice(0, rest.length, conversationId, ...tail);
+        }
+        else if (action === 'upload') {
+            if (!tail[0]) {
+                throw new Error('Usage: dawn strategy code <id> upload <path-to-file>');
+            }
+            subcommand = '__upload';
+            rest.splice(0, rest.length, conversationId, tail[0]);
+        }
+        else {
+            throw new Error(`Unknown strategy code command: ${action}`);
+        }
+    }
+    if (primaryCommand === 'status') {
+        const conversationId = rest[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy status <id>');
+        }
+        subcommand = '__status';
+        rest.splice(0, rest.length, conversationId);
+    }
+    if (primaryCommand === 'revise') {
+        const conversationId = rest[0];
+        const text = rest.slice(1).join(' ').trim();
+        if (!conversationId || !text) {
+            throw new Error('Usage: dawn strategy revise <id> <text>');
+        }
+        subcommand = '__edit';
+        rest.splice(0, rest.length, conversationId, text);
+    }
+    if (subcommand === 'list') {
+        const data = await apiFetch(config, '/conversations?isArchived=false');
+        renderConversationList(data);
+        return;
+    }
+    if (subcommand === 'create') {
+        const text = rest.join(' ').trim();
+        if (!text) {
+            throw new Error('Usage: dawn strategy create <text>');
+        }
+        const result = (await apiFetch(config, '/conversations', {
+            method: 'POST',
+            body: JSON.stringify({ userMessage: text }),
+        }));
+        console.log(`Created strategy conversation: ${result.conversationId}`);
+        return;
+    }
+    if (subcommand === '__upload') {
+        const conversationId = rest[0];
+        const filePath = rest[1];
+        if (!conversationId || !filePath) {
+            throw new Error('Usage: dawn strategy code <id> upload <path-to-file>');
+        }
+        const latestVersion = (await apiFetch(config, `/conversations/${conversationId}/latest-version?withCode=true`));
+        if (!latestVersion?.id) {
+            throw new Error('No strategy version found for conversation.');
+        }
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        const content = await fs.readFile(absolutePath, 'utf8');
+        let codePayload = null;
+        if (absolutePath.endsWith('.json')) {
+            try {
+                const parsed = JSON.parse(content);
+                const validMap = parsed &&
+                    typeof parsed === 'object' &&
+                    !Array.isArray(parsed) &&
+                    Object.values(parsed).every((v) => typeof v === 'string');
+                if (validMap) {
+                    codePayload = parsed;
+                }
+            }
+            catch {
+                // fall through to single-file mode
+            }
+        }
+        if (!codePayload) {
+            codePayload = {
+                [path.basename(absolutePath)]: content,
+            };
+        }
+        await apiFetch(config, '/v2/strategy/update-code', {
+            method: 'POST',
+            body: JSON.stringify({
+                versionId: latestVersion.id,
+                code: codePayload,
+            }),
+        });
+        console.log(`Uploaded code to version ${latestVersion.id}.`);
+        return;
+    }
+    if (subcommand === '__rules-list') {
+        const conversationId = rest[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy rules <id> list');
+        }
+        const latestVersion = await getLatestStrategyVersion(config, conversationId, false);
+        if (!latestVersion?.id) {
+            throw new Error('No strategy version found for conversation.');
+        }
+        renderStrategyRules(latestVersion);
+        return;
+    }
+    if (subcommand === '__rules-approve') {
+        const conversationId = rest[0];
+        const ruleIndexRaw = rest[1];
+        if (!conversationId || !ruleIndexRaw) {
+            throw new Error('Usage: dawn strategy rules <id> approve <rule-index>');
+        }
+        const ruleIndex = Number(ruleIndexRaw);
+        if (!Number.isInteger(ruleIndex) || ruleIndex < 0) {
+            throw new Error('rule-index must be a non-negative integer.');
+        }
+        const latestVersion = await getLatestStrategyVersion(config, conversationId, false);
+        if (!latestVersion?.id) {
+            throw new Error('No strategy version found for conversation.');
+        }
+        const updated = (await apiFetch(config, `/v2/strategy/approve-rule/${latestVersion.id}`, {
+            method: 'POST',
+            body: JSON.stringify({ ruleIndex }),
+        }));
+        const approvedRuleIndices = updated.approvedRuleIndices || [];
+        const isApproved = approvedRuleIndices.includes(ruleIndex);
+        console.log(`${isApproved ? 'Approved' : 'Unapproved'} rule ${ruleIndex} on version ${latestVersion.id}.`);
+        console.log(`Approved indices: ${approvedRuleIndices.join(', ') || '(none)'}`);
+        return;
+    }
+    if (subcommand === '__rules-approve-all') {
+        const conversationId = rest[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy rules <id> approve-all');
+        }
+        const latestVersion = await getLatestStrategyVersion(config, conversationId, false);
+        if (!latestVersion?.id) {
+            throw new Error('No strategy version found for conversation.');
+        }
+        const rules = Array.isArray(latestVersion.strategy?.rules)
+            ? latestVersion.strategy?.rules
+            : [];
+        if (!rules.length) {
+            console.log('No rules to approve.');
+            return;
+        }
+        const approved = new Set(latestVersion.metadata?.generation?.approvedRuleIndices || []);
+        for (let i = 0; i < rules.length; i += 1) {
+            if (approved.has(i)) {
+                continue;
+            }
+            const response = (await apiFetch(config, `/v2/strategy/approve-rule/${latestVersion.id}`, {
+                method: 'POST',
+                body: JSON.stringify({ ruleIndex: i }),
+            }));
+            const nextApproved = response.approvedRuleIndices || [];
+            approved.clear();
+            for (const idx of nextApproved) {
+                approved.add(idx);
+            }
+        }
+        console.log(`Approved all rules for version ${latestVersion.id}. Total approved: ${approved.size}/${rules.length}.`);
+        return;
+    }
+    if (subcommand === '__generate') {
+        const conversationId = rest[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy code <id> generate');
+        }
+        const latestVersion = await getLatestStrategyVersion(config, conversationId, false);
+        if (!latestVersion?.id) {
+            throw new Error('No strategy version found for conversation.');
+        }
+        const rules = Array.isArray(latestVersion.strategy?.rules)
+            ? latestVersion.strategy?.rules
+            : [];
+        const approved = new Set(latestVersion.metadata?.generation?.approvedRuleIndices || []);
+        const unapproved = rules
+            .map((_, i) => i)
+            .filter((i) => !approved.has(i));
+        if (unapproved.length > 0) {
+            throw new Error(`Cannot generate code: unapproved rule indices: ${unapproved.join(', ')}. Run: dawn strategy rules ${conversationId} approve-all`);
+        }
+        const result = (await apiFetch(config, `/v2/strategy/generate-code/${latestVersion.id}`, {
+            method: 'POST',
+        }));
+        console.log(result?.message ||
+            `Code generation requested for version ${latestVersion.id}.`);
+        return;
+    }
+    if (subcommand === '__raw-code') {
+        const conversationId = rest[0];
+        const { flags } = parseFlags(rest.slice(1));
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy code <id> export [--out <path>] [--json]');
+        }
+        const latestVersionWithCode = await apiFetch(config, `/conversations/${conversationId}/latest-version?withCode=true`);
+        const codeMap = extractCodeMap(latestVersionWithCode);
+        if (!codeMap) {
+            throw new Error('No raw code payload found on latest strategy version.');
+        }
+        const wantsJson = flags.json === true ||
+            (typeof flags.out === 'string' && flags.out.toLowerCase().endsWith('.json'));
+        const defaultPath = wantsJson
+            ? `dawn-strategy-${conversationId}-code.json`
+            : `dawn-strategy-${conversationId}.py`;
+        const outPath = typeof flags.out === 'string' ? flags.out : defaultPath;
+        const absolutePath = path.resolve(process.cwd(), outPath);
+        if (wantsJson) {
+            await fs.writeFile(absolutePath, JSON.stringify(codeMap, null, 2));
+            console.log(`Saved raw strategy code map to ${absolutePath}`);
+            return;
+        }
+        const pythonEntry = codeMap['strategy.py'] ||
+            Object.entries(codeMap).find(([filename]) => filename.endsWith('.py'))?.[1];
+        if (!pythonEntry) {
+            throw new Error('No Python source file found in strategy code map. Re-run with --json to inspect all files.');
+        }
+        await fs.writeFile(absolutePath, pythonEntry);
+        console.log(`Saved strategy Python file to ${absolutePath}`);
+        return;
+    }
+    if (subcommand === '__edit') {
+        const conversationId = rest[0];
+        const text = rest.slice(1).join(' ').trim();
+        if (!conversationId || !text) {
+            throw new Error('Usage: dawn strategy revise <id> <text>');
+        }
+        await apiFetch(config, `/conversations/${conversationId}/messages`, {
+            method: 'POST',
+            body: JSON.stringify({ userMessage: text }),
+        });
+        console.log(`Sent edit request to strategy ${conversationId}.`);
+        return;
+    }
+    if (subcommand === 'launch') {
+        const conversationId = rest[0];
+        const { flags } = parseFlags(rest.slice(1));
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy launch <id> --budget <usd> [--live] [--hours N]');
+        }
+        if (typeof flags.budget !== 'string') {
+            throw new Error('Missing required --budget <usd>. Example: dawn strategy launch 123 --budget 50 --hours 24');
+        }
+        const budget = Number(flags.budget);
+        if (!Number.isFinite(budget) || budget <= 0) {
+            throw new Error('--budget must be a positive number.');
+        }
+        const isPaper = !flags.live;
+        const vaultType = isPaper ? 'paper' : 'strategy';
+        const vaultsResponse = (await apiFetch(config, `/v1/vaults/all/${vaultType}?isArchived=false`));
+        const vaults = vaultsResponse?.vaults || [];
+        if (vaults.length === 0) {
+            throw new Error(`No ${vaultType} vault found. Create one in the Dawn app before launching.`);
+        }
+        const vault = vaults[0];
+        const latestVersion = await getLatestStrategyVersion(config, conversationId, true);
+        if (!latestVersion?.id) {
+            throw new Error(`No code-ready strategy version found. Run: dawn strategy rules ${conversationId} approve-all, then dawn strategy code ${conversationId} generate.`);
+        }
+        const configuredBudget = Number(latestVersion.strategy?.initialAmount);
+        if (!Number.isFinite(configuredBudget) || configuredBudget <= 0) {
+            throw new Error(`Latest strategy version ${latestVersion.id} is missing a valid initialAmount. Update strategy rules/spec and regenerate code before launch.`);
+        }
+        if (Math.abs(configuredBudget - budget) > 1e-9) {
+            throw new Error(`Budget mismatch: launch budget is ${budget}, but latest version initialAmount is ${configuredBudget}. Re-run with --budget ${configuredBudget} or update/regenerate the strategy amount first.`);
+        }
+        const hours = Number(flags.hours || 24);
+        if (!Number.isFinite(hours) || hours <= 0) {
+            throw new Error('--hours must be a positive number.');
+        }
+        const terminateAt = new Date(Date.now() + hours * 60 * 60 * 1000).toISOString();
+        const result = (await apiFetch(config, `/strategy/${conversationId}/run-strategy-v2`, {
+            method: 'POST',
+            body: JSON.stringify({
+                strategyVersionId: latestVersion.id,
+                isPaper,
+                terminateAt,
+                walletId: vault.id,
+            }),
+        }));
+        console.log(`Launched strategy. Strategy ID: ${result?.strategy?.id ?? 'unknown'}${isPaper ? ' (paper)' : ' (live)'}`);
+        return;
+    }
+    if (subcommand === '__status') {
+        const conversationId = rest[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn strategy status <id>');
+        }
+        const [conversationRaw, latestVersionRaw, strategiesRaw] = await Promise.all([
+            apiFetch(config, `/conversations/${conversationId}`),
+            apiFetch(config, `/conversations/${conversationId}/latest-version?withCode=false`),
+            apiFetch(config, `/strategy/conversation/${conversationId}`),
+        ]);
+        const conversation = conversationRaw;
+        const latestVersion = (latestVersionRaw || null);
+        const strategies = Array.isArray(strategiesRaw)
+            ? strategiesRaw
+            : [];
+        let generationStatus = null;
+        if (latestVersion?.id) {
+            try {
+                const generationRaw = (await apiFetch(config, `/v2/strategy/generation-status/${latestVersion.id}`));
+                generationStatus = generationRaw.generationStatus || null;
+            }
+            catch {
+                // Generation status endpoint is best-effort; latest version metadata remains fallback.
+            }
+        }
+        printConversationStatus(conversationId, conversation, latestVersion, generationStatus, strategies);
+        return;
+    }
+    throw new Error('Unknown strategy command.');
+}
+async function handleAgent(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`Usage:
+  dawn agent list
+  dawn agent <id>
+  dawn agent stop <id>`);
+        return;
+    }
+    const config = await loadConfig();
+    if (!getAuthToken(config)) {
+        throw new Error('Not authenticated. Run: dawn auth login');
+    }
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        throw new Error('Missing agent command.');
+    }
+    if (subcommand === 'list') {
+        const data = await apiFetch(config, '/conversations?isArchived=false');
+        renderConversationList(data);
+        return;
+    }
+    if (subcommand === 'stop') {
+        const conversationId = rest[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn agent stop <id>');
+        }
+        const strategies = (await apiFetch(config, `/strategy/conversation/${conversationId}`));
+        if (!Array.isArray(strategies) || strategies.length === 0) {
+            throw new Error('No strategies found for this agent.');
+        }
+        const running = strategies.find((s) => s?.isRunning) ||
+            strategies.find((s) => s?.status === 'running') ||
+            strategies[0];
+        const strategyId = running?.id;
+        if (!strategyId) {
+            throw new Error('Could not determine strategy ID to stop.');
+        }
+        await apiFetch(config, `/strategy/${strategyId}/terminate`, { method: 'PATCH' });
+        console.log(`Stopped strategy ${strategyId} for agent ${conversationId}.`);
+        return;
+    }
+    if (args.length === 1) {
+        const [conversation, strategies] = await Promise.all([
+            apiFetch(config, `/conversations/${subcommand}`),
+            apiFetch(config, `/strategy/conversation/${subcommand}`),
+        ]);
+        const conversationSummary = conversation;
+        const strategySummaries = Array.isArray(strategies)
+            ? strategies
+            : [];
+        renderAgentOverview(subcommand, conversationSummary, strategySummaries);
+        return;
+    }
+    throw new Error('Unknown agent command.');
+}
+async function handleRun(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`Usage:
+  dawn run list
+  dawn run status <id>
+  dawn run logs <id> [--limit N]
+  dawn run stop <id>`);
+        return;
+    }
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        throw new Error('Missing run command.');
+    }
+    if (subcommand === 'list') {
+        await handleAgent(['list']);
+        return;
+    }
+    if (subcommand === 'status') {
+        const conversationId = rest[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn run status <id>');
+        }
+        await handleAgent([conversationId]);
+        return;
+    }
+    if (subcommand === 'logs') {
+        const { flags, positional } = parseFlags(rest);
+        const conversationId = positional[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn run logs <id> [--limit N]');
+        }
+        const config = await loadConfig();
+        if (!getAuthToken(config)) {
+            throw new Error('Not authenticated. Run: dawn auth login');
+        }
+        const sessionLimit = Number(flags.limit || 10);
+        // Find strategies for this conversation
+        const strategies = (await apiFetch(config, `/strategy/conversation/${conversationId}`));
+        if (!Array.isArray(strategies) || strategies.length === 0) {
+            throw new Error(`No strategies found for conversation ${conversationId}.`);
+        }
+        // Prefer the running strategy, otherwise most recent
+        const strategy = strategies.find((s) => s.isRunning) || strategies[0];
+        const strategyId = strategy.id;
+        console.log(`Strategy ${strategyId} (${strategy.strategyType || 'unknown'}${strategy.isRunning ? ', running' : ', stopped'})`);
+        console.log('');
+        // Fetch sessions
+        const sessionsResp = (await apiFetch(config, `/strategy/${strategyId}/sessions?limit=${sessionLimit}&offset=0`));
+        const sessions = sessionsResp.sessions || [];
+        if (sessions.length === 0) {
+            console.log('No execution sessions found yet.');
+            return;
+        }
+        console.log(`Sessions: ${sessions.length} of ${sessionsResp.total} total\n`);
+        // Fetch details for each session
+        for (const session of sessions) {
+            const details = (await apiFetch(config, `/strategy/session/${session.id}/details`));
+            console.log(`--- Session ${session.id} (${formatTimestamp(session.createdAt)}) ---`);
+            if (details.messages && details.messages.length > 0) {
+                for (const msg of details.messages) {
+                    const ts = formatTimestamp(msg.createdAt);
+                    // Try to extract structured logs from JSON content
+                    let parsed = null;
+                    try {
+                        parsed =
+                            typeof msg.content === 'string'
+                                ? JSON.parse(msg.content)
+                                : msg.content;
+                    }
+                    catch {
+                        // not JSON
+                    }
+                    if (parsed) {
+                        // Extract stdout from execution_logs or execution_result messages
+                        const logType = parsed.type;
+                        if (logType === 'execution_logs' || logType === 'execution_result') {
+                            const logs = (logType === 'execution_logs'
+                                ? parsed.logs
+                                : null) ||
+                                parsed.result?.logs?.stdout;
+                            if (Array.isArray(logs)) {
+                                for (const entry of logs) {
+                                    if (typeof entry === 'string') {
+                                        // execution_result stdout array
+                                        process.stdout.write(entry);
+                                    }
+                                    else if (entry && typeof entry === 'object' && 'message' in entry) {
+                                        // execution_logs array
+                                        process.stdout.write(entry.message);
+                                    }
+                                }
+                            }
+                        }
+                        else if (msg.role === 'tool') {
+                            // tool messages contain the run_code_v2 output; skip (redundant with execution_logs)
+                            continue;
+                        }
+                        else {
+                            console.log(`[${ts}] [${msg.role}] ${JSON.stringify(parsed).slice(0, 200)}`);
+                        }
+                    }
+                    else {
+                        const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                        console.log(`[${ts}] [${msg.role}] ${content}`);
+                    }
+                }
+            }
+            else {
+                console.log('  (no messages)');
+            }
+            if (details.transactions && details.transactions.length > 0) {
+                console.log('  Transactions:');
+                for (const tx of details.transactions) {
+                    const symbol = tx.asset?.symbol || '???';
+                    console.log(`    ${tx.type} ${tx.amount} ${symbol} (${formatTimestamp(tx.createdAt)})`);
+                }
+            }
+            console.log('');
+        }
+        return;
+    }
+    if (subcommand === 'stop') {
+        const conversationId = rest[0];
+        if (!conversationId) {
+            throw new Error('Usage: dawn run stop <id>');
+        }
+        await handleAgent(['stop', conversationId]);
+        return;
+    }
+    throw new Error(`Unknown run command: ${subcommand}`);
+}
+async function main() {
+    const [cmd, ...args] = process.argv.slice(2);
+    if (cmd === '--version' || cmd === '-V' || cmd === 'version') {
+        console.log(`dawn-cli ${CLI_VERSION}`);
+        return;
+    }
+    if (!cmd || cmd === '--help' || cmd === '-h') {
+        printUsage();
+        return;
+    }
+    try {
+        if (cmd === 'auth') {
+            await handleAuth(args);
+            return;
+        }
+        if (cmd === 'account') {
+            await handleAccount(args);
+            return;
+        }
+        if (cmd === 'strategy') {
+            await handleStrategy(args);
+            return;
+        }
+        if (cmd === 'run') {
+            await handleRun(args);
+            return;
+        }
+        throw new Error(`Unknown command: ${cmd}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    }
+}
+await main();

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@dawnai/cli",
+  "version": "1.0.3",
+  "type": "module",
+  "description": "User-facing Dawn CLI",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "dawn": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CLAUDE.md",
+    "postinstall.js"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "postinstall": "node postinstall.js",
+    "prepare": "npm run build",
+    "prepack": "npm run build",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "echo \"No tests configured\"",
+    "pack:check": "npm pack --dry-run"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.2"
+  }
+}

package/postinstall.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// Only show the banner for global installs (skip when installing as a dependency).
+const isGlobal =
+  process.env.npm_config_global === 'true' ||
+  (process.env.npm_lifecycle_event === 'postinstall' &&
+    !process.env.npm_package_name);
+
+if (!isGlobal) {
+  process.exit(0);
+}
+
+console.log(`
+  @dawnai/cli installed successfully.
+
+  Get started:
+    dawn --version          Check installed version
+    dawn auth login         Authenticate (opens browser)
+    dawn --help             Show all commands
+
+  Headless / CI / agent environments:
+    export DAWN_JWT_TOKEN="<your-token>"
+
+  Config is stored at ~/.dawn-cli/config.json
+`);