osborn 0.1.0 → 0.1.2

package/dist/claude-handler.d.ts

@@ -5,6 +5,7 @@ interface ClaudeHandlerOptions {
     allowedTools?: string[];
     permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions';
     mcpServers?: Record<string, McpServerConfig>;
+    requireAllPermissions?: boolean;
 }
 export type { McpServerConfig };
 export interface PermissionRequestEvent {
@@ -28,10 +29,14 @@ export declare class ClaudeHandler extends EventEmitter {
     private abortController;
     private sessionId;
     private pendingPermission;
-    private dangerousTools;
+    private toolStartTimes;
     private alwaysAllowedTools;
     private static readonly ALL_TOOLS;
     constructor(options?: ClaudeHandlerOptions);
+    /**
+     * Generate human-readable description for a tool call
+     */
+    private getToolDescription;
     run(prompt: string): Promise<string>;
     /**
      * Request permission from user via event emission

package/dist/claude-handler.js

@@ -1,13 +1,41 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { EventEmitter } from 'events';
+// Log tool calls to terminal (async, non-blocking)
+function logToolCall(entry) {
+    // Use setImmediate to avoid blocking the main execution
+    setImmediate(() => {
+        const time = new Date().toLocaleTimeString();
+        const inputStr = JSON.stringify(entry.input).substring(0, 100);
+        switch (entry.status) {
+            case 'started':
+                console.log(`\n🔧 [${time}] TOOL START: ${entry.toolName}`);
+                console.log(`   📥 Input: ${inputStr}${inputStr.length >= 100 ? '...' : ''}`);
+                break;
+            case 'completed':
+                const duration = entry.duration ? `${entry.duration}ms` : '?';
+                console.log(`✅ [${time}] TOOL DONE: ${entry.toolName} (${duration})`);
+                if (entry.output) {
+                    const outStr = typeof entry.output === 'string'
+                        ? entry.output.substring(0, 150)
+                        : JSON.stringify(entry.output).substring(0, 150);
+                    console.log(`   📤 Output: ${outStr}${outStr.length >= 150 ? '...' : ''}`);
+                }
+                break;
+            case 'blocked':
+                console.log(`❌ [${time}] TOOL BLOCKED: ${entry.toolName}`);
+                console.log(`   ⛔ Reason: ${entry.error || 'User denied'}`);
+                break;
+        }
+    });
+}
 export class ClaudeHandler extends EventEmitter {
     options;
     abortController = null;
     sessionId = null;
     pendingPermission = null;
-    // Tools that require permission
-    dangerousTools = ['Bash', 'Write', 'Edit'];
-    // Tools the user has permanently approved
+    // Track tool call start times for duration logging
+    toolStartTimes = new Map();
+    // Tools the user has permanently approved (for this session)
     alwaysAllowedTools = new Set();
     // All available Claude Agent SDK tools
     static ALL_TOOLS = [
@@ -33,12 +61,52 @@ export class ClaudeHandler extends EventEmitter {
             allowedTools: options.allowedTools || ClaudeHandler.ALL_TOOLS,
             permissionMode: options.permissionMode || 'default',
             mcpServers: options.mcpServers,
+            // By default, require permission for ALL tools
+            requireAllPermissions: options.requireAllPermissions ?? true,
         };
         console.log(`🔧 Allowed tools: ${this.options.allowedTools?.join(', ')}`);
+        console.log(`🔐 Require all permissions: ${this.options.requireAllPermissions}`);
         if (this.options.mcpServers) {
             console.log(`🔌 MCP servers: ${Object.keys(this.options.mcpServers).join(', ')}`);
         }
     }
+    /**
+     * Generate human-readable description for a tool call
+     */
+    getToolDescription(toolName, toolInput) {
+        switch (toolName) {
+            case 'Bash':
+                return `Run command: ${toolInput.command || 'unknown command'}`;
+            case 'Write':
+                return `Create file: ${toolInput.file_path || 'unknown file'}`;
+            case 'Edit':
+                return `Edit file: ${toolInput.file_path || 'unknown file'}`;
+            case 'MultiEdit':
+                return `Multi-edit: ${toolInput.edits?.length || 0} edits`;
+            case 'Read':
+                return `Read file: ${toolInput.file_path || 'unknown file'}`;
+            case 'Glob':
+                return `Find files: ${toolInput.pattern || 'unknown pattern'}`;
+            case 'Grep':
+                return `Search content: "${toolInput.pattern || 'unknown'}" in ${toolInput.path || 'cwd'}`;
+            case 'WebSearch':
+                return `🌐 Web search: "${toolInput.query || 'unknown query'}"`;
+            case 'WebFetch':
+                return `🌐 Fetch URL: ${toolInput.url || 'unknown url'}`;
+            case 'NotebookEdit':
+                return `Edit notebook: ${toolInput.notebook_path || 'unknown'}`;
+            case 'Task':
+                return `Spawn task: ${toolInput.description || 'unknown task'}`;
+            case 'TodoWrite':
+                return `Update todos: ${toolInput.todos?.length || 0} items`;
+            case 'LSP':
+                return `LSP ${toolInput.operation || 'query'}: ${toolInput.filePath || 'unknown'}`;
+            default:
+                // For MCP tools, show the tool name and first few input keys
+                const inputKeys = Object.keys(toolInput || {}).slice(0, 3).join(', ');
+                return `${toolName}: ${inputKeys || 'no params'}`;
+        }
+    }
     async run(prompt) {
         this.abortController = new AbortController();
         let fullResponse = '';
@@ -68,10 +136,26 @@ export class ClaudeHandler extends EventEmitter {
                             hooks: [async (input, toolUseId) => {
                                     const toolName = input?.tool_name || 'unknown';
                                     const toolInput = input?.tool_input || {};
+                                    const id = toolUseId || `tool-${Date.now()}`;
+                                    const description = this.getToolDescription(toolName, toolInput);
+                                    // Record start time for duration tracking
+                                    this.toolStartTimes.set(id, Date.now());
+                                    // Log tool start (background, non-blocking)
+                                    logToolCall({
+                                        timestamp: new Date().toISOString(),
+                                        toolName,
+                                        toolUseId: id,
+                                        input: toolInput,
+                                        status: 'started',
+                                    });
                                     console.log(`🔧 Tool: ${toolName}`);
-                                    this.emit('tool_use', { name: toolName, input: toolInput });
+                                    console.log(`   📋 ${description}`);
+                                    this.emit('tool_use', { name: toolName, input: toolInput, description });
                                     // Check if this tool needs permission
-                                    if (this.dangerousTools.includes(toolName) && this.options.permissionMode === 'default') {
+                                    // In default mode with requireAllPermissions, ALL tools need permission
+                                    const needsPermission = this.options.permissionMode === 'default' &&
+                                        this.options.requireAllPermissions;
+                                    if (needsPermission) {
                                         // Skip if user has permanently approved this tool
                                         if (this.alwaysAllowedTools.has(toolName)) {
                                             console.log(`✅ Auto-approved (always allow): ${toolName}`);
@@ -79,9 +163,18 @@ export class ClaudeHandler extends EventEmitter {
                                         else {
                                             console.log(`⚠️ Permission required for: ${toolName}`);
                                             // Emit permission request and wait for approval
-                                            const response = await this.requestPermission(toolName, toolInput, toolUseId || 'unknown');
+                                            const response = await this.requestPermission(toolName, toolInput, id, description);
                                             if (response === 'deny') {
                                                 console.log(`❌ Permission denied for: ${toolName}`);
+                                                // Log blocked tool
+                                                logToolCall({
+                                                    timestamp: new Date().toISOString(),
+                                                    toolName,
+                                                    toolUseId: id,
+                                                    input: toolInput,
+                                                    status: 'blocked',
+                                                    error: 'User denied permission',
+                                                });
                                                 return {
                                                     decision: 'block',
                                                     reason: 'User denied permission for this operation'
@@ -101,10 +194,26 @@ export class ClaudeHandler extends EventEmitter {
                         }],
                     PostToolUse: [{
                             matcher: '.*',
-                            hooks: [async (input) => {
+                            hooks: [async (input, toolUseId) => {
                                     const toolName = input?.tool_name || 'unknown';
-                                    console.log(`✅ Completed: ${toolName}`);
-                                    this.emit('tool_result', { name: toolName });
+                                    const toolOutput = input?.tool_output || input?.output;
+                                    const id = toolUseId || 'unknown';
+                                    // Calculate duration
+                                    const startTime = this.toolStartTimes.get(id);
+                                    const duration = startTime ? Date.now() - startTime : undefined;
+                                    this.toolStartTimes.delete(id);
+                                    // Log tool completion (background, non-blocking)
+                                    logToolCall({
+                                        timestamp: new Date().toISOString(),
+                                        toolName,
+                                        toolUseId: id,
+                                        input: input?.tool_input || {},
+                                        status: 'completed',
+                                        output: toolOutput ? (typeof toolOutput === 'string' ? toolOutput.substring(0, 500) : 'object') : undefined,
+                                        duration,
+                                    });
+                                    console.log(`✅ Completed: ${toolName} (${duration ? duration + 'ms' : 'unknown duration'})`);
+                                    this.emit('tool_result', { name: toolName, output: toolOutput, duration });
                                     return {};
                                 }]
                         }]
@@ -168,24 +277,15 @@ export class ClaudeHandler extends EventEmitter {
      * Request permission from user via event emission
      * Returns a promise that resolves when user responds with allow/deny/always_allow
      */
-    requestPermission(toolName, toolInput, toolUseId) {
+    requestPermission(toolName, toolInput, toolUseId, description) {
         return new Promise((resolve) => {
-            // Format the permission request message
-            let description = '';
-            if (toolName === 'Bash') {
-                description = `Run command: ${toolInput.command || 'unknown command'}`;
-            }
-            else if (toolName === 'Write') {
-                description = `Create file: ${toolInput.file_path || 'unknown file'}`;
-            }
-            else if (toolName === 'Edit') {
-                description = `Edit file: ${toolInput.file_path || 'unknown file'}`;
-            }
+            // Use provided description or generate one
+            const desc = description || this.getToolDescription(toolName, toolInput);
             this.pendingPermission = { toolName, toolInput, toolUseId, resolve: resolve };
             // Emit event for voice handler to pick up
             this.emit('permission_request', {
                 toolName,
-                description,
+                description: desc,
                 toolInput,
                 toolUseId,
             });
@@ -240,16 +340,7 @@ export class ClaudeHandler extends EventEmitter {
         if (!this.pendingPermission)
             return null;
         const { toolName, toolInput, toolUseId } = this.pendingPermission;
-        let description = '';
-        if (toolName === 'Bash') {
-            description = `Run command: ${toolInput.command || 'unknown command'}`;
-        }
-        else if (toolName === 'Write') {
-            description = `Create file: ${toolInput.file_path || 'unknown file'}`;
-        }
-        else if (toolName === 'Edit') {
-            description = `Edit file: ${toolInput.file_path || 'unknown file'}`;
-        }
+        const description = this.getToolDescription(toolName, toolInput);
         return { toolName, description, toolInput, toolUseId };
     }
     /**

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+import type { McpServerConfig } from './claude-handler.js';
+export interface OsbornConfig {
+    workingDirectory?: string;
+    mcpServers?: Record<string, McpServerConfigYaml>;
+    defaultProvider?: 'openai' | 'gemini';
+    defaultCodingAgent?: 'claude' | 'codex';
+}
+interface McpServerConfigYaml {
+    enabled?: boolean;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    transport?: 'stdio' | 'sse' | 'http';
+}
+/**
+ * Load configuration from ~/.osborn/config.yaml
+ * Creates default config if it doesn't exist
+ */
+export declare function loadConfig(): OsbornConfig;
+/**
+ * Get enabled MCP servers in the format expected by Claude Agent SDK
+ */
+export declare function getMcpServers(config: OsbornConfig): Record<string, McpServerConfig>;
+/**
+ * Get list of enabled MCP server names (for display)
+ */
+export declare function getEnabledMcpServerNames(config: OsbornConfig): string[];
+/**
+ * Save config to file
+ */
+export declare function saveConfig(config: OsbornConfig): void;
+export {};

package/dist/config.js

@@ -0,0 +1,127 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { parse, stringify } from 'yaml';
+// Config file paths
+const CONFIG_DIR = join(homedir(), '.osborn');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.yaml');
+// Default config template
+const DEFAULT_CONFIG = {
+    workingDirectory: process.cwd(),
+    defaultProvider: 'openai',
+    defaultCodingAgent: 'claude',
+    mcpServers: {
+    // Example MCP servers (disabled by default)
+    // github: {
+    //   enabled: true,
+    //   command: 'npx',
+    //   args: ['@modelcontextprotocol/server-github'],
+    //   env: {
+    //     GITHUB_TOKEN: '${GITHUB_TOKEN}',
+    //   },
+    // },
+    // filesystem: {
+    //   enabled: true,
+    //   command: 'npx',
+    //   args: ['@modelcontextprotocol/server-filesystem', '/allowed/path'],
+    // },
+    },
+};
+/**
+ * Resolve environment variable references in a string
+ * e.g., "${GITHUB_TOKEN}" becomes the value of process.env.GITHUB_TOKEN
+ */
+function resolveEnvVar(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (_, envVar) => {
+        return process.env[envVar] || '';
+    });
+}
+/**
+ * Resolve environment variables in an object of strings
+ */
+function resolveEnvVars(env) {
+    if (!env)
+        return undefined;
+    const resolved = {};
+    for (const [key, value] of Object.entries(env)) {
+        resolved[key] = resolveEnvVar(value);
+    }
+    return resolved;
+}
+/**
+ * Load configuration from ~/.osborn/config.yaml
+ * Creates default config if it doesn't exist
+ */
+export function loadConfig() {
+    // Ensure config directory exists
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+        console.log(`📁 Created config directory: ${CONFIG_DIR}`);
+    }
+    // Create default config if it doesn't exist
+    if (!existsSync(CONFIG_FILE)) {
+        const defaultYaml = stringify(DEFAULT_CONFIG);
+        writeFileSync(CONFIG_FILE, defaultYaml, 'utf-8');
+        console.log(`📝 Created default config: ${CONFIG_FILE}`);
+        return DEFAULT_CONFIG;
+    }
+    // Load and parse config
+    try {
+        const content = readFileSync(CONFIG_FILE, 'utf-8');
+        const config = parse(content);
+        console.log(`📋 Loaded config from: ${CONFIG_FILE}`);
+        return config;
+    }
+    catch (err) {
+        console.error(`❌ Failed to load config: ${err.message}`);
+        return DEFAULT_CONFIG;
+    }
+}
+/**
+ * Get enabled MCP servers in the format expected by Claude Agent SDK
+ */
+export function getMcpServers(config) {
+    const servers = {};
+    if (!config.mcpServers) {
+        return servers;
+    }
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        // Skip disabled servers
+        if (serverConfig.enabled === false) {
+            continue;
+        }
+        // Build the McpServerConfig for Claude Agent SDK
+        if (serverConfig.command) {
+            servers[name] = {
+                command: serverConfig.command,
+                args: serverConfig.args,
+                env: resolveEnvVars(serverConfig.env),
+            };
+        }
+        // Note: SSE/HTTP transport may require different handling
+    }
+    return servers;
+}
+/**
+ * Get list of enabled MCP server names (for display)
+ */
+export function getEnabledMcpServerNames(config) {
+    if (!config.mcpServers)
+        return [];
+    return Object.entries(config.mcpServers)
+        .filter(([_, serverConfig]) => serverConfig.enabled !== false && serverConfig.command)
+        .map(([name, _]) => name);
+}
+/**
+ * Save config to file
+ */
+export function saveConfig(config) {
+    try {
+        const yaml = stringify(config);
+        writeFileSync(CONFIG_FILE, yaml, 'utf-8');
+        console.log(`💾 Saved config to: ${CONFIG_FILE}`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to save config: ${err.message}`);
+    }
+}

package/dist/index.js

@@ -6,6 +6,22 @@ import { fileURLToPath } from 'url';
 import 'dotenv/config';
 import { ClaudeHandler } from './claude-handler.js';
 import { CodexHandler } from './codex-handler.js';
+import { loadConfig, getMcpServers, getEnabledMcpServerNames } from './config.js';
+// Parse CLI arguments for room code
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let roomCode;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--room' && args[i + 1]) {
+            roomCode = args[i + 1];
+        }
+    }
+    return { roomCode };
+}
+const cliArgs = parseArgs();
+if (cliArgs.roomCode) {
+    console.log(`🔗 Room code provided: ${cliArgs.roomCode}`);
+}
 // Global error handlers to catch silent failures
 process.on('unhandledRejection', (reason, promise) => {
     console.error('❌ Unhandled Rejection:', reason);
@@ -21,29 +37,23 @@ if (DEBUG) {
     console.log('🐛 Debug logging enabled');
 }
 console.log(`🤖 Default LLM Provider: ${DEFAULT_PROVIDER}`);
-// Example MCP server configurations (uncomment to enable)
-const MCP_SERVERS = {
-// GitHub integration
-// 'github': {
-//   command: 'npx',
-//   args: ['@modelcontextprotocol/server-github'],
-//   env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN || '' }
-// },
-// Filesystem with specific allowed paths
-// 'filesystem': {
-//   command: 'npx',
-//   args: ['@modelcontextprotocol/server-filesystem'],
-//   env: { ALLOWED_PATHS: '/Users/newupgrade/Desktop/Developer' }
-// },
-};
+// Load configuration from ~/.osborn/config.yaml
+console.log('📁 Loading configuration...');
+const config = loadConfig();
+const mcpServers = getMcpServers(config);
+const enabledMcpNames = getEnabledMcpServerNames(config);
+if (enabledMcpNames.length > 0) {
+    console.log(`🔌 Enabled MCP servers: ${enabledMcpNames.join(', ')}`);
+}
 // Pre-initialize Claude handler at module load (before any connections)
 console.log('🔥 Pre-initializing Claude Code...');
+const workingDir = config.workingDirectory || process.cwd();
 const claude = new ClaudeHandler({
-    workingDirectory: '/Users/newupgrade/Desktop/Developer/osborn',
+    workingDirectory: workingDir,
     permissionMode: 'default', // Ask for permission on dangerous tools (Bash, Write, Edit)
-    // Uncomment to enable MCP servers:
-    // mcpServers: MCP_SERVERS,
+    mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,
 });
+console.log(`📂 Working directory: ${workingDir}`);
 // Listen for permission requests from Claude
 claude.on('permission_request', (req) => {
     console.log(`\n⚠️ PERMISSION REQUIRED ⚠️`);
@@ -67,6 +77,23 @@ let currentSession = null;
 // Track the current coding handler (can be Claude or Codex)
 let currentCodingAgent = 'claude';
 let codexHandler = null;
+// Helper to cleanup previous session before starting new one
+async function cleanupSession() {
+    if (currentSession) {
+        console.log('🧹 Cleaning up previous session...');
+        try {
+            currentSession.removeAllListeners();
+            // Close session gracefully if method exists
+            if (typeof currentSession.close === 'function') {
+                await currentSession.close();
+            }
+        }
+        catch (err) {
+            console.log('⚠️ Session cleanup error (non-fatal):', err.message);
+        }
+        currentSession = null;
+    }
+}
 // Helper to send data to frontend
 async function sendToFrontend(data) {
     if (!jobContext)
@@ -190,11 +217,13 @@ function createModel(provider) {
         // From official docs: https://docs.livekit.io/agents/models/realtime/plugins/gemini/
         // Package v1.0.31 uses google.beta.realtime (not google.realtime yet)
         const model = new google.beta.realtime.RealtimeModel({
-            model: 'gemini-2.5-flash-native-audio-preview-12-2025', // From official docs
+            // model: 'gemini-2.5-flash-native-audio-preview-12-2025', // From official docs
+            model: 'gemini-3.5-flash-latest', // From official docs
             voice: 'Puck',
             instructions: OSBORN_INSTRUCTIONS,
         });
-        console.log('✅ Gemini model created with gemini-2.5-flash-native-audio-preview-12-2025');
+        // console.log('✅ Gemini model created with gemini-2.5-flash-native-audio-preview-12-2025')
+        console.log('✅ Gemini model created with gemini-3.5-flash-latest');
         return model;
     }
     else {
@@ -234,6 +263,15 @@ function getCodingAgentFromParticipant(metadata) {
 export default defineAgent({
     entry: async (ctx) => {
         console.log('🚀 Agent starting for room:', ctx.room.name);
+        // If room code was provided via CLI, validate room name
+        if (cliArgs.roomCode) {
+            const expectedRoom = `osborn-${cliArgs.roomCode}`;
+            if (ctx.room.name !== expectedRoom) {
+                console.log(`⏭️ Skipping room ${ctx.room.name} (waiting for ${expectedRoom})`);
+                return; // Don't handle this room
+            }
+            console.log(`✅ Room matches expected: ${expectedRoom}`);
+        }
         jobContext = ctx;
         // Claude verbose logging
         claude.on('tool_use', (tool) => {
@@ -272,12 +310,14 @@ export default defineAgent({
         if (codingAgent === 'codex') {
             console.log('🔧 Initializing Codex handler...');
             codexHandler = new CodexHandler({
-                workingDirectory: '/Users/newupgrade/Desktop/Developer/osborn',
+                workingDirectory: workingDir,
             });
             console.log('✅ Codex handler ready');
         }
         // Create model based on user's choice
         const model = createModel(provider);
+        // Clean up any previous session before creating new one
+        await cleanupSession();
         const session = new voice.AgentSession({
             llm: model,
         });
@@ -302,6 +342,11 @@ export default defineAgent({
         ctx.room.on('trackSubscribed', (track, publication, p) => {
             console.log(`📥 Track subscribed: ${track.kind} from ${p.identity}`);
         });
+        ctx.room.on('participantDisconnected', async (p) => {
+            console.log(`👋 Participant disconnected: ${p.identity}`);
+            // Clean up session when user disconnects to prepare for next connection
+            await cleanupSession();
+        });
         // Listen for data channel messages from frontend
         ctx.room.on('dataReceived', async (payload, participant, kind, topic) => {
             if (topic === 'user-input') {
@@ -353,4 +398,18 @@ export default defineAgent({
         console.log('🎤 Ready for voice input! Speak to start.');
     },
 });
-cli.runApp(new ServerOptions({ agent: fileURLToPath(import.meta.url) }));
+// Configure server options
+const serverOptions = {
+    agent: fileURLToPath(import.meta.url),
+};
+// If room code is provided, filter to only handle that room
+if (cliArgs.roomCode) {
+    const targetRoom = `osborn-${cliArgs.roomCode}`;
+    console.log(`🎯 Filtering for room: ${targetRoom}`);
+    // The agent will be dispatched to rooms matching this pattern
+    serverOptions.workerOptions = {
+    // Note: Room filtering is handled by LiveKit dispatch
+    // For local development, we validate the room in the entry function
+    };
+}
+cli.runApp(new ServerOptions(serverOptions));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {