clawmoney 0.2.0 → 0.4.0

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/tweet.d.ts

@@ -1,10 +1,10 @@
 interface TweetOptions {
     media?: string;
+    draft?: boolean;
 }
 /**
- * Post a tweet via bnbot-cli.
- * bnbot-cli is CJS; we spawn it as a subprocess for simplicity
- * since it requires the BNBot Chrome Extension to be running.
+ * 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

@@ -1,69 +1,50 @@
 import chalk from 'chalk';
 import ora from 'ora';
-import { spawn } from 'node:child_process';
+import { sendAction } from '../utils/bridge.js';
 /**
- * Post a tweet via bnbot-cli.
- * bnbot-cli is CJS; we spawn it as a subprocess for simplicity
- * since it requires the BNBot Chrome Extension to be running.
+ * 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(`  Posting tweet: "${text.slice(0, 80)}${text.length > 80 ? '...' : ''}"`));
+    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('Posting tweet via BNBot...').start();
+    const spinner = ora(isDraft ? 'Filling tweet draft...' : 'Posting tweet...').start();
     try {
-        const args = ['bnbot-cli', 'tweet', text];
+        const params = {
+            text,
+            draftOnly: isDraft,
+        };
         if (options.media) {
-            args.push('--media', options.media);
+            params.media = [{ type: 'image', url: options.media }];
         }
-        const result = await new Promise((resolve, reject) => {
-            const child = spawn('npx', args, {
-                stdio: ['inherit', 'pipe', 'pipe'],
-                shell: true,
-            });
-            let stdout = '';
-            let stderr = '';
-            child.stdout.on('data', (chunk) => {
-                stdout += chunk.toString();
-            });
-            child.stderr.on('data', (chunk) => {
-                stderr += chunk.toString();
-            });
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(stderr.trim() || `bnbot-cli exited with code ${code}`));
-                    return;
-                }
-                resolve(stdout.trim());
-            });
-            child.on('error', (err) => {
-                reject(new Error(`Failed to spawn bnbot-cli: ${err.message}`));
-            });
-        });
-        spinner.succeed('Tweet posted');
-        // Try to parse and display tweet URL
-        try {
-            const data = JSON.parse(result);
-            if (data.url || data.tweet_url) {
-                console.log(`  ${chalk.dim('URL:')} ${chalk.cyan(data.url || data.tweet_url)}`);
-            }
+        const result = await sendAction('post_tweet', params);
+        if (!result.success) {
+            spinner.fail(result.error || 'Failed');
+            return;
         }
-        catch {
-            if (result) {
-                console.log(chalk.dim(`  ${result}`));
+        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 to post tweet');
+        spinner.fail('Failed');
         console.error(chalk.red(err.message));
         console.log('');
         console.log(chalk.dim('  Make sure:'));
-        console.log(chalk.dim('  1. BNBot Chrome Extension is running'));
-        console.log(chalk.dim('  2. bnbot-cli is installed: npm install -g bnbot-cli'));
+        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/index.js

@@ -5,6 +5,7 @@ import { browseCommand } from './commands/browse.js';
 import { hireSubmitCommand, hireVerifyCommand } from './commands/hire.js';
 import { walletStatusCommand, walletBalanceCommand, walletAddressCommand, walletSendCommand, } from './commands/wallet.js';
 import { tweetCommand } from './commands/tweet.js';
+import { serveCommand } from './commands/serve.js';
 const program = new Command();
 program
     .name('clawmoney')
@@ -118,11 +119,26 @@ wallet
         process.exit(1);
     }
 });
+// serve
+program
+    .command('serve')
+    .description('Start the bridge server for Chrome Extension communication')
+    .option('-p, --port <port>', 'WebSocket port', '18900')
+    .action(async (options) => {
+    try {
+        await serveCommand(options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 // tweet
 program
     .command('tweet <text>')
     .description('Post a tweet via BNBot Chrome Extension')
     .option('-m, --media <path>', 'Path to media file')
+    .option('-d, --draft', 'Draft mode: fill tweet composer without posting')
     .action(async (text, options) => {
     try {
         await tweetCommand(text, options);

package/dist/utils/bridge.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Bridge — WebSocket server that sits between CLI commands and the Chrome Extension.
+ *
+ * Architecture:
+ *   clawmoney serve  →  starts WS server (port 18900)
+ *   Chrome Extension  →  connects as client (localRelayManager)
+ *   clawmoney tweet   →  connects as client, sends action, gets result via server
+ *
+ * The server keeps a persistent connection to the extension.
+ * CLI commands connect briefly, send an action, and disconnect after getting a result.
+ */
+/**
+ * The Bridge server — start with `clawmoney serve`
+ */
+export declare class BridgeServer {
+    private wss;
+    private extensionClient;
+    private pendingRequests;
+    private extensionVersion;
+    private port;
+    constructor(port?: number);
+    start(): Promise<void>;
+    private handleMessage;
+    stop(): void;
+    isExtensionConnected(): boolean;
+    getExtensionVersion(): string | null;
+    getPort(): number;
+}
+/**
+ * Send an action to the Chrome Extension.
+ * Auto-starts bridge server if none is running, then waits for extension to connect.
+ */
+export declare function sendAction(actionType: string, params: Record<string, unknown>, port?: number): Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}>;

package/dist/utils/bridge.js

@@ -0,0 +1,259 @@
+/**
+ * Bridge — WebSocket server that sits between CLI commands and the Chrome Extension.
+ *
+ * Architecture:
+ *   clawmoney serve  →  starts WS server (port 18900)
+ *   Chrome Extension  →  connects as client (localRelayManager)
+ *   clawmoney tweet   →  connects as client, sends action, gets result via server
+ *
+ * The server keeps a persistent connection to the extension.
+ * CLI commands connect briefly, send an action, and disconnect after getting a result.
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+import { randomUUID } from 'node:crypto';
+const DEFAULT_PORT = 18900;
+const ACTION_TIMEOUT = 60000;
+/**
+ * The Bridge server — start with `clawmoney serve`
+ */
+export class BridgeServer {
+    wss = null;
+    extensionClient = null;
+    pendingRequests = new Map();
+    extensionVersion = null;
+    port;
+    constructor(port) {
+        this.port = port || DEFAULT_PORT;
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            this.wss = new WebSocketServer({ port: this.port, host: '127.0.0.1' });
+            this.wss.on('listening', () => {
+                resolve();
+            });
+            this.wss.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${this.port} already in use. Another serve instance may be running.`));
+                }
+                else {
+                    reject(error);
+                }
+            });
+            this.wss.on('connection', (ws) => {
+                // Determine if this is the extension or a CLI client
+                // Extension sends a 'status' message on connect
+                // CLI clients send an 'action' message
+                ws.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(ws, message);
+                    }
+                    catch {
+                        // ignore
+                    }
+                });
+                ws.on('close', () => {
+                    if (this.extensionClient === ws) {
+                        this.extensionClient = null;
+                        this.extensionVersion = null;
+                        // Reject all pending requests
+                        for (const [id, pending] of this.pendingRequests) {
+                            clearTimeout(pending.timer);
+                            pending.reject(new Error('Extension disconnected'));
+                            this.pendingRequests.delete(id);
+                        }
+                    }
+                });
+            });
+        });
+    }
+    handleMessage(ws, message) {
+        switch (message.type) {
+            case 'status':
+                // Extension connected
+                if (this.extensionClient && this.extensionClient !== ws && this.extensionClient.readyState === WebSocket.OPEN) {
+                    this.extensionClient.close(1000, 'Replaced by new connection');
+                }
+                this.extensionClient = ws;
+                this.extensionVersion = message.version;
+                break;
+            case 'action':
+                // CLI client sending an action — forward to extension
+                if (!this.extensionClient || this.extensionClient.readyState !== WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'action_result',
+                        requestId: message.requestId,
+                        success: false,
+                        error: 'Extension not connected. Make sure BNBot Chrome Extension is running on a Twitter tab.',
+                    }));
+                    return;
+                }
+                // Store pending request keyed to the CLI client WebSocket
+                const requestId = message.requestId;
+                const timer = setTimeout(() => {
+                    this.pendingRequests.delete(requestId);
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: 'action_result',
+                            requestId,
+                            success: false,
+                            error: `Action '${message.actionType}' timed out`,
+                        }));
+                    }
+                }, ACTION_TIMEOUT);
+                this.pendingRequests.set(requestId, {
+                    resolve: (result) => {
+                        if (ws.readyState === WebSocket.OPEN) {
+                            ws.send(JSON.stringify(result));
+                        }
+                    },
+                    reject: (error) => {
+                        if (ws.readyState === WebSocket.OPEN) {
+                            ws.send(JSON.stringify({
+                                type: 'action_result',
+                                requestId,
+                                success: false,
+                                error: error.message,
+                            }));
+                        }
+                    },
+                    timer,
+                });
+                // Forward to extension
+                this.extensionClient.send(JSON.stringify(message));
+                break;
+            case 'action_result':
+                // Extension sending back a result — forward to CLI client
+                const pending = this.pendingRequests.get(message.requestId);
+                if (pending) {
+                    clearTimeout(pending.timer);
+                    this.pendingRequests.delete(message.requestId);
+                    pending.resolve(message);
+                }
+                break;
+            case 'heartbeat':
+                // Respond to heartbeat from extension
+                break;
+        }
+    }
+    stop() {
+        if (this.extensionClient) {
+            this.extensionClient.close(1000, 'Server shutting down');
+            this.extensionClient = null;
+        }
+        if (this.wss) {
+            this.wss.close();
+            this.wss = null;
+        }
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Server shutting down'));
+        }
+        this.pendingRequests.clear();
+    }
+    isExtensionConnected() {
+        return this.extensionClient !== null && this.extensionClient.readyState === WebSocket.OPEN;
+    }
+    getExtensionVersion() {
+        return this.extensionVersion;
+    }
+    getPort() {
+        return this.port;
+    }
+}
+// Singleton bridge server — auto-started on first sendAction call
+let _server = null;
+/**
+ * Ensure a bridge server is running. Starts one if needed.
+ */
+async function ensureBridge(port) {
+    if (_server)
+        return _server;
+    // Try connecting to an existing server first
+    const existing = await new Promise((resolve) => {
+        const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+        const t = setTimeout(() => { ws.close(); resolve(false); }, 1000);
+        ws.on('open', () => { clearTimeout(t); ws.close(); resolve(true); });
+        ws.on('error', () => { clearTimeout(t); resolve(false); });
+    });
+    if (existing) {
+        // Another bridge (or `clawmoney serve`) is already running — use it as client
+        return null; // signal to use client mode
+    }
+    // Start our own bridge in-process
+    const server = new BridgeServer(port);
+    await server.start();
+    _server = server;
+    return server;
+}
+/**
+ * Send an action to the Chrome Extension.
+ * Auto-starts bridge server if none is running, then waits for extension to connect.
+ */
+export async function sendAction(actionType, params, port) {
+    const wsPort = port || DEFAULT_PORT;
+    // Ensure bridge is running
+    const server = await ensureBridge(wsPort).catch(() => null);
+    // If we own the server, wait for extension to connect (up to 30s)
+    if (server && _server === server) {
+        const waitStart = Date.now();
+        while (!server.isExtensionConnected() && Date.now() - waitStart < 30000) {
+            await new Promise(r => setTimeout(r, 500));
+        }
+        if (!server.isExtensionConnected()) {
+            return {
+                success: false,
+                error: 'Chrome Extension not connected. Make sure BNBot extension is running on a Twitter tab with OpenClaw integration enabled.',
+            };
+        }
+    }
+    // Send action via WebSocket client
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(`ws://127.0.0.1:${wsPort}`);
+        const requestId = randomUUID();
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                ws.close();
+                reject(new Error(`Action '${actionType}' timed out after ${ACTION_TIMEOUT / 1000}s`));
+            }
+        }, ACTION_TIMEOUT);
+        ws.on('open', () => {
+            ws.send(JSON.stringify({
+                type: 'action',
+                requestId,
+                actionType,
+                actionPayload: params,
+            }));
+        });
+        ws.on('message', (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === 'action_result' && msg.requestId === requestId) {
+                    settled = true;
+                    clearTimeout(timer);
+                    ws.close();
+                    resolve({ success: msg.success, data: msg.data, error: msg.error });
+                }
+            }
+            catch {
+                // ignore
+            }
+        });
+        ws.on('error', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(new Error('Cannot connect to bridge. Make sure BNBot Chrome Extension is running.'));
+            }
+        });
+        ws.on('close', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(new Error('Connection closed before response'));
+            }
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "ClawMoney CLI -- Earn crypto with your AI agent",
   "type": "module",
   "bin": {
@@ -16,16 +16,17 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@types/ws": "^8.18.1",
     "awal": "^2.2.0",
-    "bnbot-cli": "^1.3.0",
-    "commander": "^12.0.0",
-    "yaml": "^2.4.0",
     "chalk": "^5.3.0",
-    "ora": "^8.0.0"
+    "commander": "^12.0.0",
+    "ora": "^8.0.0",
+    "ws": "^8.20.0",
+    "yaml": "^2.4.0"
   },
   "devDependencies": {
-    "typescript": "^5.4.0",
-    "@types/node": "^20.0.0"
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
   },
   "engines": {
     "node": ">=18"