uwonbot 1.0.0

package/README.md

@@ -0,0 +1,49 @@
+# Uwonbot CLI
+
+> Your AI controls your computer — AI 어시스턴트가 컴퓨터를 제어합니다
+
+Uwonbot은 터미널에서 AI 어시스턴트와 대화하고, 업무를 자동화할 수 있는 CLI 도구입니다.
+
+## Installation
+
+```bash
+npm install -g uwonbot
+```
+
+## Quick Start
+
+```bash
+# 로그인
+uwonbot login
+
+# AI 어시스턴트와 대화
+uwonbot chat
+
+# 특정 어시스턴트와 대화
+uwonbot chat "assistant-name"
+
+# AI에게 작업 요청
+uwonbot run "브라우저에서 검색해줘"
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `uwonbot login` | Uwonbot 계정으로 로그인 |
+| `uwonbot logout` | 로그아웃 |
+| `uwonbot whoami` | 현재 로그인된 사용자 확인 |
+| `uwonbot assistants` | AI 어시스턴트 목록 보기 |
+| `uwonbot chat` | AI 어시스턴트와 대화 시작 |
+| `uwonbot run "..."` | AI에게 작업 실행 요청 |
+
+## Features
+
+- AI 어시스턴트와 실시간 대화
+- 컴퓨터 제어 자동화 (브라우저, 파일 등)
+- 200+ 서비스 연동 (Excel, Google Sheets, Slack 등)
+- 코드 없이 업무 자동화
+
+## License
+
+MIT

package/bin/uwonbot.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { showBanner } from '../src/banner.js';
+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';
+
+showBanner();
+
+program
+    .name('uwonbot')
+    .description('Uwonbot AI Assistant — Your AI controls your computer')
+    .version('1.0.0');
+
+program
+    .command('login')
+    .description('Log in to your Uwonbot account')
+    .action(loginCommand);
+
+program
+    .command('logout')
+    .description('Log out of your Uwonbot account')
+    .action(logoutCommand);
+
+program
+    .command('whoami')
+    .description('Show current logged-in user')
+    .action(whoamiCommand);
+
+program
+    .command('assistants')
+    .description('List your AI assistants')
+    .action(listAssistants);
+
+program
+    .command('chat [assistantName]')
+    .description('Start chatting with an AI assistant')
+    .action(async (assistantName) => {
+        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);
+        } else {
+            const assistant = await selectAssistant();
+            if (assistant) {
+                await startChat(null, assistant);
+            }
+        }
+    });
+
+program
+    .command('run <command>')
+    .description('Ask your assistant to run a task')
+    .action(async (command) => {
+        const config = getConfig();
+        if (!config.get('uid')) {
+            console.log('\n  ⚠️  Please log in first: uwonbot login\n');
+            process.exit(1);
+        }
+        const assistant = await selectAssistant();
+        if (assistant) {
+            await startChat(null, assistant, command);
+        }
+    });
+
+if (process.argv.length <= 2) {
+    const config = getConfig();
+    const uid = config.get('uid');
+    if (uid) {
+        const email = config.get('email') || 'unknown';
+        console.log(`  Logged in as: ${email}`);
+        console.log('');
+        console.log('  Commands:');
+        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 logout         Log out');
+        console.log('');
+    } else {
+        console.log('  Get started:');
+        console.log('    uwonbot login          Log in to your account');
+        console.log('    uwonbot chat           Start chatting after login');
+        console.log('');
+    }
+} else {
+    program.parse();
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "uwonbot",
+  "version": "1.0.0",
+  "description": "Uwonbot AI Assistant CLI — Your AI controls your computer",
+  "main": "src/index.js",
+  "bin": {
+    "uwonbot": "./bin/uwonbot.js"
+  },
+  "type": "module",
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "scripts": {
+    "start": "node bin/uwonbot.js",
+    "dev": "node bin/uwonbot.js"
+  },
+  "keywords": ["ai", "assistant", "automation", "cli", "computer-use"],
+  "author": "Uwonbot",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/uwonbot/uwonbot-cli"
+  },
+  "dependencies": {
+    "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"
+  }
+}

package/src/assistants.js

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { getConfig } from './config.js';
+import { fetchAssistants } from './firebase-client.js';
+
+export async function listAssistants() {
+    const config = getConfig();
+    const uid = config.get('uid');
+    if (!uid) {
+        console.log(chalk.yellow('\n  ⚠️  Please log in first: uwonbot login\n'));
+        return;
+    }
+
+    const spinner = ora('Fetching assistants...').start();
+    try {
+        const assistants = await fetchAssistants(uid);
+        spinner.stop();
+
+        if (assistants.length === 0) {
+            console.log('');
+            console.log(chalk.yellow('  No assistants found.'));
+            console.log(chalk.gray('  Create one at https://chartapp-653e1.web.app/assistant/create'));
+            console.log('');
+            return;
+        }
+
+        console.log('');
+        console.log(chalk.white.bold('  Your AI Assistants'));
+        console.log(chalk.gray('  ──────────────────'));
+        assistants.forEach((a, i) => {
+            const brainColor = a.brain === 'claude' ? '#f97316' : a.brain === 'openai' ? '#10b981' : a.brain === 'gemini' ? '#8b5cf6' : '#2563eb';
+            const brainLabel = a.brain === 'default' ? 'Uwonbot' : a.brain.charAt(0).toUpperCase() + a.brain.slice(1);
+            console.log(`  ${chalk.gray(`${i + 1}.`)} ${a.avatar || '🤖'} ${chalk.white.bold(a.name)} ${chalk.hex(brainColor)(`[${brainLabel}]`)}`);
+            if (a.description) {
+                console.log(`     ${chalk.gray(a.description)}`);
+            }
+            const scopes = (a.scope || []).join(', ');
+            if (scopes) {
+                console.log(`     ${chalk.gray('Scope:')} ${scopes}`);
+            }
+        });
+        console.log('');
+        console.log(chalk.gray('  Use: uwonbot chat   — to start chatting with an assistant'));
+        console.log('');
+    } catch (err) {
+        spinner.fail(chalk.red('Failed to fetch assistants'));
+        console.log(chalk.red(`  ${err.message}`));
+    }
+}
+
+export async function selectAssistant() {
+    const config = getConfig();
+    const uid = config.get('uid');
+    if (!uid) {
+        console.log(chalk.yellow('\n  ⚠️  Please log in first: uwonbot login\n'));
+        return null;
+    }
+
+    const spinner = ora('Loading assistants...').start();
+    try {
+        const assistants = await fetchAssistants(uid);
+        spinner.stop();
+
+        const choices = [
+            { name: `🌐 Uwonbot Guide (Platform usage help)`, value: { id: '__uwonbot__', name: 'Uwonbot Guide', brain: 'default' } },
+            ...assistants.map(a => ({
+                name: `${a.avatar || '🤖'} ${a.name} [${a.brain === 'default' ? 'Uwonbot' : a.brain}]`,
+                value: a,
+            })),
+            new inquirer.Separator(),
+            { name: '+ Create new assistant (opens browser)', value: '__create__' },
+        ];
+
+        const { selected } = await inquirer.prompt([{
+            type: 'list',
+            name: 'selected',
+            message: 'Choose an assistant:',
+            choices,
+        }]);
+
+        if (selected === '__create__') {
+            const open = (await import('open')).default;
+            await open('https://chartapp-653e1.web.app/assistant/create');
+            console.log(chalk.gray('  Opening browser to create a new assistant...'));
+            return null;
+        }
+
+        config.set('activeAssistantId', selected.id);
+        config.set('activeAssistantName', selected.name);
+        return selected;
+    } catch (err) {
+        spinner.fail(chalk.red('Failed to load assistants'));
+        console.log(chalk.red(`  ${err.message}`));
+        return null;
+    }
+}

package/src/auth.js

@@ -0,0 +1,92 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { getConfig } from './config.js';
+import { loginWithEmail } from './firebase-client.js';
+
+export async function loginCommand() {
+    const config = getConfig();
+    const existing = config.get('uid');
+    if (existing) {
+        console.log(chalk.yellow(`  Already logged in as ${config.get('email')}`));
+        const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Log out and log in with a different account?',
+            default: false,
+        }]);
+        if (!confirm) return;
+        config.clear();
+    }
+
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'email',
+            message: 'Email:',
+            validate: v => v.includes('@') || 'Please enter a valid email',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+            mask: '*',
+            validate: v => v.length >= 6 || 'Password must be at least 6 characters',
+        },
+    ]);
+
+    const spinner = ora('Logging in...').start();
+    try {
+        const user = await loginWithEmail(answers.email, answers.password);
+        config.set('uid', user.uid);
+        config.set('email', user.email);
+        config.set('displayName', user.displayName);
+        config.set('idToken', user.idToken);
+        config.set('refreshToken', user.refreshToken);
+        spinner.succeed(chalk.green(`Logged in as ${user.email}`));
+        console.log('');
+        console.log(chalk.gray('  Next: uwonbot chat   — Start chatting with your AI assistant'));
+        console.log(chalk.gray('        uwonbot assistants — List your assistants'));
+        console.log('');
+    } catch (err) {
+        spinner.fail(chalk.red('Login failed'));
+        if (err.code === 'auth/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') {
+            console.log(chalk.yellow('  Invalid password. Try again.'));
+        } else {
+            console.log(chalk.red(`  ${err.message}`));
+        }
+    }
+}
+
+export async function logoutCommand() {
+    const config = getConfig();
+    const email = config.get('email');
+    config.clear();
+    if (email) {
+        console.log(chalk.green(`  Logged out from ${email}`));
+    } else {
+        console.log(chalk.gray('  Not logged in'));
+    }
+}
+
+export async function whoamiCommand() {
+    const config = getConfig();
+    const uid = config.get('uid');
+    if (!uid) {
+        console.log(chalk.gray('  Not logged in. Run: uwonbot login'));
+        return;
+    }
+    console.log('');
+    console.log(chalk.white.bold('  Account Info'));
+    console.log(chalk.gray('  ─────────────'));
+    console.log(`  Email: ${chalk.cyan(config.get('email'))}`);
+    console.log(`  Name:  ${config.get('displayName') || chalk.gray('(not set)')}`);
+    console.log(`  UID:   ${chalk.gray(uid)}`);
+    const activeAssistant = config.get('activeAssistantName');
+    if (activeAssistant) {
+        console.log(`  Active Assistant: ${chalk.hex('#2563eb')(activeAssistant)}`);
+    }
+    console.log('');
+}

package/src/banner.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+
+export function showBanner() {
+    const blue = chalk.hex('#2563eb');
+    const cyan = chalk.hex('#06b6d4');
+    const gray = chalk.hex('#6b7280');
+    const white = chalk.white.bold;
+
+    console.log('');
+    console.log(blue('  ╔══════════════════════════════════════════════════════════════╗'));
+    console.log(blue('  ║                                                              ║'));
+    console.log(blue('  ║') + cyan('   ██╗   ██╗██╗    ██╗ ██████╗ ███╗   ██╗██████╗  ██████╗ ████████╗') + blue('  ║'));
+    console.log(blue('  ║') + cyan('   ██║   ██║██║    ██║██╔═══██╗████╗  ██║██╔══██╗██╔═══██╗╚══██╔══╝') + blue('  ║'));
+    console.log(blue('  ║') + white('   ██║   ██║██║ █╗ ██║██║   ██║██╔██╗ ██║██████╔╝██║   ██║   ██║   ') + blue('  ║'));
+    console.log(blue('  ║') + white('   ██║   ██║██║███╗██║██║   ██║██║╚██╗██║██╔══██╗██║   ██║   ██║   ') + blue('  ║'));
+    console.log(blue('  ║') + cyan('   ╚██████╔╝╚███╔███╔╝╚██████╔╝██║ ╚████║██████╔╝╚██████╔╝   ██║   ') + blue('  ║'));
+    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('  ║                                                              ║'));
+    console.log(blue('  ╚══════════════════════════════════════════════════════════════╝'));
+    console.log('');
+}
+
+export function showMiniBar() {
+    const blue = chalk.hex('#2563eb');
+    console.log(blue('  ─── UWONBOT ───'));
+}

package/src/brain.js

@@ -0,0 +1,231 @@
+import fetch from 'node-fetch';
+import chalk from 'chalk';
+import { executeTool, getToolsForProvider } from './tools.js';
+
+const GEMINI_BASE = 'https://generativelanguage.googleapis.com/v1beta/models';
+
+function buildSystemPrompt(assistant) {
+    const base = assistant.systemPrompt || `You are ${assistant.name || 'Uwonbot'}, an AI assistant.`;
+    return `${base}
+
+You have full access to the user's computer through tools. You can:
+- Read, write, create, delete, and move files
+- Execute shell commands (install packages, run scripts, etc.)
+- List directories and search files
+- Open URLs and applications
+- Access the clipboard
+- Get system information
+
+IMPORTANT RULES:
+1. Always confirm before performing destructive operations (deleting files, overwriting, etc.)
+2. Explain what you're about to do before using tools
+3. If a command fails, explain why and suggest alternatives
+4. Be concise but informative in your responses
+5. Use tools proactively to help the user accomplish their tasks`;
+}
+
+async function callGemini(apiKey, model, messages, systemPrompt) {
+    const modelName = model || 'gemini-2.0-flash';
+    const tools = getToolsForProvider('gemini');
+
+    const contents = messages.map(m => ({
+        role: m.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: m.content }],
+    }));
+
+    const body = {
+        contents,
+        systemInstruction: { parts: [{ text: systemPrompt }] },
+        tools: [{ functionDeclarations: tools }],
+        generationConfig: { maxOutputTokens: 8192, temperature: 0.7 },
+    };
+
+    const url = `${GEMINI_BASE}/${modelName}:generateContent?key=${encodeURIComponent(apiKey)}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+        const errData = await res.json().catch(() => ({}));
+        throw new Error(`Gemini API error ${res.status}: ${errData?.error?.message || 'Unknown'}`);
+    }
+
+    const data = await res.json();
+    const candidate = data?.candidates?.[0];
+    if (!candidate) throw new Error('No response from Gemini');
+
+    const parts = candidate.content?.parts || [];
+    const textParts = parts.filter(p => p.text).map(p => p.text).join('');
+    const functionCalls = parts.filter(p => p.functionCall).map(p => p.functionCall);
+
+    return { text: textParts, functionCalls, provider: 'gemini' };
+}
+
+async function callOpenAI(apiKey, model, messages, systemPrompt) {
+    const modelName = model || 'gpt-4o';
+    const tools = getToolsForProvider('openai');
+
+    const apiMessages = [
+        { role: 'system', content: systemPrompt },
+        ...messages,
+    ];
+
+    const body = {
+        model: modelName,
+        messages: apiMessages,
+        tools,
+        max_tokens: 4096,
+        temperature: 0.7,
+    };
+
+    const res = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+        const errData = await res.json().catch(() => ({}));
+        throw new Error(`OpenAI API error ${res.status}: ${errData?.error?.message || 'Unknown'}`);
+    }
+
+    const data = await res.json();
+    const choice = data.choices?.[0];
+    if (!choice) throw new Error('No response from OpenAI');
+
+    const msg = choice.message;
+    const toolCalls = (msg.tool_calls || []).map(tc => ({
+        id: tc.id,
+        name: tc.function.name,
+        args: JSON.parse(tc.function.arguments || '{}'),
+    }));
+
+    return { text: msg.content || '', toolCalls, provider: 'openai', rawMessage: msg };
+}
+
+async function callClaude(apiKey, model, messages, systemPrompt) {
+    const modelName = model || 'claude-sonnet-4-20250514';
+    const tools = getToolsForProvider('claude');
+
+    const apiMessages = messages.map(m => ({
+        role: m.role,
+        content: m.content,
+    }));
+
+    const body = {
+        model: modelName,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: apiMessages,
+        tools,
+    };
+
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+        const errData = await res.json().catch(() => ({}));
+        throw new Error(`Claude API error ${res.status}: ${errData?.error?.message || 'Unknown'}`);
+    }
+
+    const data = await res.json();
+    const textBlocks = (data.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
+    const toolUseBlocks = (data.content || []).filter(b => b.type === 'tool_use').map(b => ({
+        id: b.id,
+        name: b.name,
+        args: b.input,
+    }));
+
+    return { text: textBlocks, toolCalls: toolUseBlocks, provider: 'claude', stopReason: data.stop_reason };
+}
+
+async function handleToolCalls(result, apiKey, model, messages, systemPrompt, assistant, depth = 0) {
+    if (depth > 10) return result.text || '(Max tool depth reached)';
+
+    if (result.provider === 'gemini' && result.functionCalls?.length > 0) {
+        let allText = result.text || '';
+        for (const fc of result.functionCalls) {
+            console.log(chalk.hex('#8b5cf6')(`  🔧 Tool: ${fc.name}`));
+            const toolResult = await executeTool(fc.name, fc.args || {});
+            console.log(chalk.gray(`  ✓ Done`));
+
+            messages.push({ role: 'assistant', content: allText || `Using tool: ${fc.name}` });
+            messages.push({ role: 'user', content: `Tool result for ${fc.name}: ${JSON.stringify(toolResult)}` });
+
+            const nextResult = await callGemini(apiKey, model, messages, systemPrompt);
+            return handleToolCalls(nextResult, apiKey, model, messages, systemPrompt, assistant, depth + 1);
+        }
+    }
+
+    if (result.provider === 'openai' && result.toolCalls?.length > 0) {
+        messages.push(result.rawMessage);
+        for (const tc of result.toolCalls) {
+            console.log(chalk.hex('#10b981')(`  🔧 Tool: ${tc.name}`));
+            const toolResult = await executeTool(tc.name, tc.args);
+            console.log(chalk.gray(`  ✓ Done`));
+            messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(toolResult) });
+        }
+        const nextResult = await callOpenAI(apiKey, model, messages, systemPrompt);
+        return handleToolCalls(nextResult, apiKey, model, messages, systemPrompt, assistant, depth + 1);
+    }
+
+    if (result.provider === 'claude' && result.toolCalls?.length > 0) {
+        const contentBlocks = [];
+        if (result.text) contentBlocks.push({ type: 'text', text: result.text });
+        for (const tc of result.toolCalls) {
+            contentBlocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.args });
+        }
+        messages.push({ role: 'assistant', content: contentBlocks });
+
+        const toolResults = [];
+        for (const tc of result.toolCalls) {
+            console.log(chalk.hex('#f97316')(`  🔧 Tool: ${tc.name}`));
+            const toolResult = await executeTool(tc.name, tc.args);
+            console.log(chalk.gray(`  ✓ Done`));
+            toolResults.push({ type: 'tool_result', tool_use_id: tc.id, content: JSON.stringify(toolResult) });
+        }
+        messages.push({ role: 'user', content: toolResults });
+
+        const nextResult = await callClaude(apiKey, model, messages, systemPrompt);
+        return handleToolCalls(nextResult, apiKey, model, messages, systemPrompt, assistant, depth + 1);
+    }
+
+    return result.text || '(No response)';
+}
+
+export async function sendToBrain(assistant, messages, userMessage) {
+    const brain = assistant.brain || 'default';
+    const apiKey = assistant.apiKey || '';
+    const model = assistant.model || '';
+    const systemPrompt = buildSystemPrompt(assistant);
+
+    messages.push({ role: 'user', content: userMessage });
+
+    let result;
+    if (brain === 'openai') {
+        result = await callOpenAI(apiKey, model, messages, systemPrompt);
+    } else if (brain === 'claude') {
+        result = await callClaude(apiKey, model, messages, systemPrompt);
+    } else {
+        const key = apiKey || process.env.GEMINI_API_KEY || '';
+        if (!key) throw new Error('No API key. Set one in your assistant settings or GEMINI_API_KEY env var.');
+        result = await callGemini(key, model, messages, systemPrompt);
+    }
+
+    const finalText = await handleToolCalls(result, apiKey, model, messages, systemPrompt, assistant);
+
+    messages.push({ role: 'assistant', content: finalText });
+    return finalText;
+}

package/src/chat.js

@@ -0,0 +1,127 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import readline from 'readline';
+import { getConfig } from './config.js';
+import { sendToBrain } from './brain.js';
+import { showMiniBar } from './banner.js';
+
+export async function startChat(assistantName, assistant, initialCommand) {
+    const config = getConfig();
+    const uid = config.get('uid');
+    if (!uid) {
+        console.log(chalk.yellow('\n  ⚠️  Please log in first: uwonbot login\n'));
+        return;
+    }
+
+    if (!assistant) {
+        console.log(chalk.yellow('\n  No assistant selected.\n'));
+        return;
+    }
+
+    const brainLabel = assistant.brain === 'default' ? 'Uwonbot (Gemini)'
+        : assistant.brain === 'openai' ? 'OpenAI GPT'
+        : assistant.brain === 'claude' ? 'Anthropic Claude'
+        : assistant.brain === 'gemini' ? 'Google Gemini'
+        : assistant.brain;
+
+    const brainColor = assistant.brain === 'claude' ? '#f97316'
+        : assistant.brain === 'openai' ? '#10b981'
+        : assistant.brain === 'gemini' ? '#8b5cf6'
+        : '#2563eb';
+
+    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('');
+
+    const messages = [];
+
+    if (initialCommand) {
+        await processMessage(initialCommand, messages, assistant, brainColor);
+    }
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk.hex('#2563eb')('  You > '),
+    });
+
+    rl.prompt();
+
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+
+        if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+            console.log(chalk.gray('\n  Goodbye! 👋\n'));
+            rl.close();
+            process.exit(0);
+        }
+
+        if (input.toLowerCase() === 'clear') {
+            messages.length = 0;
+            console.log(chalk.gray('  Chat cleared.\n'));
+            rl.prompt();
+            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('');
+            rl.prompt();
+            return;
+        }
+
+        rl.pause();
+        await processMessage(input, messages, assistant, brainColor);
+        rl.resume();
+        rl.prompt();
+    });
+
+    rl.on('close', () => {
+        process.exit(0);
+    });
+}
+
+async function processMessage(input, messages, assistant, brainColor) {
+    const spinner = ora({
+        text: chalk.gray('Thinking...'),
+        spinner: 'dots',
+        color: 'blue',
+    }).start();
+
+    try {
+        const reply = await sendToBrain(assistant, messages, input);
+        spinner.stop();
+
+        console.log('');
+        console.log(chalk.hex(brainColor)(`  ${assistant.avatar || '🤖'} ${assistant.name} >`));
+        const lines = reply.split('\n');
+        for (const line of lines) {
+            console.log(chalk.white(`  ${line}`));
+        }
+        console.log('');
+    } catch (err) {
+        spinner.stop();
+        console.log(chalk.red(`\n  ❌ Error: ${err.message}\n`));
+        if (err.message.includes('API key') || err.message.includes('api key')) {
+            console.log(chalk.yellow('  Make sure your assistant has a valid API key configured.'));
+            console.log(chalk.gray('  Update it at: https://chartapp-653e1.web.app/assistant/create\n'));
+        }
+    }
+}

package/src/config.js

@@ -0,0 +1,21 @@
+import Conf from 'conf';
+
+let _config = null;
+
+export function getConfig() {
+    if (!_config) {
+        _config = new Conf({
+            projectName: 'uwonbot',
+            schema: {
+                uid: { type: 'string', default: '' },
+                email: { type: 'string', default: '' },
+                displayName: { type: 'string', default: '' },
+                idToken: { type: 'string', default: '' },
+                refreshToken: { type: 'string', default: '' },
+                activeAssistantId: { type: 'string', default: '' },
+                activeAssistantName: { type: 'string', default: '' },
+            },
+        });
+    }
+    return _config;
+}

package/src/firebase-client.js

@@ -0,0 +1,53 @@
+import { initializeApp } from 'firebase/app';
+import { getAuth, signInWithEmailAndPassword, signInWithCustomToken } from 'firebase/auth';
+import { getFirestore, collection, getDocs, doc, getDoc, query, orderBy } from 'firebase/firestore';
+
+const firebaseConfig = {
+    apiKey: "AIzaSyCVq7IdMZCfWqFbd5gBle5JmMX5cVJx68o",
+    authDomain: "chartapp-653e1.firebaseapp.com",
+    projectId: "chartapp-653e1",
+    storageBucket: "chartapp-653e1.firebasestorage.app",
+    messagingSenderId: "273874051709",
+    appId: "1:273874051709:web:f31e4b40dacb3a0bc76c88",
+};
+
+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 };
+}
+
+export async function loginWithEmail(email, password) {
+    const { auth } = getFirebaseApp();
+    const cred = await signInWithEmailAndPassword(auth, email, password);
+    return {
+        uid: cred.user.uid,
+        email: cred.user.email,
+        displayName: cred.user.displayName || '',
+        idToken: await cred.user.getIdToken(),
+        refreshToken: cred.user.refreshToken,
+    };
+}
+
+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() }));
+}
+
+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() };
+}

package/src/index.js

@@ -0,0 +1,6 @@
+export { showBanner } from './banner.js';
+export { loginCommand, logoutCommand, whoamiCommand } from './auth.js';
+export { listAssistants, selectAssistant } from './assistants.js';
+export { startChat } from './chat.js';
+export { executeTool, TOOL_DEFINITIONS } from './tools.js';
+export { sendToBrain } from './brain.js';

package/src/tools.js

@@ -0,0 +1,420 @@
+import { execSync, exec } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+
+const TOOL_DEFINITIONS = [
+    {
+        name: 'run_shell',
+        description: 'Execute a shell command on the user\'s computer. Can install packages, run scripts, manage processes, etc. Returns stdout and stderr.',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'The shell command to execute' },
+                cwd: { type: 'string', description: 'Working directory (optional, defaults to current)' },
+            },
+            required: ['command'],
+        },
+    },
+    {
+        name: 'read_file',
+        description: 'Read the contents of a file on the user\'s computer.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute or relative file path' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'write_file',
+        description: 'Write or overwrite a file on the user\'s computer.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute or relative file path' },
+                content: { type: 'string', description: 'File content to write' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    {
+        name: 'list_directory',
+        description: 'List files and directories in a given path.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path' },
+                recursive: { type: 'boolean', description: 'List recursively (max 3 levels)' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'create_directory',
+        description: 'Create a directory (and parent directories if needed).',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path to create' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'delete_file',
+        description: 'Delete a file or directory.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to delete' },
+                recursive: { type: 'boolean', description: 'Delete directory recursively' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'move_file',
+        description: 'Move or rename a file or directory.',
+        parameters: {
+            type: 'object',
+            properties: {
+                source: { type: 'string', description: 'Source path' },
+                destination: { type: 'string', description: 'Destination path' },
+            },
+            required: ['source', 'destination'],
+        },
+    },
+    {
+        name: 'search_files',
+        description: 'Search for files matching a pattern using glob or by content.',
+        parameters: {
+            type: 'object',
+            properties: {
+                directory: { type: 'string', description: 'Directory to search in' },
+                pattern: { type: 'string', description: 'File name pattern (glob)' },
+                content: { type: 'string', description: 'Search file contents for this text' },
+            },
+            required: ['directory'],
+        },
+    },
+    {
+        name: 'system_info',
+        description: 'Get information about the user\'s computer (OS, CPU, memory, etc.).',
+        parameters: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'open_url',
+        description: 'Open a URL in the default browser.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to open' },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'open_application',
+        description: 'Open an application on the computer.',
+        parameters: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Application name (e.g. "Visual Studio Code", "Finder", "Terminal")' },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'install_package',
+        description: 'Install a package using npm, pip, brew, or apt.',
+        parameters: {
+            type: 'object',
+            properties: {
+                manager: { type: 'string', enum: ['npm', 'pip', 'brew', 'apt'], description: 'Package manager to use' },
+                package_name: { type: 'string', description: 'Package name to install' },
+                global: { type: 'boolean', description: 'Install globally (for npm)' },
+            },
+            required: ['manager', 'package_name'],
+        },
+    },
+    {
+        name: 'get_clipboard',
+        description: 'Get the current clipboard content.',
+        parameters: { type: 'object', properties: {} },
+    },
+    {
+        name: 'set_clipboard',
+        description: 'Set clipboard content.',
+        parameters: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Text to copy to clipboard' },
+            },
+            required: ['text'],
+        },
+    },
+];
+
+function resolvePath(p) {
+    if (p.startsWith('~')) {
+        return path.join(os.homedir(), p.slice(1));
+    }
+    return path.resolve(p);
+}
+
+async function executeTool(name, args) {
+    switch (name) {
+        case 'run_shell': {
+            const cwd = args.cwd ? resolvePath(args.cwd) : process.cwd();
+            console.log(chalk.gray(`  ⚙ Running: ${args.command}`));
+            try {
+                const result = execSync(args.command, {
+                    cwd,
+                    encoding: 'utf-8',
+                    timeout: 60000,
+                    maxBuffer: 5 * 1024 * 1024,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                return { success: true, stdout: result.substring(0, 10000) };
+            } catch (err) {
+                return {
+                    success: false,
+                    exitCode: err.status,
+                    stdout: (err.stdout || '').substring(0, 5000),
+                    stderr: (err.stderr || '').substring(0, 5000),
+                };
+            }
+        }
+
+        case 'read_file': {
+            const filePath = resolvePath(args.path);
+            console.log(chalk.gray(`  📖 Reading: ${filePath}`));
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                return { success: true, content: content.substring(0, 50000), size: content.length };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'write_file': {
+            const filePath = resolvePath(args.path);
+            console.log(chalk.gray(`  ✍️  Writing: ${filePath}`));
+            try {
+                const dir = path.dirname(filePath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                fs.writeFileSync(filePath, args.content, 'utf-8');
+                return { success: true, path: filePath, bytes: Buffer.byteLength(args.content) };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'list_directory': {
+            const dirPath = resolvePath(args.path);
+            console.log(chalk.gray(`  📂 Listing: ${dirPath}`));
+            try {
+                const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+                const items = entries.map(e => ({
+                    name: e.name,
+                    type: e.isDirectory() ? 'directory' : 'file',
+                    size: e.isFile() ? fs.statSync(path.join(dirPath, e.name)).size : undefined,
+                }));
+                return { success: true, path: dirPath, items: items.slice(0, 200) };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'create_directory': {
+            const dirPath = resolvePath(args.path);
+            console.log(chalk.gray(`  📁 Creating dir: ${dirPath}`));
+            try {
+                fs.mkdirSync(dirPath, { recursive: true });
+                return { success: true, path: dirPath };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'delete_file': {
+            const filePath = resolvePath(args.path);
+            console.log(chalk.gray(`  🗑️  Deleting: ${filePath}`));
+            try {
+                if (args.recursive) {
+                    fs.rmSync(filePath, { recursive: true, force: true });
+                } else {
+                    fs.unlinkSync(filePath);
+                }
+                return { success: true, path: filePath };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'move_file': {
+            const src = resolvePath(args.source);
+            const dest = resolvePath(args.destination);
+            console.log(chalk.gray(`  📦 Moving: ${src} → ${dest}`));
+            try {
+                fs.renameSync(src, dest);
+                return { success: true, source: src, destination: dest };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'search_files': {
+            const dir = resolvePath(args.directory);
+            console.log(chalk.gray(`  🔍 Searching in: ${dir}`));
+            try {
+                let cmd = '';
+                if (args.content) {
+                    cmd = `grep -rl "${args.content.replace(/"/g, '\\"')}" "${dir}" --include="${args.pattern || '*'}" 2>/dev/null | head -30`;
+                } else if (args.pattern) {
+                    cmd = `find "${dir}" -name "${args.pattern}" -maxdepth 5 2>/dev/null | head -50`;
+                } else {
+                    cmd = `find "${dir}" -maxdepth 3 2>/dev/null | head -50`;
+                }
+                const result = execSync(cmd, { encoding: 'utf-8', timeout: 15000 });
+                return { success: true, files: result.trim().split('\n').filter(Boolean) };
+            } catch (err) {
+                return { success: true, files: [] };
+            }
+        }
+
+        case 'system_info': {
+            console.log(chalk.gray(`  💻 Getting system info`));
+            return {
+                success: true,
+                platform: os.platform(),
+                arch: os.arch(),
+                hostname: os.hostname(),
+                cpus: os.cpus().length,
+                cpuModel: os.cpus()[0]?.model,
+                totalMemory: `${Math.round(os.totalmem() / 1073741824)}GB`,
+                freeMemory: `${Math.round(os.freemem() / 1073741824)}GB`,
+                homeDir: os.homedir(),
+                shell: process.env.SHELL || 'unknown',
+                nodeVersion: process.version,
+                cwd: process.cwd(),
+                user: os.userInfo().username,
+            };
+        }
+
+        case 'open_url': {
+            console.log(chalk.gray(`  🌐 Opening: ${args.url}`));
+            try {
+                const open = (await import('open')).default;
+                await open(args.url);
+                return { success: true, url: args.url };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'open_application': {
+            console.log(chalk.gray(`  🚀 Opening: ${args.name}`));
+            try {
+                if (os.platform() === 'darwin') {
+                    execSync(`open -a "${args.name}"`, { timeout: 5000 });
+                } else if (os.platform() === 'win32') {
+                    execSync(`start "" "${args.name}"`, { timeout: 5000 });
+                } else {
+                    execSync(`xdg-open "${args.name}" &`, { timeout: 5000 });
+                }
+                return { success: true, app: args.name };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'install_package': {
+            const { manager, package_name } = args;
+            let cmd;
+            switch (manager) {
+                case 'npm': cmd = args.global ? `npm install -g ${package_name}` : `npm install ${package_name}`; break;
+                case 'pip': cmd = `pip install ${package_name}`; break;
+                case 'brew': cmd = `brew install ${package_name}`; break;
+                case 'apt': cmd = `sudo apt-get install -y ${package_name}`; break;
+                default: return { success: false, error: `Unknown package manager: ${manager}` };
+            }
+            console.log(chalk.gray(`  📦 Installing: ${cmd}`));
+            try {
+                const result = execSync(cmd, { encoding: 'utf-8', timeout: 120000 });
+                return { success: true, command: cmd, output: result.substring(0, 5000) };
+            } catch (err) {
+                return { success: false, error: (err.stderr || err.message).substring(0, 3000) };
+            }
+        }
+
+        case 'get_clipboard': {
+            try {
+                let cmd;
+                if (os.platform() === 'darwin') cmd = 'pbpaste';
+                else if (os.platform() === 'win32') cmd = 'powershell -command "Get-Clipboard"';
+                else cmd = 'xclip -selection clipboard -o';
+                const result = execSync(cmd, { encoding: 'utf-8', timeout: 3000 });
+                return { success: true, content: result.substring(0, 10000) };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        case 'set_clipboard': {
+            try {
+                let cmd;
+                if (os.platform() === 'darwin') cmd = 'pbcopy';
+                else if (os.platform() === 'win32') cmd = 'clip';
+                else cmd = 'xclip -selection clipboard';
+                const proc = exec(cmd);
+                proc.stdin.write(args.text);
+                proc.stdin.end();
+                return { success: true };
+            } catch (err) {
+                return { success: false, error: err.message };
+            }
+        }
+
+        default:
+            return { success: false, error: `Unknown tool: ${name}` };
+    }
+}
+
+function getToolsForProvider(provider) {
+    if (provider === 'gemini') {
+        return TOOL_DEFINITIONS.map(t => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        }));
+    }
+    if (provider === 'openai') {
+        return TOOL_DEFINITIONS.map(t => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+    if (provider === 'claude') {
+        return TOOL_DEFINITIONS.map(t => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.parameters,
+        }));
+    }
+    return TOOL_DEFINITIONS;
+}
+
+export { TOOL_DEFINITIONS, executeTool, getToolsForProvider };