@dawnai/cli 1.0.7 → 1.1.0

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/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 readline from 'node:readline/promises';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-const CLI_VERSION = '1.0.7';
+const CLI_VERSION = '1.1.0';
 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');
@@ -136,6 +136,12 @@ function formatNumeric(value, fallback = 0) {
     const n = Number(value);
     return Number.isFinite(n) ? n : fallback;
 }
+function parseDecimalAmount(value, fallback = 0) {
+    if (typeof value === 'string') {
+        return formatNumeric(value.replace(/,/g, '').trim(), fallback);
+    }
+    return formatNumeric(value, fallback);
+}
 function formatUsd(value) {
     return `$${formatNumeric(value).toLocaleString('en-US', {
         minimumFractionDigits: 2,
@@ -353,6 +359,76 @@ async function getLatestStrategyVersion(config, conversationId, withCode) {
     const latest = (await apiFetch(config, `/conversations/${conversationId}/latest-version?withCode=${withCode ? 'true' : 'false'}`));
     return latest || null;
 }
+async function resolveLaunchVaultId(config, isPaper, budget) {
+    if (isPaper) {
+        console.log('Creating new paper vault...');
+        const createResponse = (await apiFetch(config, '/v1/vaults/create', {
+            method: 'POST',
+            body: JSON.stringify({ walletType: 'paper' }),
+        }));
+        const createdVaultId = createResponse?.vault?.id;
+        if (!createResponse?.success || !createdVaultId) {
+            throw new Error(createResponse?.error ||
+                'Failed to create paper vault: invalid create-vault response.');
+        }
+        const vaultId = String(createdVaultId);
+        console.log(`Paper vault created: ${shortId(vaultId)}.`);
+        console.log(`Auto-funding paper vault with ${formatUsd(budget)}...`);
+        await apiFetch(config, `/v1/vaults/${vaultId}/fund`, {
+            method: 'POST',
+            body: JSON.stringify({ amount: String(budget) }),
+        });
+        console.log(`Paper vault funded: ${formatUsd(budget)}.`);
+        return vaultId;
+    }
+    const vaultsResponse = (await apiFetch(config, '/v1/vaults/all/strategy?isArchived=false'));
+    const vaults = vaultsResponse?.vaults || [];
+    let strategyVaultId = '';
+    let strategyVaultCurrentAmount = 0;
+    if (vaults.length > 0) {
+        strategyVaultId = String(vaults[0].id);
+        strategyVaultCurrentAmount = formatNumeric(vaults[0].currentAmount);
+    }
+    else {
+        console.log('No strategy vault found, creating strategy vault...');
+        const createResponse = (await apiFetch(config, '/v1/vaults/create', {
+            method: 'POST',
+            body: JSON.stringify({ walletType: 'strategy' }),
+        }));
+        const createdVaultId = createResponse?.vault?.id;
+        if (!createResponse?.success || !createdVaultId) {
+            throw new Error(createResponse?.error ||
+                'Failed to create strategy vault: invalid create-vault response.');
+        }
+        strategyVaultId = String(createdVaultId);
+        strategyVaultCurrentAmount = 0;
+        console.log(`Strategy vault created: ${shortId(createdVaultId)}.`);
+    }
+    const fundingDeficit = budget - strategyVaultCurrentAmount;
+    if (fundingDeficit > 1e-9) {
+        const walletBalance = (await apiFetch(config, '/wallet/balance'));
+        const availableFundingBalance = parseDecimalAmount(walletBalance.availableBalance ?? walletBalance.usdcBalance ?? '0', 0);
+        console.log(`Strategy vault funding is ${formatUsd(strategyVaultCurrentAmount)}; funding additional ${formatUsd(fundingDeficit)} to reach ${formatUsd(budget)}...`);
+        if (availableFundingBalance + 1e-9 < fundingDeficit) {
+            throw new Error(`Insufficient available funding balance for live launch: available ${formatUsd(availableFundingBalance)}, required ${formatUsd(fundingDeficit)}.`);
+        }
+        try {
+            await apiFetch(config, `/v1/vaults/${strategyVaultId}/fund`, {
+                method: 'POST',
+                body: JSON.stringify({ amount: String(fundingDeficit) }),
+            });
+            console.log(`Strategy vault funded: +${formatUsd(fundingDeficit)}.`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(`Failed to auto-fund strategy vault: ${message}`);
+        }
+    }
+    else {
+        console.log(`Strategy vault already funded (${formatUsd(strategyVaultCurrentAmount)} >= ${formatUsd(budget)}).`);
+    }
+    return strategyVaultId;
+}
 async function apiFetch(config, endpoint, options = {}) {
     const apiBaseUrl = await getApiBaseUrl(config);
     const token = getAuthToken(config);
@@ -386,20 +462,27 @@ async function apiFetch(config, endpoint, options = {}) {
     }
     return body;
 }
-function openBrowser(url) {
-    const platform = process.platform;
-    if (platform === 'darwin') {
-        spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
-        return;
+async function promptForHeadlessCode() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error('Interactive input is unavailable. Set DAWN_JWT_TOKEN for non-interactive environments.');
     }
-    if (platform === 'win32') {
-        spawn('cmd', ['/c', 'start', '', url], {
-            stdio: 'ignore',
-            detached: true,
-        }).unref();
-        return;
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        for (let attempt = 1; attempt <= 3; attempt += 1) {
+            const raw = (await rl.question('Enter the 6-digit code: ')).trim();
+            if (/^\d{6}$/.test(raw)) {
+                return raw;
+            }
+            console.log('Invalid code format. Please enter exactly 6 digits.');
+        }
     }
-    spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+    finally {
+        rl.close();
+    }
+    throw new Error('Too many invalid code entry attempts.');
 }
 async function handleAuth(args) {
     if (args.includes('--help') || args.includes('-h')) {
@@ -408,11 +491,11 @@ async function handleAuth(args) {
   dawn auth status
   dawn auth logout
 
-For headless/CI environments, set the DAWN_JWT_TOKEN environment variable
-instead of using interactive login.`);
+Login uses a browser URL + 6-digit code flow.
+For non-interactive headless/CI environments, set DAWN_JWT_TOKEN.`);
         return;
     }
-    const [subcommand, ...rest] = args;
+    const [subcommand] = args;
     if (!subcommand) {
         throw new Error('Usage: dawn auth <login|status|logout>');
     }
@@ -437,103 +520,36 @@ instead of using interactive login.`);
     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);
-    });
+    const apiBaseUrl = await getApiBaseUrl(config);
+    const initiateResponse = (await apiFetch(config, '/v1/auth/google/?headless=true'));
+    const authUrl = initiateResponse.authUrl;
+    const loginRequestId = initiateResponse.loginRequestId;
+    if (!authUrl || !loginRequestId) {
+        throw new Error('Failed to initialize headless authentication flow.');
+    }
+    console.log(`Using API: ${apiBaseUrl}`);
+    console.log('');
+    console.log('Open this URL in any browser/device and complete Google login:');
+    console.log(authUrl);
+    if (typeof initiateResponse.expiresInSeconds === 'number') {
+        console.log(`Code expires in about ${Math.max(1, Math.floor(initiateResponse.expiresInSeconds / 60))} minute(s).`);
+    }
+    console.log('');
+    const code = await promptForHeadlessCode();
+    const completeResponse = (await apiFetch(config, '/v1/auth/google/headless/complete', {
+        method: 'POST',
+        body: JSON.stringify({
+            loginRequestId,
+            code,
+        }),
+    }));
+    const token = completeResponse.jwtToken;
+    if (!token) {
+        throw new Error('Authentication did not return a JWT token.');
+    }
+    const latestConfig = await loadConfig();
+    await saveConfig({ ...latestConfig, token });
     console.log('Authentication successful.');
 }
 async function ensureWallet(config) {
@@ -583,13 +599,7 @@ async function handleFund(args) {
     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).');
-    }
+    console.log('Use @moonpay/cli to deposit USDC.e to the wallet above.');
 }
 async function handleOverview(args) {
     const { flags } = parseFlags(args);
@@ -1152,13 +1162,6 @@ async function handleStrategy(args) {
             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.`);
@@ -1175,13 +1178,14 @@ async function handleStrategy(args) {
             throw new Error('--hours must be a positive number.');
         }
         const terminateAt = new Date(Date.now() + hours * 60 * 60 * 1000).toISOString();
+        const vaultId = await resolveLaunchVaultId(config, isPaper, budget);
         const result = (await apiFetch(config, `/strategy/${conversationId}/run-strategy-v2`, {
             method: 'POST',
             body: JSON.stringify({
                 strategyVersionId: latestVersion.id,
                 isPaper,
                 terminateAt,
-                walletId: vault.id,
+                walletId: vaultId,
             }),
         }));
         console.log(`Launched strategy. Strategy ID: ${result?.strategy?.id ?? 'unknown'}${isPaper ? ' (paper)' : ' (live)'}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawnai/cli",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "type": "module",
   "description": "User-facing Dawn CLI",
   "license": "MIT",