uwonbot 1.0.6 → 1.0.8

package/bin/uwonbot.js

@@ -12,7 +12,7 @@ showBanner();
 program
     .name('uwonbot')
     .description('Uwonbot AI Assistant — Your AI controls your computer')
-    .version('1.0.6');
+    .version('1.0.8');
 
 program
     .command('login')
@@ -42,18 +42,30 @@ program
 program
     .command('chat [assistantName]')
     .description('Start chatting with an AI assistant')
-    .action(async (assistantName) => {
+    .option('-n, --name <name>', 'Assistant name to launch directly')
+    .action(async (assistantName, opts) => {
         const config = getConfig();
         if (!config.get('uid')) {
             console.log('\n  ⚠️  Please log in first: uwonbot login\n');
             process.exit(1);
         }
-        if (assistantName) {
-            await startChat(assistantName);
+        const targetName = opts.name || assistantName;
+        if (targetName) {
+            await startChat(targetName);
         } else {
             const assistant = await selectAssistant();
             if (assistant) {
                 await startChat(null, assistant);
+            } else {
+                const defaultBot = {
+                    name: 'Uwonbot',
+                    avatar: '🤖',
+                    brain: 'default',
+                    voiceLang: 'ko-KR',
+                    voiceStyle: 'male',
+                    isDefaultBot: true,
+                };
+                await startChat(null, defaultBot);
             }
         }
     });
@@ -62,8 +74,9 @@ program
     .command('agent')
     .description('Start the local agent for OS-level mouse/keyboard control')
     .option('-p, --port <port>', 'WebSocket server port', '9876')
+    .option('--no-mic', 'Disable microphone clap detection')
     .action(async (opts) => {
-        await startAgent(parseInt(opts.port));
+        await startAgent(parseInt(opts.port), { noMic: !opts.mic });
     });
 
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uwonbot",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Uwonbot AI Assistant CLI — Your AI controls your computer",
   "main": "src/index.js",
   "bin": {
@@ -34,6 +34,7 @@
   },
   "optionalDependencies": {
     "@nut-tree-fork/nut-js": "^4.2.0",
+    "mic": "^2.5.1",
     "screenshot-desktop": "^1.15.0"
   }
 }

package/src/agent.js

@@ -3,6 +3,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import chalk from 'chalk';
 import { getConfig } from './config.js';
+import ClapListener from './clapListener.js';
 
 const execAsync = promisify(exec);
 const platform = process.platform;
@@ -194,6 +195,33 @@ async function openApp(appName) {
     }
 }
 
+async function openTerminalWithChat(assistantName) {
+    const name = assistantName || 'uwonbot';
+    try {
+        if (platform === 'darwin') {
+            await execAsync(`osascript -e 'tell application "Terminal"
+                activate
+                do script "uwonbot chat --name \\"${name}\\""
+            end tell'`);
+        } else if (platform === 'win32') {
+            await execAsync(`start cmd /k "uwonbot chat --name \\"${name}\\""`);
+        } else {
+            const terminals = ['gnome-terminal', 'xterm', 'konsole', 'xfce4-terminal'];
+            for (const t of terminals) {
+                try {
+                    await execAsync(`which ${t}`);
+                    await execAsync(`${t} -- uwonbot chat --name "${name}"`);
+                    return true;
+                } catch {}
+            }
+        }
+        return true;
+    } catch (e) {
+        console.error(chalk.red('  Terminal open failed:'), e.message);
+        return false;
+    }
+}
+
 async function handleCommand(msg) {
     try {
         const cmd = JSON.parse(msg);
@@ -231,6 +259,9 @@ async function handleCommand(msg) {
             case 'screen_size':
                 const size = await getScreenSize();
                 return { ok: true, ...size };
+            case 'open_terminal':
+                const termOk = await openTerminalWithChat(cmd.assistantName || cmd.name);
+                return { ok: termOk };
             case 'ping':
                 return { ok: true, pong: true };
             default:
@@ -241,7 +272,7 @@ async function handleCommand(msg) {
     }
 }
 
-export async function startAgent(port = 9876) {
+export async function startAgent(port = 9876, options = {}) {
     console.log('');
     console.log(chalk.bold.cyan('  🖥️  Uwonbot Agent'));
     console.log(chalk.gray('  ────────────────────────'));
@@ -263,6 +294,15 @@ export async function startAgent(port = 9876) {
     console.log(chalk.gray(`  Port: ${port}`));
     console.log('');
 
+    if (!options.noMic) {
+        const clapListener = new ClapListener(() => {
+            console.log(chalk.bold.cyan('  🎯 Opening terminal...'));
+            openTerminalWithChat();
+        });
+        await clapListener.start();
+        console.log('');
+    }
+
     const wss = new WebSocketServer({ port });
 
     wss.on('connection', (ws, req) => {

package/src/chat.js

@@ -2,9 +2,78 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import ora from 'ora';
 import readline from 'readline';
+import crypto from 'crypto';
+import open from 'open';
 import { getConfig } from './config.js';
 import { sendToBrain } from './brain.js';
 import { showMiniBar } from './banner.js';
+import {
+    hasRegisteredDevices,
+    createCLISession,
+    checkCLISession,
+    deleteCLISession,
+} from './firebase-client.js';
+
+const WEB_APP_URL = 'https://chartapp-653e1.web.app';
+
+async function requireBiometricAuth(uid) {
+    try {
+        const hasDevices = await hasRegisteredDevices(uid);
+        if (!hasDevices) return true;
+    } catch {
+        return true;
+    }
+
+    const token = crypto.randomUUID();
+
+    try {
+        await createCLISession(uid, token);
+    } catch (err) {
+        console.log(chalk.yellow(`\n  ⚠ 인증 세션 생성 실패: ${err.message}\n`));
+        return false;
+    }
+
+    const authUrl = `${WEB_APP_URL}/cli-auth?token=${token}`;
+    console.log('');
+    console.log(chalk.bold.cyan('  🔐 생체인증이 필요합니다'));
+    console.log(chalk.gray('  ─────────────────────────'));
+    console.log(chalk.white('  브라우저에서 지문/Face ID 인증을 완료해주세요.'));
+    console.log('');
+    console.log(chalk.gray(`  ${authUrl}`));
+    console.log('');
+
+    try {
+        await open(authUrl);
+    } catch {
+        console.log(chalk.yellow('  브라우저를 자동으로 열 수 없습니다. 위 URL을 직접 열어주세요.'));
+    }
+
+    const spinner = ora({
+        text: chalk.gray('인증 대기 중... (60초 이내에 완료해주세요)'),
+        spinner: 'dots',
+        color: 'cyan',
+    }).start();
+
+    const MAX_WAIT = 60000;
+    const POLL_INTERVAL = 2000;
+    const start = Date.now();
+
+    while (Date.now() - start < MAX_WAIT) {
+        await new Promise(r => setTimeout(r, POLL_INTERVAL));
+        try {
+            const session = await checkCLISession(uid, token);
+            if (session?.verified) {
+                spinner.succeed(chalk.green('인증 완료!'));
+                try { await deleteCLISession(uid, token); } catch {}
+                return true;
+            }
+        } catch {}
+    }
+
+    spinner.fail(chalk.red('인증 시간 초과'));
+    try { await deleteCLISession(uid, token); } catch {}
+    return false;
+}
 
 export async function startChat(assistantName, assistant, initialCommand) {
     const config = getConfig();
@@ -19,6 +88,14 @@ export async function startChat(assistantName, assistant, initialCommand) {
         return;
     }
 
+    if (!assistant.isDefaultBot) {
+        const authOk = await requireBiometricAuth(uid);
+        if (!authOk) {
+            console.log(chalk.red('\n  ✗ 인증에 실패했습니다. 비서를 사용하려면 인증이 필요합니다.\n'));
+            return;
+        }
+    }
+
     const brainLabel = assistant.brain === 'default' ? 'Uwonbot (Gemini)'
         : assistant.brain === 'openai' ? 'OpenAI GPT'
         : assistant.brain === 'claude' ? 'Anthropic Claude'

package/src/clapListener.js

@@ -0,0 +1,107 @@
+import chalk from 'chalk';
+
+const DEFAULT_THRESHOLD = 0.4;
+const CLAP_MIN_INTERVAL = 100;
+const CLAP_MAX_INTERVAL = 800;
+const REQUIRED_CLAPS = 2;
+const RESET_TIMEOUT = 1500;
+const SAMPLE_RATE = 16000;
+const BUFFER_SIZE = 1024;
+
+export default class ClapListener {
+    constructor(onDoubleClap) {
+        this.onDoubleClap = onDoubleClap;
+        this.threshold = DEFAULT_THRESHOLD;
+        this.clapTimes = [];
+        this.lastClapTime = 0;
+        this.resetTimer = null;
+        this.mic = null;
+        this.running = false;
+    }
+
+    async start() {
+        if (this.running) return;
+
+        let micModule;
+        try {
+            micModule = (await import('mic')).default;
+        } catch {
+            console.log(chalk.yellow('  ⚠ mic module not found. Clap detection disabled.'));
+            console.log(chalk.gray('    Install: npm install -g mic'));
+            return false;
+        }
+
+        try {
+            this.mic = micModule({
+                rate: String(SAMPLE_RATE),
+                channels: '1',
+                bitwidth: '16',
+                encoding: 'signed-integer',
+                endian: 'little',
+                device: 'default',
+                debug: false,
+            });
+
+            const stream = this.mic.getAudioStream();
+            this.running = true;
+
+            stream.on('data', (buf) => {
+                if (!this.running) return;
+                this._processBuffer(buf);
+            });
+
+            stream.on('error', (err) => {
+                if (err.message?.includes('spawn') || err.message?.includes('sox') || err.message?.includes('rec')) {
+                    console.log(chalk.yellow('  ⚠ SoX not found. Install for clap detection:'));
+                    console.log(chalk.gray('    macOS: brew install sox'));
+                    console.log(chalk.gray('    Ubuntu: sudo apt install sox'));
+                    this.running = false;
+                }
+            });
+
+            this.mic.start();
+            console.log(chalk.green('  ✓ Microphone listening for claps'));
+            return true;
+        } catch (e) {
+            console.log(chalk.yellow(`  ⚠ Microphone init failed: ${e.message}`));
+            return false;
+        }
+    }
+
+    stop() {
+        this.running = false;
+        clearTimeout(this.resetTimer);
+        try { this.mic?.stop(); } catch {}
+        this.mic = null;
+    }
+
+    _processBuffer(buf) {
+        let peak = 0;
+        for (let i = 0; i < buf.length - 1; i += 2) {
+            const sample = buf.readInt16LE(i) / 32768;
+            const abs = Math.abs(sample);
+            if (abs > peak) peak = abs;
+        }
+
+        const now = Date.now();
+        const isClap = peak > this.threshold && (now - this.lastClapTime) > CLAP_MIN_INTERVAL;
+
+        if (!isClap) return;
+
+        this.lastClapTime = now;
+        this.clapTimes.push(now);
+
+        clearTimeout(this.resetTimer);
+        this.resetTimer = setTimeout(() => { this.clapTimes = []; }, RESET_TIMEOUT);
+
+        if (this.clapTimes.length >= REQUIRED_CLAPS) {
+            const interval = this.clapTimes[this.clapTimes.length - 1] - this.clapTimes[this.clapTimes.length - 2];
+            if (interval <= CLAP_MAX_INTERVAL) {
+                this.clapTimes = [];
+                clearTimeout(this.resetTimer);
+                console.log(chalk.cyan('  👏 Double clap detected!'));
+                this.onDoubleClap?.();
+            }
+        }
+    }
+}

package/src/firebase-client.js

@@ -83,3 +83,57 @@ export async function sendPasswordReset(email) {
 }
 
 export function setIdToken(token) { cachedIdToken = token; }
+
+export async function createCLISession(uid, token) {
+    if (!cachedIdToken) throw new Error('Not logged in');
+    const url = `${FIRESTORE_URL}/users/${uid}/cliSessions/${token}`;
+    const res = await fetch(url, {
+        method: 'PATCH',
+        headers: {
+            'Authorization': `Bearer ${cachedIdToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            fields: {
+                verified: { booleanValue: false },
+                createdAt: { timestampValue: new Date().toISOString() },
+            },
+        }),
+    });
+    const data = await res.json();
+    if (data.error) throw new Error(data.error.message);
+    return data;
+}
+
+export async function checkCLISession(uid, token) {
+    if (!cachedIdToken) throw new Error('Not logged in');
+    const url = `${FIRESTORE_URL}/users/${uid}/cliSessions/${token}`;
+    const res = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${cachedIdToken}` },
+    });
+    const data = await res.json();
+    if (data.error) return null;
+    const fields = data.fields || {};
+    return {
+        verified: fields.verified?.booleanValue === true,
+    };
+}
+
+export async function deleteCLISession(uid, token) {
+    if (!cachedIdToken) throw new Error('Not logged in');
+    const url = `${FIRESTORE_URL}/users/${uid}/cliSessions/${token}`;
+    await fetch(url, {
+        method: 'DELETE',
+        headers: { 'Authorization': `Bearer ${cachedIdToken}` },
+    });
+}
+
+export async function hasRegisteredDevices(uid) {
+    if (!cachedIdToken) throw new Error('Not logged in');
+    const url = `${FIRESTORE_URL}/users/${uid}/devices?pageSize=1`;
+    const res = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${cachedIdToken}` },
+    });
+    const data = await res.json();
+    return (data.documents || []).length > 0;
+}