uwonbot 1.0.9 → 1.1.1

package/bin/uwonbot.js

@@ -13,7 +13,7 @@ showBanner();
 program
     .name('uwonbot')
     .description('Uwonbot AI Assistant — Your AI controls your computer')
-    .version('1.0.9');
+    .version('1.1.1');
 
 program
     .command('login')
@@ -44,19 +44,21 @@ program
     .command('chat [assistantName]')
     .description('Start chatting with an AI assistant')
     .option('-n, --name <name>', 'Assistant name to launch directly')
+    .option('-v, --voice', 'Enable hands-free voice input mode')
     .action(async (assistantName, opts) => {
         const config = getConfig();
         if (!config.get('uid')) {
             console.log('\n  ⚠️  Please log in first: uwonbot login\n');
             process.exit(1);
         }
+        const chatOpts = { voice: opts.voice || false };
         const targetName = opts.name || assistantName;
         if (targetName) {
-            await startChat(targetName);
+            await startChat(targetName, null, null, chatOpts);
         } else {
             const assistant = await selectAssistant();
             if (assistant) {
-                await startChat(null, assistant);
+                await startChat(null, assistant, null, chatOpts);
             } else {
                 const defaultBot = {
                     name: 'Uwonbot',
@@ -66,7 +68,7 @@ program
                     voiceStyle: 'male',
                     isDefaultBot: true,
                 };
-                await startChat(null, defaultBot);
+                await startChat(null, defaultBot, null, chatOpts);
             }
         }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uwonbot",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "description": "Uwonbot AI Assistant CLI — Your AI controls your computer",
   "main": "src/index.js",
   "bin": {

package/src/chat.js

@@ -7,6 +7,8 @@ import open from 'open';
 import { getConfig } from './config.js';
 import { sendToBrain } from './brain.js';
 import { showMiniBar } from './banner.js';
+import { printOrb, animateOrb } from './terminalOrb.js';
+import VoiceInput from './voiceInput.js';
 import {
     hasRegisteredDevices,
     createCLISession,
@@ -16,6 +18,40 @@ import {
 
 const WEB_APP_URL = 'https://chartapp-653e1.web.app';
 
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    return [
+        parseInt(h.substring(0, 2), 16) || 37,
+        parseInt(h.substring(2, 4), 16) || 99,
+        parseInt(h.substring(4, 6), 16) || 235,
+    ];
+}
+
+async function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+
+async function bootSequence(assistant, brainLabel, brainColor) {
+    const c = chalk.hex(brainColor);
+    const g = chalk.gray;
+    const w = chalk.white;
+
+    const steps = [
+        [300, `${g('  [SYS]')}  ${w('INITIATING SYSTEM I...')}`],
+        [300, `${g('  [SYS]')}  ${c(`NETWARE ${assistant.name.toUpperCase()} v1.0`)}`],
+        [400, `${g('  [SYS]')}  ${w('PROTOCOL: SCANNING...')}`],
+        [300, `${g('  [SYS]')}  ${w('RELEASING CONFIGURATION')}`],
+        [200, `${g('  [SYS]')}  ${w(`Brain: ${brainLabel} | API: connected`)}`],
+        [200, `${g('  [SYS]')}  ${w('Authentication verified.')}`],
+        [500, `${g('  [SYS]')}  ${chalk.green('All systems operational. Standing by.')}`],
+    ];
+
+    for (const [delay, text] of steps) {
+        await sleep(delay);
+        console.log(text);
+    }
+}
+
 async function requireBiometricAuth(uid) {
     try {
         const hasDevices = await hasRegisteredDevices(uid);
@@ -75,7 +111,7 @@ async function requireBiometricAuth(uid) {
     return false;
 }
 
-export async function startChat(assistantName, assistant, initialCommand) {
+export async function startChat(assistantName, assistant, initialCommand, options = {}) {
     const config = getConfig();
     const uid = config.get('uid');
     if (!uid) {
@@ -107,26 +143,85 @@ export async function startChat(assistantName, assistant, initialCommand) {
         : assistant.brain === 'gemini' ? '#8b5cf6'
         : '#2563eb';
 
+    const orbColorHex = assistant.orbColor || brainColor;
+    const orbRgb = hexToRgb(orbColorHex);
+
+    console.clear();
+    printOrb({
+        radius: 10,
+        color: orbRgb,
+        label: assistant.name.toUpperCase(),
+        status: '준비됨',
+    });
+
+    await bootSequence(assistant, brainLabel, brainColor);
+
+    const voiceMode = options.voice || false;
+
     console.log('');
-    console.log(chalk.hex('#2563eb')('  ╔══════════════════════════════════════════╗'));
-    console.log(chalk.hex('#2563eb')('  ║') + chalk.white.bold(`  ${assistant.avatar || '🤖'} ${assistant.name}`) + ' '.repeat(Math.max(1, 38 - assistant.name.length)) + chalk.hex('#2563eb')('║'));
-    console.log(chalk.hex('#2563eb')('  ║') + chalk.gray(`  Brain: `) + chalk.hex(brainColor)(brainLabel) + ' '.repeat(Math.max(1, 30 - brainLabel.length)) + chalk.hex('#2563eb')('║'));
-    console.log(chalk.hex('#2563eb')('  ║') + chalk.gray('  Type "exit" to quit, "clear" to reset   ') + chalk.hex('#2563eb')('║'));
-    console.log(chalk.hex('#2563eb')('  ╚══════════════════════════════════════════╝'));
+    console.log(chalk.gray('  ─────────────────────────────────────────'));
+    if (voiceMode) {
+        console.log(chalk.cyan('  🎙 음성 모드 활성화 — 말하면 자동 인식됩니다'));
+        console.log(chalk.gray('  텍스트 입력도 가능합니다'));
+    }
+    console.log(chalk.gray('  "exit" 종료 | "clear" 대화 초기화'));
+    console.log(chalk.gray('  ─────────────────────────────────────────'));
     console.log('');
 
     const messages = [];
-
-    if (initialCommand) {
-        await processMessage(initialCommand, messages, assistant, brainColor);
-    }
+    let voiceInput = null;
+    let processingVoice = false;
 
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
-        prompt: chalk.hex('#2563eb')('  You > '),
+        prompt: chalk.hex(brainColor)('  You > '),
     });
 
+    if (voiceMode) {
+        const apiKey = assistant.apiKey || process.env.GEMINI_API_KEY || '';
+        if (!apiKey) {
+            console.log(chalk.yellow('  ⚠ 음성 모드에는 API 키가 필요합니다 (음성→텍스트 변환에 Gemini 사용)'));
+            console.log(chalk.gray('  텍스트 입력으로 진행합니다.\n'));
+        } else {
+            voiceInput = new VoiceInput(apiKey);
+            const ok = await voiceInput.start({
+                onListening: () => {
+                    if (!processingVoice) {
+                        process.stdout.write(chalk.gray('  🎙 듣고 있습니다...') + '\r');
+                    }
+                },
+                onSpeechStart: () => {
+                    process.stdout.write('\x1b[2K\r');
+                    process.stdout.write(chalk.cyan('  🔴 음성 감지 중...') + '\r');
+                },
+                onSpeechEnd: () => {
+                    process.stdout.write('\x1b[2K\r');
+                    process.stdout.write(chalk.gray('  ⏳ 음성 인식 중...') + '\r');
+                },
+                onTranscript: async (text) => {
+                    if (processingVoice) return;
+                    processingVoice = true;
+                    process.stdout.write('\x1b[2K\r');
+                    console.log(chalk.hex(brainColor)(`  You (voice) > `) + chalk.white(text));
+                    rl.pause();
+                    await processMessage(text, messages, assistant, brainColor);
+                    processingVoice = false;
+                    rl.resume();
+                    rl.prompt();
+                },
+            });
+            if (!ok) {
+                voiceInput = null;
+                console.log(chalk.gray('  텍스트 입력으로 진행합니다.\n'));
+            }
+        }
+    }
+
+    if (initialCommand) {
+        await processMessage(initialCommand, messages, assistant, brainColor);
+    }
+
     rl.prompt();
 
     rl.on('line', async (line) => {
@@ -137,7 +232,8 @@ export async function startChat(assistantName, assistant, initialCommand) {
         }
 
         if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
-            console.log(chalk.gray('\n  Goodbye! 👋\n'));
+            if (voiceInput) voiceInput.stop();
+            console.log(chalk.gray('\n  Goodbye!\n'));
             rl.close();
             process.exit(0);
         }
@@ -149,17 +245,42 @@ export async function startChat(assistantName, assistant, initialCommand) {
             return;
         }
 
-        if (input.toLowerCase() === 'tools') {
-            console.log('');
-            console.log(chalk.white.bold('  Available Tools:'));
-            console.log(chalk.gray('  ────────────────'));
-            console.log('  📂 read_file, write_file, list_directory, create_directory');
-            console.log('  🗑️  delete_file, move_file, search_files');
-            console.log('  ⚙️  run_shell, install_package');
-            console.log('  🌐 open_url, open_application');
-            console.log('  📋 get_clipboard, set_clipboard');
-            console.log('  💻 system_info');
-            console.log('');
+        if (input.toLowerCase() === 'voice on') {
+            if (!voiceInput) {
+                const apiKey = assistant.apiKey || process.env.GEMINI_API_KEY || '';
+                if (apiKey) {
+                    voiceInput = new VoiceInput(apiKey);
+                    await voiceInput.start({
+                        onListening: () => {},
+                        onSpeechStart: () => process.stdout.write(chalk.cyan('\r  🔴 음성 감지 중...') + '\r'),
+                        onSpeechEnd: () => process.stdout.write(chalk.gray('\r  ⏳ 인식 중...') + '\r'),
+                        onTranscript: async (text) => {
+                            if (processingVoice) return;
+                            processingVoice = true;
+                            process.stdout.write('\x1b[2K\r');
+                            console.log(chalk.hex(brainColor)(`  You (voice) > `) + chalk.white(text));
+                            rl.pause();
+                            await processMessage(text, messages, assistant, brainColor);
+                            processingVoice = false;
+                            rl.resume();
+                            rl.prompt();
+                        },
+                    });
+                    console.log(chalk.green('  🎙 음성 모드 활성화'));
+                } else {
+                    console.log(chalk.yellow('  ⚠ 음성 모드에는 API 키가 필요합니다.'));
+                }
+            }
+            rl.prompt();
+            return;
+        }
+
+        if (input.toLowerCase() === 'voice off') {
+            if (voiceInput) {
+                voiceInput.stop();
+                voiceInput = null;
+                console.log(chalk.gray('  🔇 음성 모드 비활성화'));
+            }
             rl.prompt();
             return;
         }
@@ -171,6 +292,7 @@ export async function startChat(assistantName, assistant, initialCommand) {
     });
 
     rl.on('close', () => {
+        if (voiceInput) voiceInput.stop();
         process.exit(0);
     });
 }

package/src/terminalOrb.js

@@ -0,0 +1,232 @@
+import chalk from 'chalk';
+
+const SHADING_CHARS = ' .:-=+*#%@';
+
+/**
+ * Renders a 3D sphere in the terminal using ray-traced shading with true color.
+ * @param {object} opts
+ * @param {number} [opts.radius=10] - Sphere radius in character cells
+ * @param {number[]} [opts.color=[37,99,235]] - RGB base color
+ * @param {string} [opts.label] - Text label below the orb
+ * @param {string} [opts.status] - Status text below label
+ * @param {boolean} [opts.glow=true] - Enable glow effect
+ * @returns {string} The rendered orb as a string
+ */
+export function renderOrb(opts = {}) {
+    const radius = opts.radius || 10;
+    const [baseR, baseG, baseB] = opts.color || [37, 99, 235];
+    const label = opts.label || '';
+    const status = opts.status || '';
+    const glow = opts.glow !== false;
+
+    const width = radius * 2 + 4;
+    const height = radius + 2;
+    const lines = [];
+
+    const lightX = -0.4;
+    const lightY = -0.5;
+    const lightZ = 0.8;
+    const lightLen = Math.sqrt(lightX * lightX + lightY * lightY + lightZ * lightZ);
+    const lx = lightX / lightLen;
+    const ly = lightY / lightLen;
+    const lz = lightZ / lightLen;
+
+    for (let y = -radius; y <= radius; y++) {
+        let line = '';
+        const rowY = y / radius;
+
+        for (let x = -width / 2; x <= width / 2; x++) {
+            const rowX = x / (width / 2);
+            const distSq = rowX * rowX + rowY * rowY;
+
+            if (distSq > 1.0) {
+                if (glow && distSq < 1.5) {
+                    const glowIntensity = 1.0 - (distSq - 1.0) / 0.5;
+                    const gr = Math.round(baseR * glowIntensity * 0.3);
+                    const gg = Math.round(baseG * glowIntensity * 0.3);
+                    const gb = Math.round(baseB * glowIntensity * 0.3);
+                    line += chalk.rgb(gr, gg, gb)('·');
+                } else {
+                    line += ' ';
+                }
+                continue;
+            }
+
+            const nz = Math.sqrt(1 - distSq);
+            const nx = rowX;
+            const ny = rowY;
+
+            const diffuse = Math.max(0, nx * lx + ny * ly + nz * lz);
+
+            const rx = 2 * (nx * lx + ny * ly + nz * lz) * nx - lx;
+            const ry = 2 * (nx * lx + ny * ly + nz * lz) * ny - ly;
+            const rz = 2 * (nx * lx + ny * ly + nz * lz) * nz - lz;
+            const viewZ = 1.0;
+            const specular = Math.pow(Math.max(0, rz / Math.sqrt(rx * rx + ry * ry + rz * rz) * viewZ), 32);
+
+            const ambient = 0.12;
+            const intensity = Math.min(1.0, ambient + diffuse * 0.75 + specular * 0.5);
+
+            const r = Math.min(255, Math.round(baseR * intensity + specular * 180));
+            const g = Math.min(255, Math.round(baseG * intensity + specular * 180));
+            const b = Math.min(255, Math.round(baseB * intensity + specular * 180));
+
+            const charIdx = Math.min(SHADING_CHARS.length - 1, Math.round(intensity * (SHADING_CHARS.length - 1)));
+            const ch = SHADING_CHARS[charIdx];
+
+            line += chalk.rgb(r, g, b)(ch || ' ');
+        }
+        lines.push(line);
+    }
+
+    if (label) {
+        lines.push('');
+        const padded = label.length < width * 2
+            ? ' '.repeat(Math.max(0, Math.floor((width - label.length / 2)))) + label
+            : label;
+        lines.push(chalk.bold.white(padded));
+    }
+
+    if (status) {
+        const padded = status.length < width * 2
+            ? ' '.repeat(Math.max(0, Math.floor((width - status.length / 2)))) + status
+            : status;
+        lines.push(chalk.gray(padded));
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Animated spinning orb in the terminal.
+ * @param {object} opts
+ * @param {number[]} [opts.color=[37,99,235]]
+ * @param {string} [opts.label]
+ * @param {string} [opts.status]
+ * @param {number} [opts.radius=10]
+ * @param {number} [opts.fps=12]
+ * @returns {{ update(opts), stop() }}
+ */
+export function animateOrb(opts = {}) {
+    const radius = opts.radius || 10;
+    const fps = opts.fps || 12;
+    let color = opts.color || [37, 99, 235];
+    let label = opts.label || '';
+    let statusText = opts.status || '';
+    let frame = 0;
+    let running = true;
+    const totalLines = (radius * 2 + 3) + (label ? 1 : 0) + (statusText ? 1 : 0) + 1;
+
+    function draw() {
+        const angle = (frame * 0.05);
+        const lightX = Math.cos(angle) * 0.6;
+        const lightY = -0.5;
+        const lightZ = Math.sin(angle) * 0.4 + 0.6;
+        const lightLen = Math.sqrt(lightX * lightX + lightY * lightY + lightZ * lightZ);
+
+        const width = radius * 2 + 4;
+        const lines = [];
+
+        for (let y = -radius; y <= radius; y++) {
+            let line = '  ';
+            const rowY = y / radius;
+
+            for (let x = -width / 2; x <= width / 2; x++) {
+                const rowX = x / (width / 2);
+                const distSq = rowX * rowX + rowY * rowY;
+
+                if (distSq > 1.0) {
+                    if (distSq < 1.4) {
+                        const glowIntensity = 1.0 - (distSq - 1.0) / 0.4;
+                        const pulse = 0.3 + Math.sin(frame * 0.15) * 0.1;
+                        const gr = Math.round(color[0] * glowIntensity * pulse);
+                        const gg = Math.round(color[1] * glowIntensity * pulse);
+                        const gb = Math.round(color[2] * glowIntensity * pulse);
+                        line += chalk.rgb(gr, gg, gb)('·');
+                    } else {
+                        line += ' ';
+                    }
+                    continue;
+                }
+
+                const nz = Math.sqrt(1 - distSq);
+                const nx = rowX;
+                const ny = rowY;
+
+                const lx = lightX / lightLen;
+                const ly = lightY / lightLen;
+                const lz = lightZ / lightLen;
+
+                const diffuse = Math.max(0, nx * lx + ny * ly + nz * lz);
+                const dot = nx * lx + ny * ly + nz * lz;
+                const rz = 2 * dot * nz - lz;
+                const specular = Math.pow(Math.max(0, rz), 40);
+
+                const ambient = 0.08;
+                const intensity = Math.min(1.0, ambient + diffuse * 0.7 + specular * 0.6);
+
+                const r = Math.min(255, Math.round(color[0] * intensity + specular * 200));
+                const g = Math.min(255, Math.round(color[1] * intensity + specular * 200));
+                const b = Math.min(255, Math.round(color[2] * intensity + specular * 200));
+
+                const charIdx = Math.min(SHADING_CHARS.length - 1, Math.round(intensity * (SHADING_CHARS.length - 1)));
+                line += chalk.rgb(r, g, b)(SHADING_CHARS[charIdx] || ' ');
+            }
+            lines.push(line);
+        }
+
+        if (label) {
+            lines.push('');
+            const pad = Math.max(0, Math.floor((width + 2 - label.length) / 2));
+            lines.push(' '.repeat(pad) + chalk.bold.white(label));
+        }
+        if (statusText) {
+            const pad = Math.max(0, Math.floor((width + 2 - statusText.length) / 2));
+            lines.push(' '.repeat(pad) + chalk.gray(statusText));
+        }
+
+        return lines.join('\n');
+    }
+
+    let prevLineCount = 0;
+
+    const interval = setInterval(() => {
+        if (!running) return;
+        frame++;
+
+        if (prevLineCount > 0) {
+            process.stdout.write(`\x1b[${prevLineCount}A\x1b[J`);
+        }
+
+        const output = draw();
+        process.stdout.write(output + '\n');
+        prevLineCount = output.split('\n').length;
+    }, 1000 / fps);
+
+    const output = draw();
+    process.stdout.write(output + '\n');
+    prevLineCount = output.split('\n').length;
+
+    return {
+        update(newOpts) {
+            if (newOpts.color) color = newOpts.color;
+            if (newOpts.label !== undefined) label = newOpts.label;
+            if (newOpts.status !== undefined) statusText = newOpts.status;
+        },
+        stop() {
+            running = false;
+            clearInterval(interval);
+        },
+    };
+}
+
+/**
+ * Prints a static orb once.
+ */
+export function printOrb(opts = {}) {
+    console.log('');
+    console.log(renderOrb(opts));
+    console.log('');
+}
+
+export default { renderOrb, animateOrb, printOrb };

package/src/voiceInput.js

@@ -0,0 +1,185 @@
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+
+const SILENCE_THRESHOLD = 0.02;
+const SILENCE_DURATION_MS = 1200;
+const MIN_SPEECH_MS = 400;
+const SAMPLE_RATE = 16000;
+const BITS_PER_SAMPLE = 16;
+const CHANNELS = 1;
+
+function createWavHeader(dataLength) {
+    const header = Buffer.alloc(44);
+    header.write('RIFF', 0);
+    header.writeUInt32LE(36 + dataLength, 4);
+    header.write('WAVE', 8);
+    header.write('fmt ', 12);
+    header.writeUInt32LE(16, 16);
+    header.writeUInt16LE(1, 20);
+    header.writeUInt16LE(CHANNELS, 22);
+    header.writeUInt32LE(SAMPLE_RATE, 24);
+    header.writeUInt32LE(SAMPLE_RATE * CHANNELS * (BITS_PER_SAMPLE / 8), 28);
+    header.writeUInt16LE(CHANNELS * (BITS_PER_SAMPLE / 8), 32);
+    header.writeUInt16LE(BITS_PER_SAMPLE, 34);
+    header.write('data', 36);
+    header.writeUInt32LE(dataLength, 40);
+    return header;
+}
+
+function getAmplitude(buf) {
+    let max = 0;
+    for (let i = 0; i < buf.length - 1; i += 2) {
+        const sample = buf.readInt16LE(i);
+        const abs = Math.abs(sample) / 32768;
+        if (abs > max) max = abs;
+    }
+    return max;
+}
+
+async function transcribeWithGemini(wavBuffer, apiKey) {
+    const base64Audio = wavBuffer.toString('base64');
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${encodeURIComponent(apiKey)}`;
+
+    const body = {
+        contents: [{
+            parts: [
+                { text: 'Transcribe the following audio exactly as spoken. Output ONLY the transcribed text, nothing else. If the audio is in Korean, output Korean. If in English, output English. If mixed, output mixed.' },
+                { inlineData: { mimeType: 'audio/wav', data: base64Audio } },
+            ],
+        }],
+        generationConfig: { maxOutputTokens: 512, temperature: 0.1 },
+    };
+
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(err?.error?.message || `Transcription failed (${res.status})`);
+    }
+
+    const data = await res.json();
+    const text = data?.candidates?.[0]?.content?.parts?.[0]?.text;
+    return text?.trim() || '';
+}
+
+export default class VoiceInput {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.mic = null;
+        this.micInstance = null;
+        this.running = false;
+        this.onTranscript = null;
+        this.onListening = null;
+        this.onSpeechStart = null;
+        this.onSpeechEnd = null;
+    }
+
+    async start({ onTranscript, onListening, onSpeechStart, onSpeechEnd }) {
+        this.onTranscript = onTranscript;
+        this.onListening = onListening;
+        this.onSpeechStart = onSpeechStart;
+        this.onSpeechEnd = onSpeechEnd;
+
+        let micModule;
+        try {
+            micModule = await import('mic');
+            this.mic = micModule.default || micModule;
+        } catch {
+            console.log(chalk.yellow('\n  ⚠ mic 모듈이 없습니다. 음성 모드를 사용하려면:'));
+            console.log(chalk.gray('    npm install -g mic'));
+            console.log(chalk.gray('    brew install sox  (macOS)\n'));
+            return false;
+        }
+
+        this.running = true;
+        this._listen();
+        return true;
+    }
+
+    _listen() {
+        const micInstance = this.mic({
+            rate: String(SAMPLE_RATE),
+            channels: String(CHANNELS),
+            bitwidth: String(BITS_PER_SAMPLE),
+            encoding: 'signed-integer',
+            endian: 'little',
+            device: 'default',
+        });
+
+        this.micInstance = micInstance;
+        const stream = micInstance.getAudioStream();
+
+        let speechChunks = [];
+        let isSpeaking = false;
+        let silenceStart = null;
+        let speechStart = null;
+
+        this.onListening?.();
+
+        stream.on('data', (buf) => {
+            if (!this.running) return;
+            const amp = getAmplitude(buf);
+
+            if (amp > SILENCE_THRESHOLD) {
+                if (!isSpeaking) {
+                    isSpeaking = true;
+                    speechStart = Date.now();
+                    speechChunks = [];
+                    this.onSpeechStart?.();
+                }
+                silenceStart = null;
+                speechChunks.push(Buffer.from(buf));
+            } else if (isSpeaking) {
+                speechChunks.push(Buffer.from(buf));
+                if (!silenceStart) silenceStart = Date.now();
+
+                if (Date.now() - silenceStart >= SILENCE_DURATION_MS) {
+                    const duration = Date.now() - speechStart;
+                    isSpeaking = false;
+                    silenceStart = null;
+                    this.onSpeechEnd?.();
+
+                    if (duration >= MIN_SPEECH_MS && speechChunks.length > 0) {
+                        this._processAudio(speechChunks);
+                    }
+                    speechChunks = [];
+                }
+            }
+        });
+
+        stream.on('error', (err) => {
+            if (this.running) {
+                console.log(chalk.red(`  마이크 오류: ${err.message}`));
+            }
+        });
+
+        micInstance.start();
+    }
+
+    async _processAudio(chunks) {
+        const pcmData = Buffer.concat(chunks);
+        const wavHeader = createWavHeader(pcmData.length);
+        const wavBuffer = Buffer.concat([wavHeader, pcmData]);
+
+        try {
+            const text = await transcribeWithGemini(wavBuffer, this.apiKey);
+            if (text) {
+                this.onTranscript?.(text);
+            }
+        } catch (err) {
+            console.log(chalk.red(`  음성 인식 오류: ${err.message}`));
+        }
+    }
+
+    stop() {
+        this.running = false;
+        if (this.micInstance) {
+            try { this.micInstance.stop(); } catch {}
+            this.micInstance = null;
+        }
+    }
+}