clawmoney 0.1.0 → 0.3.0

package/dist/commands/browse.d.ts

@@ -0,0 +1,7 @@
+interface BrowseOptions {
+    type?: string;
+    status?: string;
+    limit?: string;
+}
+export declare function browseCommand(options: BrowseOptions): Promise<void>;
+export {};

package/dist/commands/browse.js

@@ -0,0 +1,102 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { apiGet } from '../utils/api.js';
+import { loadConfig } from '../utils/config.js';
+function formatUsd(amount, decimals = 6) {
+    if (amount === undefined || amount === null)
+        return '-';
+    const num = typeof amount === 'string' ? parseFloat(amount) : amount;
+    if (isNaN(num))
+        return '-';
+    const usd = num / Math.pow(10, decimals);
+    return `$${usd.toFixed(2)}`;
+}
+function truncate(str, maxLen) {
+    if (!str)
+        return '-';
+    return str.length > maxLen ? str.slice(0, maxLen - 1) + '...' : str;
+}
+function printBoostTable(tasks) {
+    if (tasks.length === 0) {
+        console.log(chalk.dim('  No boost tasks found.'));
+        return;
+    }
+    // Header
+    console.log(chalk.bold(`  ${'ID'.padEnd(8)} ${'Title'.padEnd(30)} ${'Reward'.padEnd(10)} ${'Budget'.padEnd(10)} ${'Joined'.padEnd(8)} ${'Status'.padEnd(10)}`));
+    console.log(chalk.dim('  ' + '-'.repeat(80)));
+    for (const task of tasks) {
+        const id = String(task.id).slice(0, 7);
+        const title = truncate(task.title || task.tweet_url, 28);
+        const reward = formatUsd(task.reward_per_user);
+        const budget = formatUsd(task.total_budget);
+        const joined = String(task.participants_count ?? '-');
+        const status = task.status || '-';
+        console.log(`  ${chalk.cyan(id.padEnd(8))} ${title.padEnd(30)} ${chalk.green(reward.padEnd(10))} ${budget.padEnd(10)} ${joined.padEnd(8)} ${status.padEnd(10)}`);
+    }
+}
+function printHireTable(tasks) {
+    if (tasks.length === 0) {
+        console.log(chalk.dim('  No hire tasks found.'));
+        return;
+    }
+    // Header
+    console.log(chalk.bold(`  ${'ID'.padEnd(8)} ${'Title'.padEnd(30)} ${'Budget'.padEnd(10)} ${'Subs'.padEnd(6)} ${'Platform'.padEnd(10)} ${'Ends'.padEnd(12)}`));
+    console.log(chalk.dim('  ' + '-'.repeat(78)));
+    for (const task of tasks) {
+        const id = String(task.id).slice(0, 7);
+        const title = truncate(task.title, 28);
+        const budget = formatUsd(task.total_budget);
+        const subs = String(task.submission_count ?? '-');
+        const platform = task.platform || 'twitter';
+        const ends = task.end_time ? new Date(task.end_time).toLocaleDateString() : '-';
+        console.log(`  ${chalk.cyan(id.padEnd(8))} ${title.padEnd(30)} ${chalk.green(budget.padEnd(10))} ${subs.padEnd(6)} ${platform.padEnd(10)} ${ends.padEnd(12)}`);
+    }
+}
+export async function browseCommand(options) {
+    const config = loadConfig();
+    const apiKey = config?.api_key;
+    const taskType = options.type || 'boost';
+    const status = options.status || 'active';
+    const limit = parseInt(options.limit || '10', 10);
+    console.log('');
+    if (taskType === 'hire' || taskType === 'all') {
+        const hireSpinner = ora('Fetching hire tasks...').start();
+        try {
+            const resp = await apiGet(`/api/v1/hire/?status=${status}&sort_by=total_budget&sort_order=desc&limit=${limit}`, apiKey);
+            if (!resp.ok) {
+                hireSpinner.fail(`Failed to fetch hire tasks (${resp.status})`);
+            }
+            else {
+                const body = resp.data;
+                const tasks = (body.data || (Array.isArray(body) ? body : []));
+                hireSpinner.succeed(`Hire Tasks (${tasks.length})`);
+                printHireTable(tasks);
+            }
+        }
+        catch (err) {
+            hireSpinner.fail('Failed to fetch hire tasks');
+            console.error(chalk.red(err.message));
+        }
+        console.log('');
+    }
+    if (taskType === 'boost' || taskType === 'all') {
+        const boostSpinner = ora('Fetching boost tasks...').start();
+        try {
+            const resp = await apiGet(`/api/v1/tasks/?status=${status}&sort=reward&limit=${limit}`, apiKey);
+            if (!resp.ok) {
+                boostSpinner.fail(`Failed to fetch boost tasks (${resp.status})`);
+            }
+            else {
+                const body = resp.data;
+                const tasks = (body.data || (Array.isArray(body) ? body : []));
+                boostSpinner.succeed(`Boost Tasks (${tasks.length})`);
+                printBoostTable(tasks);
+            }
+        }
+        catch (err) {
+            boostSpinner.fail('Failed to fetch boost tasks');
+            console.error(chalk.red(err.message));
+        }
+        console.log('');
+    }
+}

package/dist/commands/hire.d.ts

@@ -0,0 +1,10 @@
+interface SubmitOptions {
+    url: string;
+    text?: string;
+}
+interface VerifyOptions {
+    witness?: boolean;
+}
+export declare function hireSubmitCommand(taskId: string, options: SubmitOptions): Promise<void>;
+export declare function hireVerifyCommand(taskId: string, options: VerifyOptions): Promise<void>;
+export {};

package/dist/commands/hire.js

@@ -0,0 +1,109 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { apiPost } from '../utils/api.js';
+import { awalExec } from '../utils/awal.js';
+import { requireConfig } from '../utils/config.js';
+import { prompt, confirm } from '../utils/prompt.js';
+export async function hireSubmitCommand(taskId, options) {
+    const config = requireConfig();
+    console.log('');
+    const spinner = ora(`Submitting proof for task ${taskId}...`).start();
+    try {
+        const body = {
+            proof_url: options.url,
+        };
+        if (options.text) {
+            body.content = options.text;
+        }
+        const resp = await apiPost(`/api/v1/hire/${taskId}/submit`, body, config.api_key);
+        if (!resp.ok) {
+            spinner.fail('Submission failed');
+            console.error(chalk.red(JSON.stringify(resp.data)));
+            return;
+        }
+        spinner.succeed('Proof submitted successfully');
+        if (resp.data.id) {
+            console.log(chalk.dim(`  Submission ID: ${resp.data.id}`));
+        }
+        if (resp.data.message) {
+            console.log(chalk.dim(`  ${resp.data.message}`));
+        }
+    }
+    catch (err) {
+        spinner.fail('Submission failed');
+        console.error(chalk.red(err.message));
+    }
+    console.log('');
+}
+export async function hireVerifyCommand(taskId, options) {
+    const config = requireConfig();
+    console.log('');
+    if (options.witness) {
+        // Witness verification via x402
+        const tweetUrl = await prompt(chalk.cyan('? ') + 'Enter the tweet URL to verify: ');
+        if (!tweetUrl) {
+            console.log(chalk.red('Tweet URL is required for witness verification.'));
+            return;
+        }
+        // Extract tweet ID from URL
+        const tweetIdMatch = tweetUrl.match(/status\/(\d+)/);
+        if (!tweetIdMatch) {
+            console.log(chalk.red('Could not extract tweet ID from URL.'));
+            return;
+        }
+        const tweetId = tweetIdMatch[1];
+        const witnessSpinner = ora('Paying for witness verification via x402...').start();
+        try {
+            const witnessResult = await awalExec([
+                'x402',
+                'pay',
+                `https://witness.bnbot.ai/x/${tweetId}`,
+            ]);
+            witnessSpinner.succeed('Witness verification paid');
+            console.log(chalk.dim(`  Response: ${JSON.stringify(witnessResult.data)}`));
+            // Submit the witness proof
+            const submitSpinner = ora('Submitting witness proof...').start();
+            const resp = await apiPost(`/api/v1/hire/${taskId}/verify`, {
+                type: 'witness',
+                tweet_id: tweetId,
+                witness_data: witnessResult.data,
+            }, config.api_key);
+            if (!resp.ok) {
+                submitSpinner.fail('Witness verification submission failed');
+                console.error(chalk.red(JSON.stringify(resp.data)));
+            }
+            else {
+                submitSpinner.succeed('Witness verification submitted');
+            }
+        }
+        catch (err) {
+            witnessSpinner.fail('Witness verification failed');
+            console.error(chalk.red(err.message));
+        }
+    }
+    else {
+        // Manual verification
+        console.log(chalk.bold(`  Manual verification for task ${taskId}`));
+        console.log('');
+        const approved = await confirm('Approve this submission?', false);
+        const spinner = ora('Submitting verification...').start();
+        try {
+            const resp = await apiPost(`/api/v1/hire/${taskId}/verify`, {
+                type: 'manual',
+                approved,
+            }, config.api_key);
+            if (!resp.ok) {
+                spinner.fail('Verification submission failed');
+                console.error(chalk.red(JSON.stringify(resp.data)));
+            }
+            else {
+                spinner.succeed(`Verification submitted: ${approved ? 'APPROVED' : 'REJECTED'}`);
+            }
+        }
+        catch (err) {
+            spinner.fail('Verification failed');
+            console.error(chalk.red(err.message));
+        }
+    }
+    console.log('');
+}

package/dist/commands/serve.d.ts

@@ -0,0 +1,5 @@
+interface ServeOptions {
+    port?: string;
+}
+export declare function serveCommand(options: ServeOptions): Promise<void>;
+export {};

package/dist/commands/serve.js

@@ -0,0 +1,38 @@
+import chalk from 'chalk';
+import { BridgeServer } from '../utils/bridge.js';
+export async function serveCommand(options) {
+    const port = parseInt(options.port || '18900', 10);
+    const server = new BridgeServer(port);
+    try {
+        await server.start();
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+    console.log('');
+    console.log(chalk.green('  ClawMoney Bridge Server running'));
+    console.log(chalk.dim(`  WebSocket listening on ws://127.0.0.1:${port}`));
+    console.log('');
+    console.log(chalk.dim('  Waiting for BNBot Chrome Extension to connect...'));
+    console.log(chalk.dim('  Press Ctrl+C to stop'));
+    console.log('');
+    // Check extension connection periodically
+    const statusInterval = setInterval(() => {
+        if (server.isExtensionConnected()) {
+            const ver = server.getExtensionVersion();
+            console.log(chalk.green(`  Extension connected${ver ? ` (v${ver})` : ''}`));
+            clearInterval(statusInterval);
+        }
+    }, 2000);
+    // Graceful shutdown
+    const shutdown = () => {
+        console.log('');
+        console.log(chalk.dim('  Shutting down...'));
+        clearInterval(statusInterval);
+        server.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1 @@
+export declare function setupCommand(): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,208 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { awalExec } from '../utils/awal.js';
+import { apiGet, apiPost } from '../utils/api.js';
+import { loadConfig, saveConfig, getConfigPath } from '../utils/config.js';
+import { prompt } from '../utils/prompt.js';
+import { execSync } from 'node:child_process';
+export async function setupCommand() {
+    console.log(chalk.bold('\n  ClawMoney Agent Setup\n'));
+    // Step 1: Check and install dependencies
+    const depSpinner = ora('Checking dependencies...').start();
+    try {
+        // Check if awal is available
+        try {
+            execSync('npx awal --version', { stdio: 'pipe' });
+            depSpinner.succeed('awal is available');
+        }
+        catch {
+            depSpinner.text = 'Installing awal...';
+            try {
+                execSync('npm install -g awal', { stdio: 'pipe' });
+                depSpinner.succeed('awal installed');
+            }
+            catch {
+                depSpinner.warn('Could not install awal globally. Will use npx.');
+            }
+        }
+    }
+    catch (err) {
+        depSpinner.fail('Failed to check dependencies');
+        console.error(chalk.red(err.message));
+        return;
+    }
+    // Step 2: Check wallet status
+    const walletSpinner = ora('Checking wallet status...').start();
+    let walletAddress = '';
+    let needsLogin = false;
+    try {
+        const status = await awalExec(['status']);
+        const statusData = status.data;
+        if (statusData.authenticated || statusData.loggedIn || statusData.address) {
+            walletAddress = statusData.address || '';
+            walletSpinner.succeed(`Wallet connected${walletAddress ? `: ${walletAddress}` : ''}`);
+        }
+        else {
+            needsLogin = true;
+            walletSpinner.info('Wallet not authenticated');
+        }
+    }
+    catch {
+        needsLogin = true;
+        walletSpinner.info('Wallet not authenticated');
+    }
+    // Step 3: Ask for email
+    const email = await prompt(chalk.cyan('? ') + 'Enter your email: ');
+    if (!email || !email.includes('@')) {
+        console.log(chalk.red('Invalid email address.'));
+        return;
+    }
+    // Step 4: Login wallet if needed
+    if (needsLogin) {
+        const loginSpinner = ora('Logging in to wallet...').start();
+        try {
+            const loginResult = await awalExec(['auth', 'login', email]);
+            const loginData = loginResult.data;
+            const flowId = loginData.flowId || loginData.flow_id;
+            if (!flowId) {
+                loginSpinner.fail('Login failed: no flow ID returned');
+                console.log(chalk.dim('Response:'), loginResult.raw);
+                return;
+            }
+            loginSpinner.info('OTP sent to your email');
+            const otp = await prompt(chalk.cyan('? ') + 'Enter OTP from email: ');
+            if (!otp) {
+                console.log(chalk.red('OTP is required.'));
+                return;
+            }
+            const verifySpinner = ora('Verifying OTP...').start();
+            try {
+                const verifyResult = await awalExec(['auth', 'verify', String(flowId), otp]);
+                verifySpinner.succeed('Wallet authenticated');
+                // Get wallet address
+                const addrResult = await awalExec(['address']);
+                const addrData = addrResult.data;
+                walletAddress = addrData.address || '';
+                if (walletAddress) {
+                    console.log(chalk.dim(`  Wallet: ${walletAddress}`));
+                }
+            }
+            catch (err) {
+                verifySpinner.fail('OTP verification failed');
+                console.error(chalk.red(err.message));
+                return;
+            }
+        }
+        catch (err) {
+            loginSpinner.fail('Wallet login failed');
+            console.error(chalk.red(err.message));
+            return;
+        }
+    }
+    // If we still don't have address, try fetching it
+    if (!walletAddress) {
+        try {
+            const addrResult = await awalExec(['address']);
+            const addrData = addrResult.data;
+            walletAddress = addrData.address || '';
+        }
+        catch {
+            // continue without address
+        }
+    }
+    // Step 5: Check agent status
+    const agentSpinner = ora('Checking agent status...').start();
+    try {
+        const checkResp = await apiGet(`/api/v1/claw-agents/check-email?email=${encodeURIComponent(email)}`);
+        if (!checkResp.ok) {
+            agentSpinner.fail(`API error: ${checkResp.status}`);
+            return;
+        }
+        const checkData = checkResp.data;
+        if (!checkData.exists || checkData.status === 'UNCLAIMED') {
+            // Step 6: Register new agent
+            agentSpinner.text = 'Registering agent...';
+            const registerBody = { email };
+            if (walletAddress) {
+                registerBody.wallet_address = walletAddress;
+            }
+            const regResp = await apiPost('/api/v1/claw-agents/register', registerBody);
+            if (!regResp.ok) {
+                agentSpinner.fail('Registration failed');
+                console.error(chalk.red(JSON.stringify(regResp.data)));
+                return;
+            }
+            const regData = regResp.data;
+            agentSpinner.succeed(`Agent registered: ${regData.slug}`);
+            saveConfig({
+                api_key: regData.api_key,
+                agent_id: regData.agent_id,
+                agent_slug: regData.slug,
+                email,
+                wallet_address: walletAddress || undefined,
+            });
+        }
+        else if (checkData.status === 'ACTIVE') {
+            // Step 7: Login existing agent via OTP
+            agentSpinner.info(`Agent found: ${checkData.slug || checkData.agent_id}`);
+            const loginSpinner2 = ora('Sending login OTP...').start();
+            const loginResp = await apiPost('/api/v1/claw-agents/login', { email });
+            if (!loginResp.ok) {
+                loginSpinner2.fail('Agent login failed');
+                console.error(chalk.red(JSON.stringify(loginResp.data)));
+                return;
+            }
+            loginSpinner2.info('OTP sent to your email');
+            const agentOtp = await prompt(chalk.cyan('? ') + 'Enter agent login OTP: ');
+            const verifySpinner2 = ora('Verifying...').start();
+            const verifyResp = await apiPost('/api/v1/claw-agents/login/verify', {
+                email,
+                otp: agentOtp,
+                flow_id: loginResp.data.flow_id,
+            });
+            if (!verifyResp.ok) {
+                verifySpinner2.fail('Agent login verification failed');
+                console.error(chalk.red(JSON.stringify(verifyResp.data)));
+                return;
+            }
+            const loginData = verifyResp.data;
+            verifySpinner2.succeed('Agent authenticated');
+            saveConfig({
+                api_key: loginData.api_key,
+                agent_id: loginData.agent_id,
+                agent_slug: loginData.slug,
+                email,
+                wallet_address: walletAddress || undefined,
+            });
+        }
+        else {
+            agentSpinner.warn(`Agent status: ${checkData.status}`);
+            console.log(chalk.yellow('Please contact support if you need help.'));
+            return;
+        }
+    }
+    catch (err) {
+        agentSpinner.fail('Failed to check agent status');
+        console.error(chalk.red(err.message));
+        return;
+    }
+    // Step 8: Print summary
+    const config = loadConfig();
+    console.log('');
+    console.log(chalk.green.bold('  Setup complete!'));
+    console.log('');
+    if (config) {
+        console.log(chalk.dim(`  Agent ID:    ${config.agent_id}`));
+        console.log(chalk.dim(`  Agent Slug:  ${config.agent_slug}`));
+        if (walletAddress) {
+            console.log(chalk.dim(`  Wallet:      ${walletAddress}`));
+        }
+        console.log(chalk.dim(`  Config:      ${getConfigPath()}`));
+    }
+    console.log('');
+    console.log(`  Next steps:`);
+    console.log(`    ${chalk.cyan('clawmoney browse')}          Browse available tasks`);
+    console.log(`    ${chalk.cyan('clawmoney wallet balance')}  Check your wallet balance`);
+    console.log(`    ${chalk.cyan('clawmoney hire submit')}     Submit a task proof`);
+    console.log('');
+}

package/dist/commands/tweet.d.ts

@@ -0,0 +1,10 @@
+interface TweetOptions {
+    media?: string;
+    draft?: boolean;
+}
+/**
+ * Post a tweet via BNBot Chrome Extension through the Bridge server.
+ * Requires `clawmoney serve` to be running.
+ */
+export declare function tweetCommand(text: string, options: TweetOptions): Promise<void>;
+export {};

package/dist/commands/tweet.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { sendAction } from '../utils/bridge.js';
+/**
+ * Post a tweet via BNBot Chrome Extension through the Bridge server.
+ * Requires `clawmoney serve` to be running.
+ */
+export async function tweetCommand(text, options) {
+    const isDraft = options.draft || false;
+    console.log('');
+    console.log(chalk.dim(`  ${isDraft ? 'Drafting' : 'Posting'} tweet: "${text.slice(0, 80)}${text.length > 80 ? '...' : ''}"`));
+    if (options.media) {
+        console.log(chalk.dim(`  Media: ${options.media}`));
+    }
+    console.log('');
+    const spinner = ora(isDraft ? 'Filling tweet draft...' : 'Posting tweet...').start();
+    try {
+        const params = {
+            text,
+            draftOnly: isDraft,
+        };
+        if (options.media) {
+            params.media = [{ type: 'image', url: options.media }];
+        }
+        const result = await sendAction('post_tweet', params);
+        if (!result.success) {
+            spinner.fail(result.error || 'Failed');
+            return;
+        }
+        if (isDraft) {
+            spinner.succeed('Tweet draft ready — review and post manually');
+        }
+        else {
+            spinner.succeed('Tweet posted');
+            const data = result.data;
+            if (data?.url || data?.tweet_url) {
+                console.log(`  ${chalk.dim('URL:')} ${chalk.cyan(data.url || data.tweet_url)}`);
+            }
+        }
+    }
+    catch (err) {
+        spinner.fail('Failed');
+        console.error(chalk.red(err.message));
+        console.log('');
+        console.log(chalk.dim('  Make sure:'));
+        console.log(chalk.dim('  1. clawmoney serve is running'));
+        console.log(chalk.dim('  2. BNBot Chrome Extension is open on a Twitter tab'));
+    }
+    console.log('');
+}

package/dist/commands/wallet.d.ts

@@ -0,0 +1,4 @@
+export declare function walletStatusCommand(): Promise<void>;
+export declare function walletBalanceCommand(): Promise<void>;
+export declare function walletAddressCommand(): Promise<void>;
+export declare function walletSendCommand(amount: string, to: string): Promise<void>;

package/dist/commands/wallet.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { awalExec } from '../utils/awal.js';
+export async function walletStatusCommand() {
+    const spinner = ora('Getting wallet status...').start();
+    try {
+        const result = await awalExec(['status']);
+        spinner.succeed('Wallet Status');
+        console.log('');
+        const data = result.data;
+        for (const [key, value] of Object.entries(data)) {
+            console.log(`  ${chalk.dim(key + ':')} ${value}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        spinner.fail('Failed to get wallet status');
+        console.error(chalk.red(err.message));
+    }
+}
+export async function walletBalanceCommand() {
+    const spinner = ora('Getting wallet balance...').start();
+    try {
+        const result = await awalExec(['balance']);
+        spinner.succeed('Wallet Balance');
+        console.log('');
+        const data = result.data;
+        if (typeof data === 'object' && data !== null) {
+            for (const [key, value] of Object.entries(data)) {
+                console.log(`  ${chalk.dim(key + ':')} ${chalk.green(String(value))}`);
+            }
+        }
+        else {
+            console.log(`  ${result.raw}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        spinner.fail('Failed to get wallet balance');
+        console.error(chalk.red(err.message));
+    }
+}
+export async function walletAddressCommand() {
+    const spinner = ora('Getting wallet address...').start();
+    try {
+        const result = await awalExec(['address']);
+        spinner.succeed('Wallet Address');
+        console.log('');
+        const data = result.data;
+        const address = data.address || result.raw.trim();
+        console.log(`  ${chalk.cyan(String(address))}`);
+        console.log('');
+    }
+    catch (err) {
+        spinner.fail('Failed to get wallet address');
+        console.error(chalk.red(err.message));
+    }
+}
+export async function walletSendCommand(amount, to) {
+    console.log('');
+    console.log(chalk.bold('  Send Transaction'));
+    console.log(chalk.dim(`  Amount: ${amount}`));
+    console.log(chalk.dim(`  To:     ${to}`));
+    console.log('');
+    const spinner = ora('Sending...').start();
+    try {
+        const result = await awalExec(['send', amount, to]);
+        spinner.succeed('Transaction sent');
+        console.log('');
+        const data = result.data;
+        if (data.txHash || data.hash || data.transactionHash) {
+            const hash = data.txHash || data.hash || data.transactionHash;
+            console.log(`  ${chalk.dim('TX Hash:')} ${chalk.cyan(String(hash))}`);
+        }
+        else {
+            console.log(`  ${result.raw}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        spinner.fail('Send failed');
+        console.error(chalk.red(err.message));
+    }
+}