@dawnai/cli 1.0.8 → 1.1.1

package/README.md

@@ -25,6 +25,10 @@ dawn account overview
 dawn account fund
 dawn account wallet
 
+dawn wallet list
+dawn wallet use <address-or-name>
+dawn wallet current
+
 dawn strategy list
 dawn strategy create "<text>"
 dawn strategy status <id>
@@ -45,6 +49,8 @@ dawn run stop <id>
 
 dawn skill list
 dawn skill install [--force] [--dir <path>]
+
+dawn sdk doctor
 ```
 
 ## Environment Variables
@@ -57,5 +63,8 @@ dawn skill install [--force] [--dir <path>]
 ## Notes
 
 - Auth token is stored at `~/.dawn-cli/config.json`.
+- Active Moonpay wallet selection is stored in `~/.dawn-cli/config.json` under `moonpay`.
+- `dawn wallet list` shells out to `mp wallet list` and uses the Polygon address for selection.
 - `dawn account fund` prints the wallet address and Polygon USDC deposit instructions.
 - `dawn skill install` copies bundled Dawn skills into `~/.claude/skills` for Claude Code.
+- `dawn sdk doctor` verifies the local Dawn SDK executable (`dawnsdk`) is available.

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.8';
+const CLI_VERSION = '1.1.1';
 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');
@@ -195,6 +195,10 @@ function printUsage() {
   dawn account fund
   dawn account wallet
 
+  dawn wallet list
+  dawn wallet use <address-or-name>
+  dawn wallet current
+
   dawn strategy list
   dawn strategy create <text>
   dawn strategy status <id>
@@ -217,6 +221,8 @@ function printUsage() {
   dawn skill list
   dawn skill install [--force] [--dir <path>]
 
+  dawn sdk doctor
+
   dawn update
 
   dawn --version
@@ -226,6 +232,111 @@ Environment variables:
   DAWN_CLI_HOME        Override config directory (default: ~/.dawn-cli)
 `);
 }
+function normalizeEvmAddress(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!/^0x[a-fA-F0-9]{40}$/.test(trimmed)) {
+        return null;
+    }
+    return trimmed.toLowerCase();
+}
+function getMoonpayConfig(config) {
+    if (!config.moonpay || typeof config.moonpay !== 'object' || Array.isArray(config.moonpay)) {
+        return {};
+    }
+    const moonpay = config.moonpay;
+    return {
+        activeWalletAddress: typeof moonpay.activeWalletAddress === 'string' ? moonpay.activeWalletAddress : undefined,
+        activeWalletName: typeof moonpay.activeWalletName === 'string' ? moonpay.activeWalletName : undefined,
+    };
+}
+async function runMoonpayCommand(args) {
+    const result = await new Promise((resolve) => {
+        const child = spawn('mp', args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => { stdout += data.toString(); });
+        child.stderr.on('data', (data) => { stderr += data.toString(); });
+        child.on('close', (code) => { resolve({ code: code ?? 1, stdout, stderr }); });
+    });
+    if (result.code !== 0) {
+        throw new Error(result.stderr.trim() || result.stdout.trim() || 'Moonpay CLI command failed.');
+    }
+    return result.stdout;
+}
+function parseMoonpayWalletList(output) {
+    const lines = output.split(/\r?\n/);
+    const wallets = [];
+    let currentName = null;
+    let currentPolygonAddress = null;
+    const flushCurrent = () => {
+        if (currentName && currentPolygonAddress) {
+            wallets.push({
+                name: currentName,
+                address: currentPolygonAddress,
+            });
+        }
+    };
+    for (const line of lines) {
+        const nameMatch = line.match(/^\s*-\s*name:\s*(.+)\s*$/);
+        if (nameMatch) {
+            flushCurrent();
+            currentName = nameMatch[1].trim();
+            currentPolygonAddress = null;
+            continue;
+        }
+        const polygonMatch = line.match(/^\s*polygon:\s*(0x[a-fA-F0-9]{40})\s*$/);
+        if (polygonMatch) {
+            currentPolygonAddress = polygonMatch[1].toLowerCase();
+        }
+    }
+    flushCurrent();
+    return wallets;
+}
+async function loadMoonpayWallets() {
+    const output = await runMoonpayCommand(['wallet', 'list']);
+    const wallets = parseMoonpayWalletList(output);
+    if (!wallets.length) {
+        throw new Error('Could not find Polygon wallets from `mp wallet list`. Ensure Moonpay CLI is installed and has wallets.');
+    }
+    return wallets;
+}
+function findMoonpayWalletBySelector(wallets, selector) {
+    const normalizedAddress = normalizeEvmAddress(selector);
+    if (normalizedAddress) {
+        const byAddress = wallets.find((wallet) => wallet.address === normalizedAddress);
+        if (byAddress) {
+            return byAddress;
+        }
+    }
+    const lowered = selector.toLowerCase();
+    const byName = wallets.filter((wallet) => wallet.name.toLowerCase() === lowered);
+    if (byName.length === 1) {
+        return byName[0];
+    }
+    if (byName.length > 1) {
+        throw new Error(`Multiple Moonpay wallets match "${selector}". Use full address or wallet ID instead.`);
+    }
+    throw new Error(`No Moonpay wallet matched "${selector}". Run: dawn wallet list`);
+}
+function printMoonpayWalletTable(wallets, activeAddress) {
+    const rows = wallets.map((wallet) => ({
+        active: activeAddress && wallet.address === activeAddress ? '*' : ' ',
+        name: wallet.name,
+        address: wallet.address,
+    }));
+    const nameWidth = Math.max(8, ...rows.map((row) => row.name.length));
+    const addressWidth = Math.max(42, ...rows.map((row) => row.address.length));
+    console.log(`${'A'.padEnd(2)}${'NAME'.padEnd(nameWidth)}  ${'POLYGON_ADDRESS'.padEnd(addressWidth)}`);
+    console.log(`${'-'.repeat(2)}${'-'.repeat(nameWidth)}  ${'-'.repeat(addressWidth)}`);
+    for (const row of rows) {
+        console.log(`${row.active.padEnd(2)}${row.name.padEnd(nameWidth)}  ${row.address}`);
+    }
+}
 function parseFlags(args) {
     const flags = {};
     const positional = [];
@@ -462,20 +573,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.');
+        }
+    }
+    finally {
+        rl.close();
     }
-    spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+    throw new Error('Too many invalid code entry attempts.');
 }
 async function handleAuth(args) {
     if (args.includes('--help') || args.includes('-h')) {
@@ -484,11 +602,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>');
     }
@@ -513,103 +631,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) {
@@ -792,6 +843,69 @@ async function handleAccount(args) {
     }
     throw new Error(`Unknown account command: ${subcommand}`);
 }
+async function handleWallet(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`Usage:
+  dawn wallet list
+  dawn wallet use <address-or-name>
+  dawn wallet current`);
+        return;
+    }
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        throw new Error('Missing wallet command.');
+    }
+    const config = await loadConfig();
+    const moonpayConfig = getMoonpayConfig(config);
+    if (subcommand === 'list') {
+        const wallets = await loadMoonpayWallets();
+        printMoonpayWalletTable(wallets, moonpayConfig.activeWalletAddress);
+        console.log('\nUse a wallet: dawn wallet use <address-or-name>');
+        return;
+    }
+    if (subcommand === 'current') {
+        const activeAddress = moonpayConfig.activeWalletAddress;
+        if (!activeAddress) {
+            console.log('No active Moonpay wallet selected. Run: dawn wallet use <address-or-name>');
+            return;
+        }
+        const wallets = await loadMoonpayWallets();
+        const wallet = wallets.find((entry) => entry.address === activeAddress);
+        if (!wallet) {
+            throw new Error(`Active wallet ${activeAddress} is no longer present in Moonpay wallets. Run: dawn wallet list`);
+        }
+        console.log('Active Moonpay wallet');
+        console.log('=====================');
+        printKeyValue('Name', wallet.name);
+        printKeyValue('Address', wallet.address);
+        printKeyValue('Source', 'mp wallet list');
+        return;
+    }
+    if (subcommand === 'use') {
+        const selector = rest[0];
+        if (!selector) {
+            throw new Error('Usage: dawn wallet use <address-or-name>');
+        }
+        const wallets = await loadMoonpayWallets();
+        const selectedWallet = findMoonpayWalletBySelector(wallets, selector);
+        const nextConfig = {
+            ...config,
+            moonpay: {
+                ...moonpayConfig,
+                activeWalletAddress: selectedWallet.address,
+                activeWalletName: selectedWallet.name,
+            },
+        };
+        await saveConfig(nextConfig);
+        console.log('Selected Moonpay wallet');
+        console.log('=======================');
+        printKeyValue('Name', selectedWallet.name);
+        printKeyValue('Address', selectedWallet.address);
+        printKeyValue('Source', 'mp wallet list');
+        return;
+    }
+    throw new Error(`Unknown wallet command: ${subcommand}`);
+}
 function renderConversationList(conversations) {
     if (!Array.isArray(conversations) || conversations.length === 0) {
         console.log('No strategies found.');
@@ -1514,6 +1628,48 @@ async function handleSkill(args) {
     }
     throw new Error(`Unknown skill command: ${subcommand}`);
 }
+async function handleSdk(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`Usage:
+  dawn sdk doctor`);
+        return;
+    }
+    const [subcommand] = args;
+    if (!subcommand) {
+        throw new Error('Missing sdk command. Run: dawn sdk doctor');
+    }
+    if (subcommand === 'doctor') {
+        const result = await new Promise((resolve) => {
+            const child = spawn('dawnsdk', ['doctor'], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (data) => { stdout += data.toString(); });
+            child.stderr.on('data', (data) => { stderr += data.toString(); });
+            child.on('close', (code) => { resolve({ code: code ?? 1, stdout, stderr }); });
+            child.on('error', (error) => {
+                resolve({
+                    code: 1,
+                    stdout: '',
+                    stderr: error instanceof Error ? error.message : String(error),
+                });
+            });
+        });
+        if (result.code !== 0) {
+            throw new Error(`Failed to run SDK doctor. ${result.stderr.trim() || result.stdout.trim()}\nInstall locally from repo: cd py/sdk && uv tool install --from . dawnai-sdk --force`);
+        }
+        const output = result.stdout.trim();
+        if (output) {
+            console.log(output);
+        }
+        else {
+            console.log('SDK doctor completed successfully.');
+        }
+        return;
+    }
+    throw new Error(`Unknown sdk command: ${subcommand}`);
+}
 async function handleUpdate() {
     console.log('Checking for updates...');
     const result = await new Promise((resolve) => {
@@ -1559,6 +1715,10 @@ async function main() {
             await handleAccount(args);
             return;
         }
+        if (cmd === 'wallet') {
+            await handleWallet(args);
+            return;
+        }
         if (cmd === 'strategy') {
             await handleStrategy(args);
             return;
@@ -1571,6 +1731,10 @@ async function main() {
             await handleSkill(args);
             return;
         }
+        if (cmd === 'sdk') {
+            await handleSdk(args);
+            return;
+        }
         if (cmd === 'update') {
             await handleUpdate();
             return;

package/package.json

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

package/postinstall.js

@@ -3,6 +3,7 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 // Only show the banner for global installs (skip when installing as a dependency).
@@ -40,6 +41,73 @@ async function installDefaultClaudeSkill() {
   return { status: 'installed', path: destinationSkillPath };
 }
 
+function runCommand(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (data) => { stdout += data.toString(); });
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+    child.on('close', (code) => {
+      resolve({
+        code: code ?? 1,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+      });
+    });
+    child.on('error', (error) => {
+      resolve({
+        code: 1,
+        stdout: '',
+        stderr: error instanceof Error ? error.message : String(error),
+      });
+    });
+  });
+}
+
+async function installLocalSdkExecutable() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = path.dirname(currentFilePath);
+  const sdkPath = path.resolve(currentDir, '..', 'py', 'sdk');
+
+  try {
+    await fs.access(path.join(sdkPath, 'pyproject.toml'));
+  } catch {
+    return {
+      status: 'missing',
+      message:
+        'Local SDK source not found (expected ../py/sdk). Skipping SDK executable bootstrap.',
+    };
+  }
+
+  // Preferred path: uv tool install from local sdk package.
+  const uvInstall = await runCommand('uv', [
+    'tool',
+    'install',
+    '--from',
+    sdkPath,
+    'dawnai-sdk',
+    '--force',
+  ]);
+  if (uvInstall.code === 0) {
+    return {
+      status: 'installed',
+      message: `Installed Dawn SDK executable from local source: ${sdkPath}`,
+    };
+  }
+
+  return {
+    status: 'failed',
+    message: [
+      'Could not auto-install Dawn SDK executable from local source using uv.',
+      `uv error: ${uvInstall.stderr || uvInstall.stdout || 'unknown error'}`,
+      `Manual setup: cd "${sdkPath}" && uv tool install --from . dawnai-sdk --force`,
+    ].join('\n    '),
+  };
+}
+
 let skillInstallMessage = '';
 try {
   const result = await installDefaultClaudeSkill();
@@ -53,16 +121,33 @@ try {
   skillInstallMessage = `\n  Note: could not auto-install default Claude skill (${message}).\n`;
 }
 
+let sdkInstallMessage = '';
+try {
+  const result = await installLocalSdkExecutable();
+  if (result.status === 'installed') {
+    sdkInstallMessage = `\n  SDK bootstrap:\n    ${result.message}\n`;
+  } else if (result.status === 'missing') {
+    sdkInstallMessage = `\n  SDK bootstrap:\n    ${result.message}\n`;
+  } else {
+    sdkInstallMessage = `\n  SDK bootstrap warning:\n    ${result.message}\n`;
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  sdkInstallMessage = `\n  SDK bootstrap warning:\n    Unexpected error: ${message}\n`;
+}
+
 console.log(`
   @dawnai/cli installed successfully.
 
   Get started:
     dawn --version          Check installed version
     dawn auth login         Authenticate (opens browser)
+    dawn sdk doctor         Verify local SDK executable
     dawn skill install      Install all bundled Claude Code skills
     dawn --help             Show all commands
 
 ${skillInstallMessage}
+${sdkInstallMessage}
 
   Headless / CI / agent environments:
     export DAWN_JWT_TOKEN="<your-token>"