uwonbot 1.0.1 → 1.0.3

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.3');
 
 program
     .command('login')
@@ -52,6 +53,14 @@ 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('run <command>')
     .description('Ask your assistant to run a task')
@@ -78,6 +87,7 @@ 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 logout         Log out');
         console.log('');
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uwonbot",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Uwonbot AI Assistant CLI — Your AI controls your computer",
   "main": "src/index.js",
   "bin": {
@@ -26,10 +26,14 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "conf": "^13.0.1",
-    "firebase": "^11.0.0",
     "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/assistants.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import ora from 'ora';
 import { getConfig } from './config.js';
-import { fetchAssistants } from './firebase-client.js';
+import { fetchAssistants, setIdToken } from './firebase-client.js';
 
 export async function listAssistants() {
     const config = getConfig();
@@ -11,6 +11,8 @@ export async function listAssistants() {
         console.log(chalk.yellow('\n  ⚠️  Please log in first: uwonbot login\n'));
         return;
     }
+    const token = config.get('idToken');
+    if (token) setIdToken(token);
 
     const spinner = ora('Fetching assistants...').start();
     try {
@@ -56,6 +58,8 @@ export async function selectAssistant() {
         console.log(chalk.yellow('\n  ⚠️  Please log in first: uwonbot login\n'));
         return null;
     }
+    const token = config.get('idToken');
+    if (token) setIdToken(token);
 
     const spinner = ora('Loading assistants...').start();
     try {

package/src/auth.js

@@ -50,9 +50,10 @@ export async function loginCommand() {
         console.log('');
     } catch (err) {
         spinner.fail(chalk.red('Login failed'));
-        if (err.code === 'auth/user-not-found') {
+        const msg = (err.message || '').toUpperCase();
+        if (msg.includes('EMAIL_NOT_FOUND') || msg.includes('USER_NOT_FOUND')) {
             console.log(chalk.yellow('  No account found. Sign up at https://chartapp-653e1.web.app/auth'));
-        } else if (err.code === 'auth/wrong-password' || err.code === 'auth/invalid-credential') {
+        } else if (msg.includes('INVALID_PASSWORD') || msg.includes('INVALID_LOGIN_CREDENTIALS')) {
             console.log(chalk.yellow('  Invalid password. Try again.'));
         } else {
             console.log(chalk.red(`  ${err.message}`));

package/src/firebase-client.js

@@ -1,53 +1,73 @@
-import { initializeApp } from 'firebase/app';
-import { getAuth, signInWithEmailAndPassword, signInWithCustomToken } from 'firebase/auth';
-import { getFirestore, collection, getDocs, doc, getDoc, query, orderBy } from 'firebase/firestore';
+const API_KEY = 'AIzaSyATfC0Ycfkjhgoe-QeS-Vww5DSdQINSWNU';
+const PROJECT_ID = 'chartapp-653e1';
+const AUTH_URL = `https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=${API_KEY}`;
+const FIRESTORE_URL = `https://firestore.googleapis.com/v1/projects/${PROJECT_ID}/databases/(default)/documents`;
 
-const firebaseConfig = {
-    apiKey: "AIzaSyATfC0Ycfkjhgoe-QeS-Vww5DSdQINSWNU",
-    authDomain: "chartapp-653e1.firebaseapp.com",
-    projectId: "chartapp-653e1",
-    storageBucket: "chartapp-653e1.firebasestorage.app",
-    messagingSenderId: "725204716095",
-    appId: "1:725204716095:web:3c179131466ed50716c68a",
-};
-
-let app = null;
-let auth = null;
-let db = null;
-
-export function getFirebaseApp() {
-    if (!app) {
-        app = initializeApp(firebaseConfig);
-        auth = getAuth(app);
-        db = getFirestore(app);
-    }
-    return { app, auth, db };
-}
+let cachedIdToken = null;
 
 export async function loginWithEmail(email, password) {
-    const { auth } = getFirebaseApp();
-    const cred = await signInWithEmailAndPassword(auth, email, password);
+    const res = await fetch(AUTH_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password, returnSecureToken: true }),
+    });
+    const data = await res.json();
+    if (data.error) {
+        throw new Error(data.error.message || 'Login failed');
+    }
+    cachedIdToken = data.idToken;
     return {
-        uid: cred.user.uid,
-        email: cred.user.email,
-        displayName: cred.user.displayName || '',
-        idToken: await cred.user.getIdToken(),
-        refreshToken: cred.user.refreshToken,
+        uid: data.localId,
+        email: data.email,
+        displayName: data.displayName || '',
+        idToken: data.idToken,
+        refreshToken: data.refreshToken,
     };
 }
 
+function parseFirestoreDoc(doc) {
+    const fields = doc.fields || {};
+    const result = {};
+    for (const [key, val] of Object.entries(fields)) {
+        if ('stringValue' in val) result[key] = val.stringValue;
+        else if ('integerValue' in val) result[key] = Number(val.integerValue);
+        else if ('doubleValue' in val) result[key] = val.doubleValue;
+        else if ('booleanValue' in val) result[key] = val.booleanValue;
+        else if ('nullValue' in val) result[key] = null;
+        else if ('arrayValue' in val) {
+            result[key] = (val.arrayValue.values || []).map(v =>
+                v.stringValue ?? v.integerValue ?? v.doubleValue ?? v.booleanValue ?? null
+            );
+        } else if ('mapValue' in val) result[key] = parseFirestoreDoc(val.mapValue);
+        else if ('timestampValue' in val) result[key] = val.timestampValue;
+    }
+    return result;
+}
+
 export async function fetchAssistants(uid) {
-    const { db } = getFirebaseApp();
-    const ref = collection(db, 'users', uid, 'assistants');
-    const q = query(ref, orderBy('createdAt', 'desc'));
-    const snap = await getDocs(q);
-    return snap.docs.map(d => ({ id: d.id, ...d.data() }));
+    if (!cachedIdToken) throw new Error('Not logged in');
+    const url = `${FIRESTORE_URL}/users/${uid}/assistants?orderBy=createdAt%20desc`;
+    const res = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${cachedIdToken}` },
+    });
+    const data = await res.json();
+    if (data.error) throw new Error(data.error.message);
+    return (data.documents || []).map(doc => {
+        const parts = doc.name.split('/');
+        return { id: parts[parts.length - 1], ...parseFirestoreDoc(doc) };
+    });
 }
 
 export async function fetchAssistant(uid, assistantId) {
-    const { db } = getFirebaseApp();
-    const ref = doc(db, 'users', uid, 'assistants', assistantId);
-    const snap = await getDoc(ref);
-    if (!snap.exists()) return null;
-    return { id: snap.id, ...snap.data() };
+    if (!cachedIdToken) throw new Error('Not logged in');
+    const url = `${FIRESTORE_URL}/users/${uid}/assistants/${assistantId}`;
+    const res = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${cachedIdToken}` },
+    });
+    const data = await res.json();
+    if (data.error) return null;
+    const parts = data.name.split('/');
+    return { id: parts[parts.length - 1], ...parseFirestoreDoc(data) };
 }
+
+export function setIdToken(token) { cachedIdToken = token; }