@dawnai/cli 1.1.0 → 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

@@ -6,7 +6,7 @@ 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.1.0';
+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 = [];
@@ -732,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.');
@@ -1454,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) => {
@@ -1499,6 +1715,10 @@ async function main() {
             await handleAccount(args);
             return;
         }
+        if (cmd === 'wallet') {
+            await handleWallet(args);
+            return;
+        }
         if (cmd === 'strategy') {
             await handleStrategy(args);
             return;
@@ -1511,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.1.0",
+  "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>"