uwonbot 1.0.2 → 1.0.4

package/bin/uwonbot.js

@@ -5,13 +5,14 @@ import { loginCommand, logoutCommand, whoamiCommand } from '../src/auth.js';
 import { listAssistants, selectAssistant } from '../src/assistants.js';
 import { startChat } from '../src/chat.js';
 import { getConfig } from '../src/config.js';
+import { startAgent } from '../src/agent.js';
 
 showBanner();
 
 program
     .name('uwonbot')
     .description('Uwonbot AI Assistant — Your AI controls your computer')
-    .version('1.0.0');
+    .version('1.0.4');
 
 program
     .command('login')
@@ -52,6 +53,43 @@ program
         }
     });
 
+program
+    .command('agent')
+    .description('Start the local agent for OS-level mouse/keyboard control')
+    .option('-p, --port <port>', 'WebSocket server port', '9876')
+    .action(async (opts) => {
+        await startAgent(parseInt(opts.port));
+    });
+
+program
+    .command('upgrade')
+    .description('Upgrade uwonbot to the latest version')
+    .action(async () => {
+        const { execSync } = await import('child_process');
+        const chalk = (await import('chalk')).default;
+        console.log(chalk.cyan('  Checking for updates...'));
+        try {
+            const latest = execSync('npm view uwonbot version', { encoding: 'utf8' }).trim();
+            const { readFileSync } = await import('fs');
+            const { fileURLToPath } = await import('url');
+            const { dirname, join } = await import('path');
+            const __dirname = dirname(fileURLToPath(import.meta.url));
+            const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+            const current = pkg.version;
+            if (current === latest) {
+                console.log(chalk.green(`  ✓ Already on latest version (v${current})`));
+                return;
+            }
+            console.log(chalk.yellow(`  Current: v${current} → Latest: v${latest}`));
+            console.log(chalk.cyan('  Upgrading...'));
+            execSync(`npm install -g uwonbot@${latest}`, { stdio: 'inherit' });
+            console.log(chalk.green(`\n  ✓ Upgraded to v${latest}!`));
+        } catch (e) {
+            console.error(chalk.red(`  ✗ Upgrade failed: ${e.message}`));
+            console.log(chalk.gray('    Try manually: npm install -g uwonbot@latest'));
+        }
+    });
+
 program
     .command('run <command>')
     .description('Ask your assistant to run a task')
@@ -78,6 +116,8 @@ if (process.argv.length <= 2) {
         console.log('    uwonbot chat          Start chatting with your AI assistant');
         console.log('    uwonbot assistants     List your AI assistants');
         console.log('    uwonbot run "..."      Ask AI to run a task');
+        console.log('    uwonbot agent          Start local agent (OS control)');
+        console.log('    uwonbot upgrade        Upgrade to latest version');
         console.log('    uwonbot logout         Log out');
         console.log('');
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uwonbot",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Uwonbot AI Assistant CLI — Your AI controls your computer",
   "main": "src/index.js",
   "bin": {
@@ -29,6 +29,11 @@
     "inquirer": "^12.0.0",
     "node-fetch": "^3.3.2",
     "open": "^10.1.0",
-    "ora": "^8.1.0"
+    "ora": "^8.1.0",
+    "ws": "^8.18.0"
+  },
+  "optionalDependencies": {
+    "@nut-tree-fork/nut-js": "^4.2.0",
+    "screenshot-desktop": "^1.15.0"
   }
 }

package/src/agent.js

@@ -0,0 +1,305 @@
+import { WebSocketServer } from 'ws';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import chalk from 'chalk';
+import { getConfig } from './config.js';
+
+const execAsync = promisify(exec);
+const platform = process.platform;
+
+let robot = null;
+let screenshotDesktop = null;
+
+async function loadNativeModules() {
+    try {
+        robot = (await import('@nut-tree-fork/nut-js')).default || (await import('@nut-tree-fork/nut-js'));
+        if (robot.mouse) {
+            robot.mouse.config.autoDelayMs = 0;
+            robot.mouse.config.mouseSpeed = 2000;
+        }
+        console.log(chalk.green('  ✓ nut-js loaded (mouse/keyboard control)'));
+    } catch {
+        try {
+            const rjs = await import('robotjs');
+            robot = rjs.default || rjs;
+            console.log(chalk.green('  ✓ robotjs loaded (mouse/keyboard control)'));
+        } catch {
+            console.log(chalk.yellow('  ⚠ No mouse/keyboard module found.'));
+            console.log(chalk.yellow('    Install: npm install -g @nut-tree-fork/nut-js'));
+            robot = null;
+        }
+    }
+
+    try {
+        const mod = await import('screenshot-desktop');
+        screenshotDesktop = mod.default || mod;
+        console.log(chalk.green('  ✓ screenshot-desktop loaded'));
+    } catch {
+        console.log(chalk.yellow('  ⚠ screenshot-desktop not found.'));
+        console.log(chalk.yellow('    Install: npm install -g screenshot-desktop'));
+        screenshotDesktop = null;
+    }
+}
+
+async function getScreenSize() {
+    if (robot?.screen?.width) {
+        const w = await robot.screen.width();
+        const h = await robot.screen.height();
+        return { width: w, height: h };
+    }
+    if (robot?.getScreenSize) {
+        return robot.getScreenSize();
+    }
+    return { width: 1920, height: 1080 };
+}
+
+async function moveMouse(x, y) {
+    const screen = await getScreenSize();
+    const px = Math.round(x * screen.width);
+    const py = Math.round(y * screen.height);
+
+    if (robot?.mouse?.setPosition) {
+        const { Point } = await import('@nut-tree-fork/nut-js');
+        await robot.mouse.setPosition(new Point(px, py));
+    } else if (robot?.moveMouse) {
+        robot.moveMouse(px, py);
+    }
+}
+
+async function mouseClick(button = 'left', double = false) {
+    if (robot?.mouse?.click) {
+        const { Button } = await import('@nut-tree-fork/nut-js');
+        const btn = button === 'right' ? Button.RIGHT : Button.LEFT;
+        await robot.mouse.click(btn);
+        if (double) await robot.mouse.click(btn);
+    } else if (robot?.mouseClick) {
+        robot.mouseClick(button, double);
+    }
+}
+
+async function mouseDown(button = 'left') {
+    if (robot?.mouse?.pressButton) {
+        const { Button } = await import('@nut-tree-fork/nut-js');
+        await robot.mouse.pressButton(button === 'right' ? Button.RIGHT : Button.LEFT);
+    } else if (robot?.mouseToggle) {
+        robot.mouseToggle('down', button);
+    }
+}
+
+async function mouseUp(button = 'left') {
+    if (robot?.mouse?.releaseButton) {
+        const { Button } = await import('@nut-tree-fork/nut-js');
+        await robot.mouse.releaseButton(button === 'right' ? Button.RIGHT : Button.LEFT);
+    } else if (robot?.mouseToggle) {
+        robot.mouseToggle('up', button);
+    }
+}
+
+async function mouseScroll(dx, dy) {
+    if (robot?.mouse?.scrollDown && robot?.mouse?.scrollUp) {
+        const amount = Math.abs(dy);
+        if (dy > 0) await robot.mouse.scrollDown(amount);
+        else await robot.mouse.scrollUp(amount);
+    } else if (robot?.scrollMouse) {
+        robot.scrollMouse(dx, dy);
+    }
+}
+
+async function mouseDrag(fromX, fromY, toX, toY) {
+    await moveMouse(fromX, fromY);
+    await mouseDown('left');
+    await new Promise(r => setTimeout(r, 50));
+    await moveMouse(toX, toY);
+    await new Promise(r => setTimeout(r, 50));
+    await mouseUp('left');
+}
+
+async function typeText(text) {
+    if (robot?.keyboard?.type) {
+        await robot.keyboard.type(text);
+    } else if (robot?.typeString) {
+        robot.typeString(text);
+    }
+}
+
+async function pressKey(keys) {
+    const keyArr = keys.split('+').map(k => k.trim().toLowerCase());
+
+    if (robot?.keyboard?.pressKey && robot?.keyboard?.releaseKey) {
+        const { Key } = await import('@nut-tree-fork/nut-js');
+        const mapped = keyArr.map(k => {
+            const map = {
+                cmd: Key.LeftSuper, command: Key.LeftSuper, meta: Key.LeftSuper,
+                ctrl: Key.LeftControl, control: Key.LeftControl,
+                alt: Key.LeftAlt, option: Key.LeftAlt,
+                shift: Key.LeftShift,
+                enter: Key.Return, return: Key.Return,
+                tab: Key.Tab, escape: Key.Escape, esc: Key.Escape,
+                space: Key.Space, backspace: Key.Backspace, delete: Key.Delete,
+                up: Key.Up, down: Key.Down, left: Key.Left, right: Key.Right,
+                home: Key.Home, end: Key.End, pageup: Key.PageUp, pagedown: Key.PageDown,
+                f1: Key.F1, f2: Key.F2, f3: Key.F3, f4: Key.F4, f5: Key.F5,
+            };
+            return map[k] || Key[k.toUpperCase()] || Key[k];
+        }).filter(Boolean);
+
+        for (const k of mapped) await robot.keyboard.pressKey(k);
+        for (const k of mapped.reverse()) await robot.keyboard.releaseKey(k);
+    } else if (robot?.keyTap) {
+        const modifiers = [];
+        let mainKey = keyArr[keyArr.length - 1];
+        for (let i = 0; i < keyArr.length - 1; i++) {
+            const k = keyArr[i];
+            if (k === 'cmd' || k === 'command') modifiers.push('command');
+            else if (k === 'ctrl' || k === 'control') modifiers.push('control');
+            else if (k === 'alt' || k === 'option') modifiers.push('alt');
+            else if (k === 'shift') modifiers.push('shift');
+        }
+        robot.keyTap(mainKey, modifiers);
+    }
+}
+
+async function takeScreenshot() {
+    if (!screenshotDesktop) return null;
+    try {
+        const buf = await screenshotDesktop({ format: 'png' });
+        return buf.toString('base64');
+    } catch (e) {
+        console.error('Screenshot failed:', e.message);
+        return null;
+    }
+}
+
+async function openApp(appName) {
+    const name = appName.toLowerCase();
+    try {
+        if (platform === 'darwin') {
+            const appMap = {
+                chrome: 'Google Chrome', safari: 'Safari', firefox: 'Firefox',
+                finder: 'Finder', terminal: 'Terminal', code: 'Visual Studio Code',
+                slack: 'Slack', spotify: 'Spotify', discord: 'Discord',
+                notes: 'Notes', calculator: 'Calculator', music: 'Music',
+            };
+            const resolved = appMap[name] || appName;
+            await execAsync(`open -a "${resolved}"`);
+        } else if (platform === 'win32') {
+            await execAsync(`start "" "${appName}"`);
+        } else {
+            await execAsync(`xdg-open "${appName}" || ${appName}`);
+        }
+        return true;
+    } catch (e) {
+        console.error('App open failed:', e.message);
+        return false;
+    }
+}
+
+async function handleCommand(msg) {
+    try {
+        const cmd = JSON.parse(msg);
+        switch (cmd.type) {
+            case 'mouse_move':
+                await moveMouse(cmd.x, cmd.y);
+                return { ok: true };
+            case 'mouse_click':
+                await mouseClick(cmd.button || 'left', cmd.double || false);
+                return { ok: true };
+            case 'mouse_down':
+                await mouseDown(cmd.button || 'left');
+                return { ok: true };
+            case 'mouse_up':
+                await mouseUp(cmd.button || 'left');
+                return { ok: true };
+            case 'mouse_scroll':
+                await mouseScroll(cmd.dx || 0, cmd.dy || 0);
+                return { ok: true };
+            case 'mouse_drag':
+                await mouseDrag(cmd.fromX, cmd.fromY, cmd.toX, cmd.toY);
+                return { ok: true };
+            case 'key_type':
+                await typeText(cmd.text || '');
+                return { ok: true };
+            case 'key_press':
+                await pressKey(cmd.keys || '');
+                return { ok: true };
+            case 'screenshot':
+                const img = await takeScreenshot();
+                return { ok: !!img, image: img };
+            case 'app_open':
+                const opened = await openApp(cmd.name || '');
+                return { ok: opened };
+            case 'screen_size':
+                const size = await getScreenSize();
+                return { ok: true, ...size };
+            case 'ping':
+                return { ok: true, pong: true };
+            default:
+                return { ok: false, error: `Unknown command: ${cmd.type}` };
+        }
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+
+export async function startAgent(port = 9876) {
+    console.log('');
+    console.log(chalk.bold.cyan('  🖥️  Uwonbot Agent'));
+    console.log(chalk.gray('  ────────────────────────'));
+    console.log('');
+
+    await loadNativeModules();
+    console.log('');
+
+    const config = getConfig();
+    const uid = config.get('uid');
+    const email = config.get('email');
+
+    if (!uid) {
+        console.log(chalk.red('  ✗ Not logged in. Run: uwonbot login'));
+        process.exit(1);
+    }
+
+    console.log(chalk.gray(`  User: ${email}`));
+    console.log(chalk.gray(`  Port: ${port}`));
+    console.log('');
+
+    const wss = new WebSocketServer({ port });
+
+    wss.on('connection', (ws, req) => {
+        const origin = req.headers.origin || 'unknown';
+        console.log(chalk.green(`  ✓ Client connected from ${origin}`));
+
+        ws.on('message', async (data) => {
+            const result = await handleCommand(data.toString());
+            ws.send(JSON.stringify(result));
+        });
+
+        ws.on('close', () => {
+            console.log(chalk.yellow('  ○ Client disconnected'));
+        });
+
+        ws.send(JSON.stringify({ type: 'welcome', agent: 'uwonbot', version: '1.0.3', uid }));
+    });
+
+    wss.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.log(chalk.red(`  ✗ Port ${port} is already in use`));
+            console.log(chalk.gray(`    Try: uwonbot agent --port ${port + 1}`));
+            process.exit(1);
+        }
+        console.error(chalk.red('  ✗ Server error:'), err.message);
+    });
+
+    console.log(chalk.bold.green(`  ✓ Agent running on ws://localhost:${port}`));
+    console.log(chalk.gray('  Waiting for connections...'));
+    console.log('');
+    console.log(chalk.gray('  Press Ctrl+C to stop'));
+    console.log('');
+
+    process.on('SIGINT', () => {
+        console.log('');
+        console.log(chalk.yellow('  Agent stopped.'));
+        wss.close();
+        process.exit(0);
+    });
+}

package/src/banner.js

@@ -1,11 +1,25 @@
 import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+function getVersion() {
+    try {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+        return pkg.version || '0.0.0';
+    } catch { return '0.0.0'; }
+}
 
 export function showBanner() {
+    const ver = getVersion();
     const blue = chalk.hex('#2563eb');
     const cyan = chalk.hex('#06b6d4');
     const gray = chalk.hex('#6b7280');
     const white = chalk.white.bold;
 
+    const verStr = `v${ver}`.padEnd(25);
+
     console.log('');
     console.log(blue('  ╔══════════════════════════════════════════════════════════════╗'));
     console.log(blue('  ║                                                              ║'));
@@ -17,7 +31,7 @@ export function showBanner() {
     console.log(blue('  ║') + cyan('    ╚═════╝  ╚══╝╚══╝  ╚═════╝ ╚═╝  ╚═══╝╚═════╝  ╚═════╝    ╚═╝   ') + blue('  ║'));
     console.log(blue('  ║                                                              ║'));
     console.log(blue('  ║') + gray('       AI Assistant — Your AI controls your computer          ') + blue('  ║'));
-    console.log(blue('  ║') + gray('       v1.0.0                     https://uwonbot.com         ') + blue('  ║'));
+    console.log(blue('  ║') + gray(`       ${verStr}https://uwonbot.com         `) + blue('  ║'));
     console.log(blue('  ║                                                              ║'));
     console.log(blue('  ╚══════════════════════════════════════════════════════════════╝'));
     console.log('');