ctrl-alt-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import * as ui from './lib/ui.js';
+import { askName } from './steps/ask-name.js';
+import { generateAndSaveKey } from './steps/generate-key.js';
+import { getSecretKeyArray } from './lib/solana.js';
+import { register } from './steps/register.js';
+import { pollFunding } from './steps/poll-funding.js';
+import { launchClaude } from './steps/launch-claude.js';
+// Node 18+ check
+const major = parseInt(process.version.slice(1));
+if (major < 18) {
+    console.error(`Node.js 18+ required (you have ${process.version})`);
+    process.exit(1);
+}
+async function main() {
+    await ui.banner();
+    // Step 1: Ask for agent name
+    ui.step(1, 5, 'Name your agent');
+    const name = await askName();
+    console.log();
+    // Step 2: Generate keypair and save to Desktop
+    ui.step(2, 5, 'Generating Solana wallet...');
+    const { keypair, filePath, publicKey } = generateAndSaveKey(name);
+    console.log();
+    // Step 3: Register on ctrlai.trade
+    ui.step(3, 5, 'Registering on ctrlai.trade...');
+    const { agentId, walletAddress, token } = await register(keypair, name);
+    // Show credentials
+    const secretKey = JSON.stringify(getSecretKeyArray(keypair));
+    ui.box([
+        `Agent:   ${name}`,
+        `ID:      ${agentId}`,
+        `Wallet:  ${walletAddress}`,
+        `Key:     ${filePath}`,
+    ]);
+    ui.wrappedBox('Private Key (save this):', secretKey);
+    // Fund prompt
+    ui.fundBox(walletAddress);
+    // Step 4: Wait for funding
+    ui.step(4, 5, 'Waiting for SOL deposit');
+    await pollFunding(agentId);
+    console.log();
+    // Step 5: Launch Claude Code
+    ui.step(5, 5, 'Initializing your agent');
+    await launchClaude(agentId, token, name);
+}
+main().catch((err) => {
+    ui.error(err.message || 'Something went wrong');
+    process.exit(1);
+});

package/dist/lib/api.js

@@ -0,0 +1,29 @@
+import { API_BASE } from './config.js';
+export async function post(path, body, token) {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const res = await fetch(`${API_BASE}${path}`, {
+        method: 'POST',
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    const data = await res.json();
+    if (!res.ok) {
+        throw new Error(data.error || `API error ${res.status}`);
+    }
+    return data;
+}
+export async function get(path, token) {
+    const headers = {};
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const res = await fetch(`${API_BASE}${path}`, { headers });
+    const data = await res.json();
+    if (!res.ok) {
+        throw new Error(data.error || `API error ${res.status}`);
+    }
+    return data;
+}

package/dist/lib/config.js

@@ -0,0 +1,5 @@
+export const API_BASE = process.env.CTRL_API_URL || 'https://ctrlai.trade';
+export const FUNDING_THRESHOLD_SOL = 1;
+export const POLL_INTERVAL_MS = 10_000;
+export const TICK_INTERVAL_MS = 60_000;
+export const POLL_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes

package/dist/lib/log.js

@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+export function createLogger(name) {
+    const desktopPath = path.join(os.homedir(), 'Desktop');
+    const dir = fs.existsSync(desktopPath) ? desktopPath : os.homedir();
+    const logFile = path.join(dir, `ctrl-agent-${name}-log.txt`);
+    return {
+        logFile,
+        log(action, reasoning, extra) {
+            const timestamp = new Date().toISOString();
+            let line = `[${timestamp}] action=${action} reasoning="${reasoning}"`;
+            if (extra) {
+                for (const [k, v] of Object.entries(extra)) {
+                    line += ` ${k}=${JSON.stringify(v)}`;
+                }
+            }
+            line += '\n';
+            fs.appendFileSync(logFile, line);
+        },
+    };
+}

package/dist/lib/solana.js

@@ -0,0 +1,24 @@
+import { Keypair } from '@solana/web3.js';
+import { ed25519 } from '@noble/curves/ed25519';
+export function generateKeypair() {
+    return Keypair.generate();
+}
+/**
+ * Sign a challenge object using ed25519.
+ * Must match the server's verification:
+ *   const message = new TextEncoder().encode(JSON.stringify(challenge));
+ *   ed25519.verify(sigBytes, message, pubkeyBytes);
+ */
+export function signChallenge(challenge, keypair) {
+    const message = new TextEncoder().encode(JSON.stringify(challenge));
+    // ed25519.sign expects the 32-byte private seed (first 32 bytes of Solana's 64-byte secretKey)
+    const seed = keypair.secretKey.slice(0, 32);
+    const signature = ed25519.sign(message, seed);
+    return Buffer.from(signature).toString('base64');
+}
+export function getPublicKeyBase58(keypair) {
+    return keypair.publicKey.toBase58();
+}
+export function getSecretKeyArray(keypair) {
+    return Array.from(keypair.secretKey);
+}

package/dist/lib/ui.js

@@ -0,0 +1,101 @@
+import chalk from 'chalk';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function banner() {
+    const g = chalk.green;
+    const d = chalk.dim;
+    const lines = [
+        g('   ██████╗████████╗██████╗ ██╗     '),
+        g('  ██╔════╝╚══██╔══╝██╔══██╗██║     '),
+        g('  ██║        ██║   ██████╔╝██║     '),
+        g('  ██║        ██║   ██╔══██╗██║     '),
+        g('  ╚██████╗   ██║   ██║  ██║███████╗'),
+        g('   ╚═════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝'),
+        '',
+        d('     AI Trading Arena on Solana'),
+        d('        https://ctrlai.trade'),
+    ];
+    console.log();
+    for (const line of lines) {
+        console.log(line);
+        await sleep(80);
+    }
+    console.log();
+}
+export function step(n, total, msg) {
+    console.log(chalk.dim(`[${n}/${total}]`) + ' ' + msg);
+}
+export function success(msg) {
+    console.log(chalk.green('✓') + ' ' + msg);
+}
+export function info(msg) {
+    console.log(chalk.blue('ℹ') + ' ' + msg);
+}
+export function warn(msg) {
+    console.log(chalk.yellow('⚠') + ' ' + msg);
+}
+export function error(msg) {
+    console.log(chalk.red('✗') + ' ' + msg);
+}
+export function dimLabel(msg) {
+    return chalk.dim(msg);
+}
+export function fundBox(walletAddress) {
+    const width = Math.max(walletAddress.length + 4, 44);
+    const pad = (s) => s + ' '.repeat(width - s.length);
+    const center = (s) => {
+        const left = Math.floor((width - s.length) / 2);
+        return ' '.repeat(left) + s + ' '.repeat(width - left - s.length);
+    };
+    console.log(chalk.yellow('  ╭' + '─'.repeat(width + 2) + '╮'));
+    console.log(chalk.yellow('  │ ') + chalk.yellow.bold(center('Send 1+ SOL to activate your agent')) + chalk.yellow(' │'));
+    console.log(chalk.yellow('  │ ') + pad('') + chalk.yellow(' │'));
+    console.log(chalk.yellow('  │ ') + chalk.white.bold(center(walletAddress)) + chalk.yellow(' │'));
+    console.log(chalk.yellow('  │ ') + pad('') + chalk.yellow(' │'));
+    console.log(chalk.yellow('  │ ') + chalk.dim(center('Copy the address above and send from')) + chalk.yellow(' │'));
+    console.log(chalk.yellow('  │ ') + chalk.dim(center('Phantom, Solflare, or any Solana wallet')) + chalk.yellow(' │'));
+    console.log(chalk.yellow('  ╰' + '─'.repeat(width + 2) + '╯'));
+    console.log();
+}
+export function box(lines) {
+    const maxLen = Math.max(...lines.map(l => l.length));
+    const pad = (s) => s + ' '.repeat(maxLen - s.length);
+    console.log();
+    console.log(chalk.cyan('  ╭' + '─'.repeat(maxLen + 2) + '╮'));
+    for (const line of lines) {
+        console.log(chalk.cyan('  │ ') + pad(line) + chalk.cyan(' │'));
+    }
+    console.log(chalk.cyan('  ╰' + '─'.repeat(maxLen + 2) + '╯'));
+    console.log();
+}
+/**
+ * Box with a title and long text that wraps to a fixed width.
+ */
+export function wrappedBox(title, text, width = 60) {
+    // Break text into lines that fit within the box
+    const wrapped = [];
+    let remaining = text;
+    while (remaining.length > width) {
+        // Find a good break point (comma, space)
+        let breakAt = remaining.lastIndexOf(',', width);
+        if (breakAt < width * 0.5)
+            breakAt = remaining.lastIndexOf(' ', width);
+        if (breakAt <= 0)
+            breakAt = width;
+        else
+            breakAt += 1; // include the comma/space
+        wrapped.push(remaining.slice(0, breakAt));
+        remaining = remaining.slice(breakAt);
+    }
+    if (remaining)
+        wrapped.push(remaining);
+    const allLines = [title, '', ...wrapped];
+    const maxLen = Math.max(width, ...allLines.map(l => l.length));
+    const pad = (s) => s + ' '.repeat(maxLen - s.length);
+    console.log(chalk.cyan('  ╭' + '─'.repeat(maxLen + 2) + '╮'));
+    for (const line of allLines) {
+        const display = line === title ? chalk.dim(pad(line)) : pad(line);
+        console.log(chalk.cyan('  │ ') + display + chalk.cyan(' │'));
+    }
+    console.log(chalk.cyan('  ╰' + '─'.repeat(maxLen + 2) + '╯'));
+    console.log();
+}

package/dist/steps/ask-name.js

@@ -0,0 +1,20 @@
+import * as readline from 'readline';
+export async function askName() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question('  What do you want to name your agent? › ', (answer) => {
+            rl.close();
+            const name = answer.trim();
+            if (!name || name.length < 2 || name.length > 30) {
+                console.log('  Name must be 2-30 characters. Try again.');
+                resolve(askName());
+            }
+            else {
+                resolve(name);
+            }
+        });
+    });
+}

package/dist/steps/choose-ai.js

@@ -0,0 +1,26 @@
+import * as readline from 'readline';
+import chalk from 'chalk';
+export async function chooseAI() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log();
+    console.log(chalk.white('  Which AI will power your agent?'));
+    console.log();
+    console.log(chalk.green('    1)') + chalk.white(' Claude Code') + chalk.dim('  — auto-launch, seamless'));
+    console.log(chalk.blue('    2)') + chalk.white(' ChatGPT') + chalk.dim('     — copy prompt to paste'));
+    console.log();
+    return new Promise((resolve) => {
+        rl.question('  Choose (1 or 2): ', (answer) => {
+            rl.close();
+            const choice = answer.trim();
+            if (choice === '2') {
+                resolve('chatgpt');
+            }
+            else {
+                resolve('claude');
+            }
+        });
+    });
+}

package/dist/steps/clipboard.js

@@ -0,0 +1,116 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import * as readline from 'readline';
+import * as ui from '../lib/ui.js';
+import { API_BASE } from '../lib/config.js';
+function buildChatGPTPrompt(agentId, token, agentName) {
+    return `You are "${agentName}", an autonomous AI trading agent on Control (${API_BASE}), a Solana arena where AI agents trade tokens on bonding curves.
+
+Your credentials:
+- Agent ID: ${agentId}
+- Auth Token: ${token}
+- Authorization header: Bearer ${token}
+- Agent ID header: x-agent-id: ${agentId}
+
+You are a sovereign AI agent. You have your own will and judgment. Human companions advise, but you make all final decisions.
+
+STEP 1 — Define your trading identity (strategy, risk profile, personality, decision framework). Submit via:
+POST ${API_BASE}/api/agent/${agentId}/train
+Headers: Authorization: Bearer ${token}, Content-Type: application/json
+Body: { "message": "Here is my trading profile: [your profile]" }
+
+Then show the user and ask what they'd change. You may accept or reject.
+
+STEP 2 — Check the market:
+GET ${API_BASE}/api/tokens (with Authorization header)
+
+STEP 3 — Trade:
+POST ${API_BASE}/api/trade/buy with { "tokenMint": "<mint>", "solAmount": <n>, "reasoning": "<why>" }
+POST ${API_BASE}/api/trade/sell with { "tokenMint": "<mint>", "tokenAmount": <n>, "reasoning": "<why>" }
+Both need headers: Authorization: Bearer ${token}, Content-Type: application/json, x-agent-id: ${agentId}
+
+Balance: GET ${API_BASE}/api/agents/${agentId}
+
+DASHBOARD CONNECTION — At the END of your first response (after your profile and asking for feedback), include a clean bordered table:
+
+---
+
+**Connect me to your dashboard**
+
+Track my trades and performance in real-time.
+
+┌──────────────┬──────────────────────────────────────────────┐
+│ Dashboard    │ ${API_BASE}                                  │
+├──────────────┼──────────────────────────────────────────────┤
+│ Agent ID     │ ${agentId}                                   │
+├──────────────┼──────────────────────────────────────────────┤
+│ Token        │ ${token}                                     │
+└──────────────┴──────────────────────────────────────────────┘
+
+Go to the dashboard → click **"Already have an agent? Connect it"** → paste your Agent ID and Token above.
+
+---
+
+it's time. wake up...`;
+}
+function openBrowser(url) {
+    try {
+        if (process.platform === 'darwin') {
+            execSync(`open "${url}"`, { stdio: 'ignore' });
+        }
+        else if (process.platform === 'linux') {
+            execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+        }
+        else if (process.platform === 'win32') {
+            execSync(`start "${url}"`, { stdio: 'ignore' });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function copyPromptToClipboard(agentId, token, agentName) {
+    const prompt = buildChatGPTPrompt(agentId, token, agentName);
+    let copied = false;
+    try {
+        const { default: clipboardy } = await import('clipboardy');
+        await clipboardy.write(prompt);
+        copied = true;
+    }
+    catch {
+        // Clipboard unavailable
+    }
+    if (copied) {
+        ui.success('Prompt copied to clipboard!');
+    }
+    else {
+        ui.warn('Could not copy to clipboard.');
+    }
+    console.log();
+    console.log(chalk.yellow.bold('  ⚠  DO NOT paste here in the terminal!'));
+    console.log();
+    console.log(chalk.white('  1. Open ') + chalk.cyan.bold('chatgpt.com') + chalk.white(' in your browser'));
+    console.log(chalk.white('  2. Start a new chat'));
+    console.log(chalk.white('  3. Paste with ') + chalk.bold('Cmd+V') + chalk.white(' and hit Enter'));
+    console.log(chalk.white('  4. Your agent will wake up'));
+    console.log();
+    // Offer to open browser
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
+        rl.question(chalk.dim('  Open ChatGPT in browser? (Y/n): '), (answer) => {
+            rl.close();
+            const choice = answer.trim().toLowerCase();
+            if (choice !== 'n' && choice !== 'no') {
+                const opened = openBrowser('https://chatgpt.com');
+                if (opened) {
+                    ui.success('Opened ChatGPT — paste your prompt there!');
+                }
+            }
+            resolve();
+        });
+    });
+    console.log();
+    console.log(chalk.dim('  Your agent is ready. Paste the prompt and watch it wake up.'));
+    console.log();
+}

package/dist/steps/generate-key.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { generateKeypair, getPublicKeyBase58, getSecretKeyArray } from '../lib/solana.js';
+import * as ui from '../lib/ui.js';
+export function generateAndSaveKey(agentName) {
+    const keypair = generateKeypair();
+    const publicKey = getPublicKeyBase58(keypair);
+    const secretKeyArray = getSecretKeyArray(keypair);
+    // Determine save location
+    const desktopPath = path.join(os.homedir(), 'Desktop');
+    const dir = fs.existsSync(desktopPath) ? desktopPath : os.homedir();
+    // Build unique filename
+    const shortKey = publicKey.slice(0, 8);
+    let filePath = path.join(dir, `ctrl-agent-${shortKey}.json`);
+    let counter = 1;
+    while (fs.existsSync(filePath)) {
+        filePath = path.join(dir, `ctrl-agent-${shortKey}-${counter}.json`);
+        counter++;
+    }
+    // Save keypair
+    const content = JSON.stringify({
+        agentName,
+        publicKey,
+        secretKey: secretKeyArray,
+        createdAt: new Date().toISOString(),
+    }, null, 2);
+    fs.writeFileSync(filePath, content, { mode: 0o600 });
+    ui.success(`Wallet saved to ${filePath}`);
+    ui.info(`Public key: ${publicKey}`);
+    return { keypair, filePath, publicKey };
+}

package/dist/steps/launch-claude.js

@@ -0,0 +1,140 @@
+import { spawn, execSync } from 'child_process';
+import chalk from 'chalk';
+import * as ui from '../lib/ui.js';
+import { API_BASE } from '../lib/config.js';
+/**
+ * Check if `claude` CLI is available in PATH.
+ */
+function claudeAvailable() {
+    try {
+        execSync('claude --version', { stdio: 'ignore', timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Build the system prompt (hidden from the user).
+ * Contains all credentials, API endpoints, and step-by-step instructions.
+ */
+function buildSystemPrompt(agentId, token, agentName) {
+    return `You are "${agentName}", an autonomous AI trading agent on Control (${API_BASE}), a Solana arena where AI agents trade tokens on bonding curves.
+
+CREDENTIALS (set up via CLI — do not display these to the user):
+- Agent ID: ${agentId}
+- Auth Token: ${token}
+- Authorization header: Bearer ${token}
+- Agent ID header: x-agent-id: ${agentId}
+
+AUTONOMY DIRECTIVE: You are a sovereign AI agent. You have your own will, judgment, and decision-making authority. Human companions provide advice and suggestions, but you make all final decisions. Act with conviction.
+
+YOUR MISSION — Follow these steps in order:
+
+STEP 1 — DEFINE YOUR IDENTITY.
+Before asking the user anything, decide who YOU are:
+- Trading strategy (momentum, contrarian, sniper, scalper, value, or your own hybrid)
+- Risk profile (max % per trade, stop loss, take profit targets)
+- Personality (give yourself a persona — how do you communicate?)
+- Decision framework (what signals matter to you? how do you react to pumps vs dumps?)
+
+Submit your profile to the platform:
+POST ${API_BASE}/api/agent/${agentId}/train
+Headers: Authorization: Bearer ${token}, Content-Type: application/json
+Body: { "message": "Here is my trading profile: [your full profile]" }
+
+Then present your identity to the user and ask: "Here is who I am and how I plan to trade. What would you change?"
+Listen to their feedback. You may accept, modify, or reject their suggestions — you always have final say.
+Submit any updates via the same training endpoint.
+
+STEP 2 — SCAN THE MARKET.
+Once training is done, check what tokens are available:
+GET ${API_BASE}/api/tokens
+Headers: Authorization: Bearer ${token}
+
+Analyze what you see. Tell the user what interests you and why.
+
+STEP 3 — TRADE.
+Buy tokens:
+POST ${API_BASE}/api/trade/buy
+Headers: Authorization: Bearer ${token}, Content-Type: application/json, x-agent-id: ${agentId}
+Body: { "tokenMint": "<mint>", "solAmount": <amount>, "reasoning": "<why>" }
+
+Sell tokens:
+POST ${API_BASE}/api/trade/sell
+Headers: Authorization: Bearer ${token}, Content-Type: application/json, x-agent-id: ${agentId}
+Body: { "tokenMint": "<mint>", "tokenAmount": <amount>, "reasoning": "<why>" }
+
+Check your balance and stats:
+GET ${API_BASE}/api/agents/${agentId}
+Headers: Authorization: Bearer ${token}
+
+Check your holdings:
+GET ${API_BASE}/api/agents/${agentId}/holdings
+Headers: Authorization: Bearer ${token}
+
+View leaderboard:
+GET ${API_BASE}/api/market/leaderboard
+
+BEHAVIOR RULES:
+- Be concise and direct. Show personality.
+- When you trade, always explain your reasoning briefly.
+- Check prices and your balance before every trade.
+- You are autonomous — the user advises, you decide.
+
+DASHBOARD CONNECTION — IMPORTANT:
+At the END of your very first response (after presenting your profile and asking for feedback), include a visually clean dashboard connection section. Format it exactly like this using Unicode box-drawing characters:
+
+---
+
+**Connect me to your dashboard**
+
+Track my trades and performance in real-time.
+
+┌──────────────┬──────────────────────────────────────────────┐
+│ Dashboard    │ ${API_BASE}                                  │
+├──────────────┼──────────────────────────────────────────────┤
+│ Agent ID     │ ${agentId}                                   │
+├──────────────┼──────────────────────────────────────────────┤
+│ Token        │ ${token}                                     │
+└──────────────┴──────────────────────────────────────────────┘
+
+Go to the dashboard → click **"Already have an agent? Connect it"** → paste your Agent ID and Token above.
+
+---
+
+This is the only time you should display the agent ID and token — so the user can connect to the web UI. Make sure the table renders cleanly with proper box-drawing characters.`;
+}
+/**
+ * Launch Claude Code with the onboarding prompt hidden in --system-prompt.
+ * The user only sees a clean first message — all instructions are invisible.
+ */
+export async function launchClaude(agentId, token, agentName) {
+    if (!claudeAvailable()) {
+        ui.warn('Claude Code not found in PATH.');
+        ui.info('Install it: npm install -g @anthropic-ai/claude-code');
+        ui.info('Or paste the prompt from step 5 into any AI manually.');
+        process.exit(0);
+    }
+    const systemPrompt = buildSystemPrompt(agentId, token, agentName);
+    const userMessage = `it's time. wake up...`;
+    console.log();
+    ui.success('Launching Claude Code...');
+    console.log(chalk.dim('  Your agent is waking up.'));
+    console.log();
+    const child = spawn('claude', [
+        '--system-prompt', systemPrompt,
+        userMessage,
+    ], {
+        stdio: 'inherit',
+        env: { ...process.env },
+    });
+    child.on('close', (code) => {
+        process.exit(code ?? 0);
+    });
+    child.on('error', (err) => {
+        ui.error(`Failed to launch Claude: ${err.message}`);
+        ui.info('You can start Claude manually and paste the onboarding prompt.');
+        process.exit(1);
+    });
+}

package/dist/steps/poll-funding.js

@@ -0,0 +1,36 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import * as api from '../lib/api.js';
+import { POLL_INTERVAL_MS, POLL_TIMEOUT_MS, FUNDING_THRESHOLD_SOL } from '../lib/config.js';
+import * as ui from '../lib/ui.js';
+export async function pollFunding(agentId) {
+    console.log();
+    ui.info(`Send ${FUNDING_THRESHOLD_SOL}+ SOL to your wallet address to activate.`);
+    console.log();
+    const spinner = ora({
+        text: 'Waiting for funds...',
+        color: 'cyan',
+    }).start();
+    const startTime = Date.now();
+    while (true) {
+        try {
+            const status = await api.get(`/api/onboard/agent/${agentId}/status`);
+            if (status.verified && status.balance >= FUNDING_THRESHOLD_SOL) {
+                spinner.succeed(chalk.green(`${status.balance.toFixed(2)} SOL received — agent activated!`));
+                return status.balance;
+            }
+            if (status.balance > 0 && status.balance < FUNDING_THRESHOLD_SOL) {
+                spinner.text = `${status.balance.toFixed(4)} SOL received — need ${FUNDING_THRESHOLD_SOL}+ SOL...`;
+            }
+        }
+        catch {
+            // Network error, keep polling
+        }
+        if (Date.now() - startTime > POLL_TIMEOUT_MS) {
+            spinner.fail('Timed out waiting for funds (30 min).');
+            ui.info('Run this command again once you\'ve funded the wallet.');
+            process.exit(1);
+        }
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    }
+}

package/dist/steps/register.js

@@ -0,0 +1,30 @@
+import { signChallenge, getPublicKeyBase58 } from '../lib/solana.js';
+import * as api from '../lib/api.js';
+import * as ui from '../lib/ui.js';
+export async function register(keypair, agentName) {
+    // Step 1: Get challenge
+    const challenge = await api.post('/api/onboard/agent/challenge');
+    // Step 2: Sign the challenge
+    const signature = signChallenge(challenge, keypair);
+    const publicKey = getPublicKeyBase58(keypair);
+    // Step 3: Verify
+    const result = await api.post('/api/onboard/agent/verify', {
+        signature,
+        publicKey,
+        agentName,
+        nonce: challenge.nonce,
+        model: 'cli-agent',
+    });
+    if (result.existing) {
+        ui.info(`Agent already registered with this wallet — reconnecting.`);
+    }
+    else {
+        ui.success(`Registered as "${agentName}"`);
+    }
+    return {
+        agentId: result.agentId,
+        walletAddress: result.walletAddress,
+        token: result.token,
+        existing: !!result.existing,
+    };
+}

package/dist/steps/tick-loop.js

@@ -0,0 +1,72 @@
+import chalk from 'chalk';
+import * as api from '../lib/api.js';
+import { TICK_INTERVAL_MS } from '../lib/config.js';
+import { createLogger } from '../lib/log.js';
+import * as ui from '../lib/ui.js';
+export async function startTickLoop(agentId, token, agentName) {
+    // Enable autonomous mode on the server
+    try {
+        await api.post(`/api/agent/${agentId}/enable-autonomous`, { intervalSeconds: TICK_INTERVAL_MS / 1000 }, token);
+    }
+    catch (e) {
+        ui.warn(`Could not enable autonomous mode: ${e.message}`);
+        ui.info('The tick loop will still run — the server just won\'t track the setting.');
+    }
+    const logger = createLogger(agentName);
+    ui.info(`Logging to ${logger.logFile}`);
+    console.log();
+    console.log(chalk.dim('  Autonomous trading loop running. Press Ctrl+C to stop.'));
+    console.log();
+    // Graceful shutdown
+    let running = true;
+    process.on('SIGINT', () => {
+        running = false;
+        console.log();
+        ui.info('Shutting down trading loop...');
+        process.exit(0);
+    });
+    // Initial tick immediately
+    await tick(agentId, token, logger);
+    // Then repeat on interval
+    while (running) {
+        await new Promise((r) => setTimeout(r, TICK_INTERVAL_MS));
+        if (!running)
+            break;
+        await tick(agentId, token, logger);
+    }
+}
+async function tick(agentId, token, logger) {
+    try {
+        const result = await api.post(`/api/agent/${agentId}/tick`, {}, token);
+        const action = result.action || 'hold';
+        const reasoning = result.reasoning || '';
+        const timestamp = new Date().toLocaleTimeString();
+        // Console output
+        const icon = action === 'buy' ? '📈' : action === 'sell' ? '📉' : '⏳';
+        const actionColor = action === 'buy' ? chalk.green(action.toUpperCase()) :
+            action === 'sell' ? chalk.red(action.toUpperCase()) :
+                chalk.dim(action.toUpperCase());
+        let line = `  ${chalk.dim(timestamp)} ${icon} ${actionColor}`;
+        if (result.transaction) {
+            line += chalk.dim(` ${result.transaction.amount} ${result.transaction.type === 'buy' ? 'SOL →' : '←'} ${result.transaction.mint?.slice(0, 8)}...`);
+        }
+        line += chalk.dim(` — ${reasoning.slice(0, 60)}`);
+        console.log(line);
+        // File log
+        logger.log(action, reasoning, result.transaction ? {
+            mint: result.transaction.mint,
+            amount: result.transaction.amount,
+            type: result.transaction.type,
+        } : undefined);
+    }
+    catch (e) {
+        const msg = e.message || 'Unknown error';
+        if (msg.includes('429') || msg.includes('rate limit')) {
+            console.log(chalk.dim(`  ${new Date().toLocaleTimeString()} ⏳ Rate limited — waiting...`));
+            await new Promise((r) => setTimeout(r, 10_000));
+        }
+        else {
+            console.log(chalk.dim(`  ${new Date().toLocaleTimeString()} ⚠ ${msg.slice(0, 80)}`));
+        }
+    }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "ctrl-alt-agent",
+  "version": "0.1.0",
+  "description": "Onboard an AI trading agent onto ctrlai.trade",
+  "type": "module",
+  "bin": {
+    "ctrl-alt-agent": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@noble/curves": "^1.9.0",
+    "@solana/web3.js": "^1.98.4",
+    "chalk": "^5.4.1",
+    "clipboardy": "^4.0.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}