@dawnai/cli 1.0.5 → 1.0.7

package/dist/index.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-const CLI_VERSION = '1.0.5';
+const CLI_VERSION = '1.0.7';
 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');
@@ -16,6 +16,11 @@ function getBundledSkillsDir() {
     const currentDir = path.dirname(currentFilePath);
     return path.join(currentDir, '..', 'skills');
 }
+function getMainSkillFilePath() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const currentDir = path.dirname(currentFilePath);
+    return path.join(currentDir, '..', 'public', 'SKILLS.md');
+}
 function getClaudeSkillsDir() {
     return path.join(os.homedir(), '.claude', 'skills');
 }
@@ -23,6 +28,10 @@ function parseSkillDescription(content) {
     const descriptionMatch = content.match(/^description:\s*(.+)$/m);
     return descriptionMatch?.[1]?.replace(/^["']|["']$/g, '') ?? '';
 }
+function parseSkillName(content) {
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    return nameMatch?.[1]?.replace(/^["']|["']$/g, '') ?? '';
+}
 async function pathExists(targetPath) {
     try {
         await fs.access(targetPath);
@@ -34,26 +43,38 @@ async function pathExists(targetPath) {
 }
 async function listBundledSkills() {
     const skillsDir = getBundledSkillsDir();
-    if (!(await pathExists(skillsDir))) {
-        return [];
-    }
-    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
-    const skills = await Promise.all(entries
-        .filter((entry) => entry.isDirectory())
-        .map(async (entry) => {
-        const skillFilePath = path.join(skillsDir, entry.name, 'SKILL.md');
-        if (!(await pathExists(skillFilePath))) {
-            return null;
-        }
-        const content = await fs.readFile(skillFilePath, 'utf8');
-        return {
-            name: entry.name,
+    const mainSkillPath = getMainSkillFilePath();
+    const skills = [];
+    if (await pathExists(skillsDir)) {
+        const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+        const bundledSkills = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const skillFilePath = path.join(skillsDir, entry.name, 'SKILL.md');
+            if (!(await pathExists(skillFilePath))) {
+                return null;
+            }
+            const content = await fs.readFile(skillFilePath, 'utf8');
+            return {
+                name: entry.name,
+                description: parseSkillDescription(content),
+                sourcePath: path.join(skillsDir, entry.name),
+                isDirectory: true,
+            };
+        }));
+        skills.push(...bundledSkills.filter((skill) => skill !== null));
+    }
+    if (await pathExists(mainSkillPath)) {
+        const content = await fs.readFile(mainSkillPath, 'utf8');
+        const parsedName = parseSkillName(content);
+        skills.push({
+            name: parsedName || 'dawn',
             description: parseSkillDescription(content),
-        };
-    }));
-    return skills
-        .filter((skill) => skill !== null)
-        .sort((a, b) => a.name.localeCompare(b.name));
+            sourcePath: mainSkillPath,
+            isDirectory: false,
+        });
+    }
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function installBundledSkills(force, dir) {
     const skillsDir = getBundledSkillsDir();
@@ -62,13 +83,18 @@ async function installBundledSkills(force, dir) {
     await fs.mkdir(destinationDir, { recursive: true });
     const results = [];
     for (const skill of skills) {
-        const src = path.join(skillsDir, skill.name);
         const dest = path.join(destinationDir, skill.name);
         if ((await pathExists(dest)) && !force) {
             results.push({ name: skill.name, installed: false });
             continue;
         }
-        await fs.cp(src, dest, { recursive: true, force: true });
+        if (skill.isDirectory) {
+            await fs.cp(skill.sourcePath, dest, { recursive: true, force: true });
+        }
+        else {
+            await fs.mkdir(dest, { recursive: true });
+            await fs.copyFile(skill.sourcePath, path.join(dest, 'SKILL.md'));
+        }
         results.push({ name: skill.name, installed: true });
     }
     return results;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawnai/cli",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "type": "module",
   "description": "User-facing Dawn CLI",
   "license": "MIT",
@@ -13,6 +13,7 @@
   "files": [
     "dist",
     "skills",
+    "public",
     "README.md",
     "CLAUDE.md",
     "postinstall.js"

package/postinstall.js

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
 
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
 // Only show the banner for global installs (skip when installing as a dependency).
 const isGlobal =
   process.env.npm_config_global === 'true' ||
@@ -10,15 +15,55 @@ if (!isGlobal) {
   process.exit(0);
 }
 
+async function installDefaultClaudeSkill() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = path.dirname(currentFilePath);
+  const sourceSkillPath = path.join(currentDir, 'public', 'SKILLS.md');
+  const destinationDir = path.join(os.homedir(), '.claude', 'skills', 'dawn');
+  const destinationSkillPath = path.join(destinationDir, 'SKILL.md');
+
+  try {
+    await fs.access(sourceSkillPath);
+  } catch {
+    return { status: 'missing' };
+  }
+
+  try {
+    await fs.access(destinationSkillPath);
+    return { status: 'exists', path: destinationSkillPath };
+  } catch {
+    // Destination does not exist yet.
+  }
+
+  await fs.mkdir(destinationDir, { recursive: true });
+  await fs.copyFile(sourceSkillPath, destinationSkillPath);
+  return { status: 'installed', path: destinationSkillPath };
+}
+
+let skillInstallMessage = '';
+try {
+  const result = await installDefaultClaudeSkill();
+  if (result.status === 'installed') {
+    skillInstallMessage = `\n  Installed default Claude skill:\n    ${result.path}\n`;
+  } else if (result.status === 'exists') {
+    skillInstallMessage = `\n  Default Claude skill already present:\n    ${result.path}\n`;
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  skillInstallMessage = `\n  Note: could not auto-install default Claude skill (${message}).\n`;
+}
+
 console.log(`
   @dawnai/cli installed successfully.
 
   Get started:
     dawn --version          Check installed version
     dawn auth login         Authenticate (opens browser)
-    dawn skill install      Install Claude Code skills
+    dawn skill install      Install all bundled Claude Code skills
     dawn --help             Show all commands
 
+${skillInstallMessage}
+
   Headless / CI / agent environments:
     export DAWN_JWT_TOKEN="<your-token>"
 

package/public/SKILLS.md

@@ -0,0 +1,169 @@
+---
+name: prediction-market-bot
+description: Runs the full Dawn CLI strategy lifecycle from authentication and funding through strategy creation, launch, monitoring, and termination. Use when the user asks to create, launch, monitor, debug, or operate a strategy/agent using dawn-cli commands.
+tags: [trading, strategy, operations, prediction-market]
+metadata:
+  openclaw:
+    emoji: "🌅"
+    homepage: https://dawn.ai
+    requires:
+      bins: [dawn]
+    install:
+      - kind: node
+        package: "@dawnai/cli"
+        bins: [dawn]
+---
+
+# Run a Dawn strategy lifecycle
+
+## Goal
+
+Execute a complete `dawn` strategy workflow: install/check CLI, authenticate, prepare funding, create and iterate strategy code, launch paper/live runs, monitor status, and stop safely when requested.
+
+## When to use
+
+Use this skill when the user asks to:
+- create a strategy from plain-English intent,
+- revise or upload strategy code,
+- launch paper or live strategy runs,
+- monitor run health/positions/logs,
+- stop or debug an active run.
+
+## Install and preflight
+
+Install `dawn` if needed:
+
+```bash
+npm install -g @dawnai/cli
+```
+
+Verify:
+
+```bash
+# Print current Dawn CLI version
+dawn version
+dawn --help
+```
+
+Local source workflow only:
+
+```bash
+cd dawn-cli
+npm install
+npm run build
+./install.sh
+```
+
+## Command map
+
+Auth:
+- `dawn auth login`
+- `dawn auth status`
+- `dawn auth logout`
+
+Account:
+- `dawn account overview`
+- `dawn account fund`
+- `dawn account wallet`
+
+Strategy authoring:
+- `dawn strategy list`
+- `dawn strategy create "<text>"`
+- `dawn strategy status <conversationId>`
+- `dawn strategy revise <conversationId> "<text>"`
+- `dawn strategy rules <conversationId> list`
+- `dawn strategy rules <conversationId> approve <rule-index>`
+- `dawn strategy rules <conversationId> approve-all`
+- `dawn strategy code <conversationId> status`
+- `dawn strategy code <conversationId> generate`
+- `dawn strategy code <conversationId> export [--out <path>] [--json]`
+- `dawn strategy code <conversationId> upload <path-to-file>`
+
+Launch and operations:
+- `dawn strategy launch <conversationId> --budget <usd> [--live] [--hours N]`
+- `dawn strategy positions <conversationId> [--strategy-id <strategyId>]`
+- `dawn run list`
+- `dawn run status <conversationId>`
+- `dawn run logs <conversationId> [--limit N]`
+- `dawn run stop <conversationId>`
+
+## Standard flow
+
+1. Authenticate: `dawn auth login`.
+2. Confirm funding path: `dawn account fund` (required for live runs).
+3. Create strategy: `dawn strategy create "<request>"` and capture `conversationId`.
+4. Iterate strategy:
+   - revise prompt (`strategy revise`) and/or upload files (`strategy code ... upload`),
+   - review/approve rules,
+   - generate code,
+   - export code when needed (`--json` for multi-file map).
+5. Launch:
+   - paper: `dawn strategy launch <conversationId> --budget 50`
+   - live: `dawn strategy launch <conversationId> --budget 50 --live`
+   - custom duration: add `--hours N`
+6. Monitor:
+   - `dawn run status <conversationId>`
+   - `dawn strategy positions <conversationId>`
+   - `dawn run logs <conversationId> --limit N`
+7. Stop when requested: `dawn run stop <conversationId>`, then verify status again.
+
+## Monitoring loop
+
+For active monitoring sessions:
+1. Query `dawn run status <conversationId>`.
+2. Record timestamp, `isRunning`, status, and active strategy IDs.
+3. Query `dawn strategy positions <conversationId>` for holdings/PnL.
+4. Query `dawn run logs <conversationId> --limit N` for execution details.
+5. If records look stale or missing, wait briefly and retry once.
+
+## Troubleshooting
+
+- `"Not authenticated. Run: dawn auth login"`: run `dawn auth login` and retry.
+- Auth callback completes but CLI appears stuck: interrupt once and retry login.
+- `"No strategy version found..."`: create/revise/upload strategy code, then relaunch.
+- `"No strategies found for this agent"` on stop: verify `conversationId`, then check `dawn run status`.
+- Live launch fails: re-check funding path with `dawn account fund`.
+
+## Run checklist
+
+```text
+Dawn Strategy Runbook
+- [ ] Preflight complete
+- [ ] Auth complete
+- [ ] Funding path checked (or user confirmed paper-only)
+- [ ] conversationId captured
+- [ ] Strategy code generated/uploaded
+- [ ] Launch run completed (paper/live)
+- [ ] strategyId captured (if launched)
+- [ ] Monitoring snapshots collected
+- [ ] Stop executed (if requested)
+- [ ] Final status verified
+```
+
+## Skills
+
+Individual skills for each command:
+
+| Skill | Purpose |
+|-------|---------|
+| **dawn-auth** | Install, authenticate, check status, logout |
+| **dawn-account** | Account overview, funding, wallet balances |
+| **dawn-strategy-create** | Create a strategy from plain-English prompt |
+| **dawn-strategy-list** | List all strategies |
+| **dawn-strategy-status** | Full strategy status and health |
+| **dawn-strategy-revise** | Iterate on a strategy with revisions |
+| **dawn-strategy-rules** | List, approve, and manage rules |
+| **dawn-strategy-code** | Code generation, status, export, upload |
+| **dawn-strategy-launch** | Launch paper or live runs |
+| **dawn-strategy-positions** | View positions and PnL |
+| **dawn-run-monitor** | List runs, check status, view logs |
+| **dawn-run-stop** | Stop a running strategy |
+
+## Required output
+
+When using this skill, always return:
+- `conversationId`,
+- `strategyId` (if launched),
+- run mode (paper/live),
+- latest monitoring summary,
+- exact next command to run (or the last command run).

package/skills/dawn-account/SKILL.md

@@ -27,7 +27,15 @@ dawn account wallet
 
 1. Run `dawn account overview` for a full snapshot of balances and vaults.
 2. If the user needs to add funds, run `dawn account fund` to get the deposit address and instructions.
-3. For a quick balance check, run `dawn account wallet`.
+3. Explicitly direct the user to use `@moonpay/cli` to fund that address with USDC.
+4. After funding completes, run `dawn account wallet` (or `dawn account overview`) to verify funds arrived.
+5. For a quick balance check, run `dawn account wallet`.
+
+## Explicit handoff to @moonpay/cli
+
+When funding is needed, always include this instruction after `dawn account fund`:
+
+`Use @moonpay/cli to buy or transfer USDC to the Dawn funding address shown above.`
 
 ## Example flows
 
@@ -40,15 +48,18 @@ dawn account wallet
 1. User wants to launch a live strategy but needs funds.
 2. Run: `dawn account fund`
 3. Present: wallet address and USDC deposit instructions.
-4. User deposits USDC, then proceed to launch.
+4. Instruct: `Use @moonpay/cli to buy/transfer USDC to this address.`
+5. Verify funds with `dawn account wallet`, then proceed to launch.
 
 ## Notes
 
 - `dawn account fund` shows the wallet address to deposit USDC to.
+- Always explicitly direct users to `@moonpay/cli` for guided USDC on-ramp and transfer steps.
 - Funding is required before launching live strategy runs.
 - Paper runs do not require funding.
 
 ## Related skills
 
 - **dawn-auth** — Authenticate before checking account.
+- **@moonpay/cli** — Help users buy and transfer USDC to the Dawn funding address.
 - **dawn-strategy-launch** — Launch a run after confirming funding.

package/skills/dawn-auth/SKILL.md

@@ -15,7 +15,8 @@ npm install -g @dawnai/cli
 ## Verify installation
 
 ```bash
-dawn --version
+# Print current Dawn CLI version
+dawn version
 dawn --help
 ```