cowork-os 0.3.21

package/dist/electron/electron/gateway/router.js

@@ -0,0 +1,2700 @@
+"use strict";
+/**
+ * Message Router
+ *
+ * Routes incoming messages from channels to appropriate handlers.
+ * Manages message flow: Security → Session → Task/Response
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageRouter = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const telegram_1 = require("./channels/telegram");
+const security_1 = require("./security");
+const session_1 = require("./session");
+const repositories_1 = require("../database/repositories");
+const types_1 = require("../../shared/types");
+const os = __importStar(require("os"));
+const provider_factory_1 = require("../agent/llm/provider-factory");
+const custom_skill_loader_1 = require("../agent/custom-skill-loader");
+const electron_1 = require("electron");
+const VoiceService_1 = require("../voice/VoiceService");
+const personality_manager_1 = require("../settings/personality-manager");
+const channelMessages_1 = require("../../shared/channelMessages");
+const types_2 = require("../../shared/types");
+const DEFAULT_CONFIG = {
+    welcomeMessage: '👋 Welcome to CoWork! I can help you with tasks in your workspace.',
+    unauthorizedMessage: '⚠️ You are not authorized to use this bot. Please contact the administrator.',
+    pairingRequiredMessage: '🔐 Please enter your pairing code to get started.',
+};
+class MessageRouter {
+    constructor(db, config = {}, agentDaemon) {
+        this.adapters = new Map();
+        this.eventHandlers = [];
+        this.mainWindow = null;
+        // Track pending responses for tasks
+        this.pendingTaskResponses = new Map();
+        // Track pending approval requests for Discord/Telegram
+        this.pendingApprovals = new Map();
+        this.db = db;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.agentDaemon = agentDaemon;
+        // Initialize repositories
+        this.channelRepo = new repositories_1.ChannelRepository(db);
+        this.userRepo = new repositories_1.ChannelUserRepository(db);
+        this.sessionRepo = new repositories_1.ChannelSessionRepository(db);
+        this.messageRepo = new repositories_1.ChannelMessageRepository(db);
+        this.workspaceRepo = new repositories_1.WorkspaceRepository(db);
+        this.taskRepo = new repositories_1.TaskRepository(db);
+        this.artifactRepo = new repositories_1.ArtifactRepository(db);
+        // Initialize managers
+        this.securityManager = new security_1.SecurityManager(db);
+        this.sessionManager = new session_1.SessionManager(db);
+        // Listen for task events if agent daemon is available
+        if (this.agentDaemon) {
+            this.setupTaskEventListener();
+        }
+    }
+    /**
+     * Set up listener for task events to send responses back to channels
+     */
+    setupTaskEventListener() {
+        // We'll listen for task events through BrowserWindow IPC
+        // The agent daemon emits events to all windows
+    }
+    /**
+     * Set the main window for sending IPC events
+     */
+    setMainWindow(window) {
+        this.mainWindow = window;
+    }
+    /**
+     * Get the main window for sending IPC events
+     */
+    getMainWindow() {
+        return this.mainWindow;
+    }
+    /**
+     * Get the channel message context from personality settings
+     */
+    getMessageContext() {
+        try {
+            if (personality_manager_1.PersonalityManager.isInitialized()) {
+                const settings = personality_manager_1.PersonalityManager.loadSettings();
+                return {
+                    agentName: settings.agentName || 'CoWork',
+                    userName: settings.relationship?.userName,
+                    personality: settings.activePersonality || 'professional',
+                    emojiUsage: settings.responseStyle?.emojiUsage || 'minimal',
+                    quirks: settings.quirks || types_2.DEFAULT_QUIRKS,
+                };
+            }
+        }
+        catch (error) {
+            console.error('[MessageRouter] Failed to load personality settings:', error);
+        }
+        return channelMessages_1.DEFAULT_CHANNEL_CONTEXT;
+    }
+    /**
+     * Get or create the temp workspace for sessions without a workspace
+     */
+    getOrCreateTempWorkspace() {
+        // Check if temp workspace exists
+        const existing = this.workspaceRepo.findById(types_1.TEMP_WORKSPACE_ID);
+        if (existing) {
+            const updatedPermissions = {
+                ...existing.permissions,
+                read: true,
+                write: true,
+                delete: true,
+                network: true,
+                shell: existing.permissions.shell ?? false,
+                unrestrictedFileAccess: true,
+            };
+            if (!existing.permissions.unrestrictedFileAccess) {
+                this.workspaceRepo.updatePermissions(existing.id, updatedPermissions);
+            }
+            // Verify directory exists
+            if (fs.existsSync(existing.path)) {
+                return { ...existing, permissions: updatedPermissions, isTemp: true };
+            }
+            // Directory was deleted, recreate it
+            const tempDir = path.join(os.tmpdir(), 'cowork-os-temp');
+            fs.mkdirSync(tempDir, { recursive: true });
+            return { ...existing, permissions: updatedPermissions, isTemp: true };
+        }
+        // Create temp directory
+        const tempDir = path.join(os.tmpdir(), 'cowork-os-temp');
+        fs.mkdirSync(tempDir, { recursive: true });
+        // Create workspace record
+        const tempWorkspace = {
+            id: types_1.TEMP_WORKSPACE_ID,
+            name: types_1.TEMP_WORKSPACE_NAME,
+            path: tempDir,
+            createdAt: Date.now(),
+            permissions: {
+                read: true,
+                write: true,
+                delete: true,
+                network: true,
+                shell: false,
+                unrestrictedFileAccess: true,
+            },
+            isTemp: true,
+        };
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO workspaces (id, name, path, created_at, permissions)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(tempWorkspace.id, tempWorkspace.name, tempWorkspace.path, tempWorkspace.createdAt, JSON.stringify(tempWorkspace.permissions));
+        return tempWorkspace;
+    }
+    /**
+     * Register a channel adapter
+     */
+    registerAdapter(adapter) {
+        // Set up message handler
+        adapter.onMessage(async (message) => {
+            await this.handleMessage(adapter, message);
+        });
+        // Set up callback query handler for inline keyboards
+        if (adapter.onCallbackQuery) {
+            adapter.onCallbackQuery(async (query) => {
+                await this.handleCallbackQuery(adapter, query);
+            });
+        }
+        // Set up error handler
+        adapter.onError((error, context) => {
+            console.error(`[${adapter.type}] Error in ${context}:`, error);
+            this.emitEvent({
+                type: 'channel:error',
+                channel: adapter.type,
+                timestamp: new Date(),
+                data: { error: error.message, context },
+            });
+        });
+        // Set up status handler
+        adapter.onStatusChange((status, error) => {
+            const eventType = status === 'connected' ? 'channel:connected' : 'channel:disconnected';
+            this.emitEvent({
+                type: eventType,
+                channel: adapter.type,
+                timestamp: new Date(),
+                data: { status, error: error?.message },
+            });
+            // Update channel status in database
+            const channel = this.channelRepo.findByType(adapter.type);
+            if (channel) {
+                this.channelRepo.update(channel.id, {
+                    status,
+                    botUsername: adapter.botUsername,
+                });
+            }
+        });
+        this.adapters.set(adapter.type, adapter);
+    }
+    /**
+     * Get a registered adapter
+     */
+    getAdapter(type) {
+        return this.adapters.get(type);
+    }
+    /**
+     * Get all registered adapters
+     */
+    getAllAdapters() {
+        return Array.from(this.adapters.values());
+    }
+    /**
+     * Connect all enabled adapters
+     */
+    async connectAll() {
+        const enabledChannels = this.channelRepo.findEnabled();
+        for (const channel of enabledChannels) {
+            const adapter = this.adapters.get(channel.type);
+            if (adapter && adapter.status !== 'connected') {
+                try {
+                    await adapter.connect();
+                }
+                catch (error) {
+                    console.error(`Failed to connect ${channel.type}:`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Disconnect all adapters
+     */
+    async disconnectAll() {
+        for (const adapter of this.adapters.values()) {
+            if (adapter.status === 'connected') {
+                try {
+                    await adapter.disconnect();
+                }
+                catch (error) {
+                    console.error(`Failed to disconnect ${adapter.type}:`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Send a message through a channel
+     */
+    async sendMessage(channelType, message) {
+        const adapter = this.adapters.get(channelType);
+        if (!adapter) {
+            throw new Error(`No adapter registered for channel type: ${channelType}`);
+        }
+        if (adapter.status !== 'connected') {
+            throw new Error(`Adapter ${channelType} is not connected`);
+        }
+        const messageId = await adapter.sendMessage(message);
+        // Find channel for logging
+        const channel = this.channelRepo.findByType(channelType);
+        if (channel) {
+            // Log outgoing message
+            this.messageRepo.create({
+                channelId: channel.id,
+                channelMessageId: messageId,
+                chatId: message.chatId,
+                direction: 'outgoing',
+                content: message.text,
+                timestamp: Date.now(),
+            });
+            this.emitEvent({
+                type: 'message:sent',
+                channel: channelType,
+                timestamp: new Date(),
+                data: { chatId: message.chatId, messageId },
+            });
+        }
+        return messageId;
+    }
+    /**
+     * Register an event handler
+     */
+    onEvent(handler) {
+        this.eventHandlers.push(handler);
+    }
+    // Private methods
+    /**
+     * Transcribe audio attachments in a message
+     * Downloads audio from URL or uses buffer, transcribes via VoiceService
+     * Saves audio file to a temp folder for transcription and sets message text to include full transcript with context
+     */
+    async transcribeAudioAttachments(message, workspacePath) {
+        if (!message.attachments || message.attachments.length === 0) {
+            return;
+        }
+        const audioAttachments = message.attachments.filter(a => a.type === 'audio');
+        if (audioAttachments.length === 0) {
+            return;
+        }
+        const voiceService = (0, VoiceService_1.getVoiceService)();
+        // Check if transcription is available
+        if (!voiceService.isTranscriptionAvailable()) {
+            console.log('[Router] Audio transcription not available - no STT provider configured');
+            // Add placeholder for audio messages
+            for (const attachment of audioAttachments) {
+                const fileName = attachment.fileName || 'voice message';
+                message.text += message.text ? `\n[Audio: ${fileName} - transcription unavailable]` : `[Audio: ${fileName} - transcription unavailable]`;
+            }
+            return;
+        }
+        console.log(`[Router] Transcribing ${audioAttachments.length} audio attachment(s)...`);
+        for (const attachment of audioAttachments) {
+            let savedAudioPath;
+            try {
+                let audioBuffer;
+                // Get audio data from buffer or file
+                if (attachment.data) {
+                    audioBuffer = attachment.data;
+                }
+                else if (attachment.url) {
+                    // Check if it's a local file path
+                    if (attachment.url.startsWith('/') || attachment.url.startsWith('file://')) {
+                        const filePath = attachment.url.replace('file://', '');
+                        if (fs.existsSync(filePath)) {
+                            audioBuffer = fs.readFileSync(filePath);
+                        }
+                    }
+                    else if (attachment.url.startsWith('http')) {
+                        // Download from URL
+                        try {
+                            const response = await fetch(attachment.url);
+                            if (response.ok) {
+                                const arrayBuffer = await response.arrayBuffer();
+                                audioBuffer = Buffer.from(arrayBuffer);
+                            }
+                        }
+                        catch (fetchError) {
+                            console.error('[Router] Failed to download audio:', fetchError);
+                        }
+                    }
+                }
+                if (!audioBuffer || audioBuffer.length === 0) {
+                    console.log('[Router] No audio data available for transcription');
+                    const fileName = attachment.fileName || 'voice message';
+                    message.text += message.text ? `\n[Audio: ${fileName} - could not load]` : `[Audio: ${fileName} - could not load]`;
+                    continue;
+                }
+                // Save audio file to temp directory for transcription
+                try {
+                    const tempDir = path.join(os.tmpdir(), 'cowork-audio');
+                    if (!fs.existsSync(tempDir)) {
+                        fs.mkdirSync(tempDir, { recursive: true });
+                    }
+                    const audioFileName = attachment.fileName || `voice_message_${Date.now()}.ogg`;
+                    savedAudioPath = path.join(tempDir, audioFileName);
+                    fs.writeFileSync(savedAudioPath, audioBuffer);
+                    console.log(`[Router] Saved audio file to: ${savedAudioPath}`);
+                }
+                catch (saveError) {
+                    console.error('[Router] Failed to save audio file:', saveError);
+                }
+                // Transcribe the audio
+                const transcript = await voiceService.transcribe(audioBuffer, { force: true });
+                if (transcript && transcript.trim()) {
+                    console.log(`[Router] Transcribed audio: "${transcript.substring(0, 100)}${transcript.length > 100 ? '...' : ''}"`);
+                    // Create a structured message with the full transcript
+                    // This ensures the agent knows it's a voice message and has the complete transcript
+                    const voiceMessageContext = [
+                        '📢 **Voice Message Received**',
+                        '',
+                        'The user sent a voice message. Here is the complete transcription:',
+                        '',
+                        '---',
+                        transcript,
+                        '---',
+                        '',
+                        'Please respond to the user\'s voice message above.',
+                    ].filter(line => line !== undefined).join('\n');
+                    // Append or set the transcribed text with context
+                    if (message.text && message.text.trim()) {
+                        message.text += `\n\n${voiceMessageContext}`;
+                    }
+                    else {
+                        message.text = voiceMessageContext;
+                    }
+                }
+                else {
+                    const fileName = attachment.fileName || 'voice message';
+                    message.text += message.text ? `\n[Audio: ${fileName} - no speech detected]` : `[Audio: ${fileName} - no speech detected]`;
+                }
+            }
+            catch (error) {
+                console.error('[Router] Failed to transcribe audio:', error);
+                const fileName = attachment.fileName || 'voice message';
+                message.text += message.text ? `\n[Audio: ${fileName} - transcription failed]` : `[Audio: ${fileName} - transcription failed]`;
+            }
+            finally {
+                if (savedAudioPath && fs.existsSync(savedAudioPath)) {
+                    try {
+                        fs.unlinkSync(savedAudioPath);
+                    }
+                    catch (cleanupError) {
+                        console.error('[Router] Failed to delete temp audio file:', cleanupError);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Handle an incoming message
+     */
+    async handleMessage(adapter, message) {
+        const channelType = adapter.type;
+        const channel = this.channelRepo.findByType(channelType);
+        if (!channel) {
+            console.error(`No channel configuration found for ${channelType}`);
+            return;
+        }
+        // Transcribe any audio attachments before processing
+        await this.transcribeAudioAttachments(message);
+        // Log incoming message
+        this.messageRepo.create({
+            channelId: channel.id,
+            channelMessageId: message.messageId,
+            chatId: message.chatId,
+            direction: 'incoming',
+            content: message.text,
+            timestamp: message.timestamp.getTime(),
+        });
+        this.emitEvent({
+            type: 'message:received',
+            channel: channelType,
+            timestamp: new Date(),
+            data: {
+                messageId: message.messageId,
+                chatId: message.chatId,
+                userId: message.userId,
+                preview: message.text.slice(0, 100),
+            },
+        });
+        // Security check
+        const securityResult = await this.securityManager.checkAccess(channel, message);
+        if (!securityResult.allowed) {
+            // Handle unauthorized access
+            await this.handleUnauthorizedMessage(adapter, message, securityResult);
+            return;
+        }
+        // Update user's last seen
+        if (securityResult.user) {
+            this.userRepo.update(securityResult.user.id, {
+                lastSeenAt: Date.now(),
+            });
+        }
+        // Get or create session
+        const session = await this.sessionManager.getOrCreateSession(channel, message.chatId, securityResult.user?.id, this.config.defaultWorkspaceId);
+        // Handle the message based on content
+        await this.routeMessage(adapter, message, session.id);
+    }
+    /**
+     * Handle unauthorized message
+     */
+    async handleUnauthorizedMessage(adapter, message, securityResult) {
+        // If pairing is required, check if the message IS a pairing code or /pair command
+        if (securityResult.pairingRequired) {
+            const text = message.text.trim();
+            // Check if it's a /pair command
+            if (text.toLowerCase().startsWith('/pair ')) {
+                const code = text.slice(6).trim(); // Remove '/pair ' prefix
+                if (code) {
+                    await this.handlePairingAttempt(adapter, message, code);
+                    return;
+                }
+            }
+            // Check if the raw text looks like a pairing code
+            if (this.looksLikePairingCode(text)) {
+                // This looks like a pairing code - try to verify it
+                await this.handlePairingAttempt(adapter, message, text);
+                return;
+            }
+        }
+        // Not a pairing code or pairing not required - send appropriate message
+        let responseText;
+        if (securityResult.pairingRequired) {
+            responseText = this.config.pairingRequiredMessage;
+        }
+        else {
+            responseText = this.config.unauthorizedMessage;
+        }
+        try {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: responseText,
+                replyTo: message.messageId,
+            });
+        }
+        catch (error) {
+            console.error('Failed to send unauthorized message response:', error);
+        }
+    }
+    /**
+     * Route message to appropriate handler
+     */
+    async routeMessage(adapter, message, sessionId) {
+        const text = message.text.trim();
+        // Handle commands
+        if (text.startsWith('/')) {
+            await this.handleCommand(adapter, message, sessionId);
+            return;
+        }
+        // Check if this is a pairing code
+        if (this.looksLikePairingCode(text)) {
+            await this.handlePairingAttempt(adapter, message, text);
+            return;
+        }
+        // Check if session has no workspace - might be workspace selection
+        const session = this.sessionRepo.findById(sessionId);
+        if (!session?.workspaceId) {
+            // Check if this looks like workspace selection (number or short name)
+            const workspaces = this.workspaceRepo.findAll();
+            if (workspaces.length > 0) {
+                // Try to match by number
+                const num = parseInt(text, 10);
+                if (!isNaN(num) && num > 0 && num <= workspaces.length) {
+                    const workspace = workspaces[num - 1];
+                    this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+                    await adapter.sendMessage({
+                        chatId: message.chatId,
+                        text: `✅ *${workspace.name}* selected!\n\nYou can now send me tasks.\n\nExample: "Create a new React component called Button"`,
+                        parseMode: 'markdown',
+                    });
+                    return;
+                }
+                // Try to match by name (case-insensitive partial match)
+                const matchedWorkspace = workspaces.find(ws => ws.name.toLowerCase() === text.toLowerCase() ||
+                    ws.name.toLowerCase().startsWith(text.toLowerCase()));
+                if (matchedWorkspace) {
+                    this.sessionManager.setSessionWorkspace(sessionId, matchedWorkspace.id);
+                    await adapter.sendMessage({
+                        chatId: message.chatId,
+                        text: `✅ *${matchedWorkspace.name}* selected!\n\nYou can now send me tasks.\n\nExample: "Create a new React component called Button"`,
+                        parseMode: 'markdown',
+                    });
+                    return;
+                }
+            }
+            // No workspace match found - auto-assign temp workspace so tasks can proceed
+            const tempWorkspace = this.getOrCreateTempWorkspace();
+            this.sessionManager.setSessionWorkspace(sessionId, tempWorkspace.id);
+        }
+        // Regular message - send to desktop app for task processing
+        await this.forwardToDesktopApp(adapter, message, sessionId);
+    }
+    /**
+     * Handle bot commands
+     */
+    async handleCommand(adapter, message, sessionId) {
+        const [command, ...args] = message.text.trim().split(/\s+/);
+        switch (command.toLowerCase()) {
+            case '/start':
+                await this.handleStartCommand(adapter, message, sessionId);
+                break;
+            case '/help':
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: this.getHelpText(adapter.type),
+                    parseMode: 'markdown',
+                });
+                break;
+            case '/status':
+                await this.handleStatusCommand(adapter, message, sessionId);
+                break;
+            case '/workspaces':
+                await this.handleWorkspacesCommand(adapter, message);
+                break;
+            case '/workspace':
+                await this.handleWorkspaceCommand(adapter, message, sessionId, args);
+                break;
+            case '/cancel':
+                // Cancel current task if any
+                await this.handleCancelCommand(adapter, message, sessionId);
+                break;
+            case '/newtask':
+                // Start a new task (unlink current session)
+                await this.handleNewTaskCommand(adapter, message, sessionId);
+                break;
+            case '/addworkspace':
+                await this.handleAddWorkspaceCommand(adapter, message, sessionId, args);
+                break;
+            case '/models':
+                await this.handleModelsCommand(adapter, message);
+                break;
+            case '/model':
+                await this.handleModelCommand(adapter, message, args);
+                break;
+            case '/provider':
+                await this.handleProviderCommand(adapter, message, args);
+                break;
+            case '/pair':
+                // Handle pairing code
+                if (args.length === 0) {
+                    await adapter.sendMessage({
+                        chatId: message.chatId,
+                        text: '🔐 Please provide a pairing code.\n\nUsage: `/pair <code>`',
+                        parseMode: 'markdown',
+                    });
+                }
+                else {
+                    const code = args[0].trim();
+                    await this.handlePairingAttempt(adapter, message, code);
+                }
+                break;
+            case '/shell':
+                await this.handleShellCommand(adapter, message, sessionId, args);
+                break;
+            case '/approve':
+            case '/yes':
+            case '/y':
+                await this.handleApproveCommand(adapter, message, sessionId);
+                break;
+            case '/deny':
+            case '/no':
+            case '/n':
+                await this.handleDenyCommand(adapter, message, sessionId);
+                break;
+            case '/queue':
+                await this.handleQueueCommand(adapter, message, args);
+                break;
+            case '/removeworkspace':
+                await this.handleRemoveWorkspaceCommand(adapter, message, sessionId, args);
+                break;
+            case '/retry':
+                await this.handleRetryCommand(adapter, message, sessionId);
+                break;
+            case '/history':
+                await this.handleHistoryCommand(adapter, message, sessionId);
+                break;
+            case '/skills':
+                await this.handleSkillsCommand(adapter, message, sessionId);
+                break;
+            case '/skill':
+                await this.handleSkillCommand(adapter, message, sessionId, args);
+                break;
+            case '/providers':
+                await this.handleProvidersCommand(adapter, message);
+                break;
+            case '/settings':
+                await this.handleSettingsCommand(adapter, message, sessionId);
+                break;
+            case '/debug':
+                await this.handleDebugCommand(adapter, message, sessionId);
+                break;
+            case '/version':
+                await this.handleVersionCommand(adapter, message);
+                break;
+            default:
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: `Unknown command: ${command}\n\nUse /help to see available commands.`,
+                    replyTo: message.messageId,
+                });
+        }
+    }
+    /**
+     * Handle /status command
+     */
+    async handleStatusCommand(adapter, message, sessionId) {
+        const session = this.sessionRepo.findById(sessionId);
+        let statusText = '✅ Bot is online and ready.\n\n';
+        if (session?.workspaceId) {
+            const workspace = this.workspaceRepo.findById(session.workspaceId);
+            if (workspace) {
+                statusText += `📁 Current workspace: ${workspace.name}\n`;
+                statusText += `   Path: ${workspace.path}\n`;
+            }
+        }
+        else {
+            statusText += '⚠️ No workspace selected. Use /workspaces to see available workspaces.';
+        }
+        if (session?.taskId) {
+            const task = this.taskRepo.findById(session.taskId);
+            if (task) {
+                statusText += `\n🔄 Active task: ${task.title} (${task.status})`;
+            }
+        }
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: statusText,
+        });
+    }
+    /**
+     * Handle /workspaces command - list available workspaces
+     */
+    async handleWorkspacesCommand(adapter, message) {
+        const workspaces = this.workspaceRepo.findAll();
+        if (workspaces.length === 0) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '📁 No workspaces configured yet.\n\nAdd a workspace in the CoWork desktop app first, or use:\n`/addworkspace /path/to/your/project`',
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // WhatsApp and iMessage don't support inline keyboards - use text-based selection
+        if (adapter.type === 'whatsapp' || adapter.type === 'imessage') {
+            let text = '📁 *Available Workspaces*\n\n';
+            workspaces.forEach((ws, index) => {
+                text += `${index + 1}. *${ws.name}*\n   \`${ws.path}\`\n\n`;
+            });
+            text += '━━━━━━━━━━━━━━━\n';
+            text += 'Reply with the number or name to select.\n';
+            text += 'Example: `1` or `myproject`';
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text,
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // Build inline keyboard with workspace buttons for Telegram/Discord
+        const keyboard = [];
+        for (const ws of workspaces) {
+            // Create one button per row for better readability
+            keyboard.push([{
+                    text: `📁 ${ws.name}`,
+                    callbackData: `workspace:${ws.id}`,
+                }]);
+        }
+        let text = '📁 *Available Workspaces*\n\nTap a workspace to select it:';
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text,
+            parseMode: 'markdown',
+            inlineKeyboard: keyboard,
+            threadId: message.threadId,
+        });
+    }
+    /**
+     * Handle /workspace command - set current workspace
+     */
+    async handleWorkspaceCommand(adapter, message, sessionId, args) {
+        if (args.length === 0) {
+            // Show current workspace
+            let session = this.sessionRepo.findById(sessionId);
+            // Auto-assign temp workspace if none selected
+            if (!session?.workspaceId) {
+                const tempWorkspace = this.getOrCreateTempWorkspace();
+                this.sessionRepo.update(sessionId, { workspaceId: tempWorkspace.id });
+                session = this.sessionRepo.findById(sessionId);
+            }
+            if (session?.workspaceId) {
+                const workspace = this.workspaceRepo.findById(session.workspaceId);
+                if (workspace) {
+                    const isTempWorkspace = workspace.id === types_1.TEMP_WORKSPACE_ID;
+                    const displayName = isTempWorkspace ? 'Temporary Workspace (work in a folder for persistence)' : workspace.name;
+                    await adapter.sendMessage({
+                        chatId: message.chatId,
+                        text: `📁 Current workspace: *${displayName}*\n\`${workspace.path}\`\n\nUse \`/workspaces\` to see available workspaces.`,
+                        parseMode: 'markdown',
+                    });
+                    return;
+                }
+            }
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: 'No workspace selected. Use `/workspaces` to see available workspaces.',
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        const workspaces = this.workspaceRepo.findAll();
+        const selector = args.join(' ');
+        let workspace;
+        // Try to find by number
+        const num = parseInt(selector, 10);
+        if (!isNaN(num) && num > 0 && num <= workspaces.length) {
+            workspace = workspaces[num - 1];
+        }
+        else {
+            // Try to find by name (case-insensitive)
+            workspace = workspaces.find(ws => ws.name.toLowerCase() === selector.toLowerCase());
+        }
+        if (!workspace) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `❌ Workspace not found: "${selector}"\n\nUse /workspaces to see available workspaces.`,
+            });
+            return;
+        }
+        // Update session workspace
+        this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `✅ Workspace set to: *${workspace.name}*\n\`${workspace.path}\`\n\nYou can now send messages to create tasks in this workspace.`,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Handle /addworkspace command - add a new workspace by path
+     */
+    async handleAddWorkspaceCommand(adapter, message, sessionId, args) {
+        if (args.length === 0) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '📁 *Add Workspace*\n\nUsage: `/addworkspace <path>`\n\nExample:\n`/addworkspace /Users/john/projects/myapp`\n`/addworkspace ~/Documents`',
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // Join args to handle paths with spaces
+        let workspacePath = args.join(' ');
+        // Expand ~ to home directory
+        if (workspacePath.startsWith('~')) {
+            const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+            workspacePath = workspacePath.replace('~', homeDir);
+        }
+        // Resolve to absolute path
+        workspacePath = path.resolve(workspacePath);
+        // Check if path exists and is a directory
+        try {
+            const stats = fs.statSync(workspacePath);
+            if (!stats.isDirectory()) {
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: `❌ Path is not a directory: \`${workspacePath}\``,
+                    parseMode: 'markdown',
+                });
+                return;
+            }
+        }
+        catch {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `❌ Directory not found: \`${workspacePath}\``,
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // Check if workspace already exists
+        const existingWorkspaces = this.workspaceRepo.findAll();
+        const existing = existingWorkspaces.find(ws => ws.path === workspacePath);
+        if (existing) {
+            // Workspace exists, just select it
+            this.sessionManager.setSessionWorkspace(sessionId, existing.id);
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `📁 Workspace already exists!\n\n✅ Selected: *${existing.name}*\n\`${existing.path}\``,
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // Create workspace name from path
+        const workspaceName = path.basename(workspacePath);
+        // Create new workspace with default permissions
+        // Note: network is enabled by default for browser tools (web access)
+        const workspace = this.workspaceRepo.create(workspaceName, workspacePath, {
+            read: true,
+            write: true,
+            delete: false, // Requires approval
+            network: true,
+            shell: false, // Requires approval
+        });
+        // Set as current workspace
+        this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+        // Notify desktop app
+        if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+            this.mainWindow.webContents.send('workspace:added', {
+                id: workspace.id,
+                name: workspace.name,
+                path: workspace.path,
+            });
+        }
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `✅ Workspace added and selected!\n\n📁 *${workspace.name}*\n\`${workspace.path}\`\n\nYou can now send messages to create tasks in this workspace.`,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Handle /models command - list available models and providers
+     */
+    async handleModelsCommand(adapter, message) {
+        const status = provider_factory_1.LLMProviderFactory.getConfigStatus();
+        const settings = provider_factory_1.LLMProviderFactory.loadSettings();
+        const providerType = status.currentProvider;
+        let text = '🤖 *AI Models & Providers*\n\n';
+        // Get provider-specific models and current model
+        let models = [];
+        let currentModel = settings.modelKey;
+        // Provider display names
+        const providerModelNames = {
+            'anthropic': 'Claude',
+            'bedrock': 'Claude',
+            'openai': 'OpenAI',
+            'gemini': 'Gemini',
+            'openrouter': 'OpenRouter',
+            'ollama': 'Ollama',
+        };
+        // Get models based on current provider
+        switch (providerType) {
+            case 'anthropic':
+            case 'bedrock':
+                models = status.models;
+                break;
+            case 'openai': {
+                currentModel = settings.openai?.model || 'gpt-4o-mini';
+                const cachedOpenAI = provider_factory_1.LLMProviderFactory.getCachedModels('openai');
+                if (cachedOpenAI && cachedOpenAI.length > 0) {
+                    models = cachedOpenAI;
+                }
+                else {
+                    // Default OpenAI models
+                    models = [
+                        { key: 'gpt-4o', displayName: 'GPT-4o' },
+                        { key: 'gpt-4o-mini', displayName: 'GPT-4o Mini' },
+                        { key: 'gpt-4-turbo', displayName: 'GPT-4 Turbo' },
+                        { key: 'gpt-3.5-turbo', displayName: 'GPT-3.5 Turbo' },
+                        { key: 'o1', displayName: 'o1' },
+                        { key: 'o1-mini', displayName: 'o1 Mini' },
+                    ];
+                }
+                break;
+            }
+            case 'gemini': {
+                currentModel = settings.gemini?.model || 'gemini-2.0-flash';
+                const cachedGemini = provider_factory_1.LLMProviderFactory.getCachedModels('gemini');
+                if (cachedGemini && cachedGemini.length > 0) {
+                    models = cachedGemini;
+                }
+                else {
+                    models = [
+                        { key: 'gemini-2.0-flash', displayName: 'Gemini 2.0 Flash' },
+                        { key: 'gemini-1.5-pro', displayName: 'Gemini 1.5 Pro' },
+                        { key: 'gemini-1.5-flash', displayName: 'Gemini 1.5 Flash' },
+                    ];
+                }
+                break;
+            }
+            case 'openrouter': {
+                currentModel = settings.openrouter?.model || 'anthropic/claude-3.5-sonnet';
+                const cachedOpenRouter = provider_factory_1.LLMProviderFactory.getCachedModels('openrouter');
+                if (cachedOpenRouter && cachedOpenRouter.length > 0) {
+                    models = cachedOpenRouter.slice(0, 10); // Limit to 10 for readability
+                }
+                else {
+                    models = [
+                        { key: 'anthropic/claude-3.5-sonnet', displayName: 'Claude 3.5 Sonnet' },
+                        { key: 'openai/gpt-4o', displayName: 'GPT-4o' },
+                        { key: 'google/gemini-pro', displayName: 'Gemini Pro' },
+                    ];
+                }
+                break;
+            }
+            case 'ollama': {
+                // Ollama handled separately below
+                break;
+            }
+            default:
+                models = status.models;
+        }
+        // Current configuration
+        text += '*Current:*\n';
+        const currentProvider = status.providers.find(p => p.type === providerType);
+        text += `• Provider: ${currentProvider?.name || providerType}\n`;
+        if (providerType === 'ollama') {
+            const ollamaModel = settings.ollama?.model || 'llama3.2';
+            text += `• Model: ${ollamaModel}\n\n`;
+        }
+        else {
+            const modelInfo = models.find(m => m.key === currentModel);
+            text += `• Model: ${modelInfo?.displayName || currentModel}\n\n`;
+        }
+        // Available providers
+        text += '*Available Providers:*\n';
+        status.providers.forEach(provider => {
+            const isActive = provider.type === providerType ? ' ✓' : '';
+            const configStatus = provider.configured ? '🟢' : '⚪';
+            text += `${configStatus} ${provider.name}${isActive}\n`;
+        });
+        text += '\n';
+        // Available models - show different list based on provider
+        if (providerType === 'ollama') {
+            text += '*Available Ollama Models:*\n';
+            try {
+                const ollamaModels = await provider_factory_1.LLMProviderFactory.getOllamaModels();
+                const currentOllamaModel = settings.ollama?.model || 'llama3.2';
+                if (ollamaModels.length === 0) {
+                    text += '⚠️ No models found. Run `ollama pull <model>` to download.\n';
+                }
+                else {
+                    ollamaModels.slice(0, 10).forEach((model, index) => {
+                        const isActive = model.name === currentOllamaModel ? ' ✓' : '';
+                        const sizeGB = (model.size / 1e9).toFixed(1);
+                        text += `${index + 1}. ${model.name} (${sizeGB}GB)${isActive}\n`;
+                    });
+                    if (ollamaModels.length > 10) {
+                        text += `   ... and ${ollamaModels.length - 10} more\n`;
+                    }
+                }
+            }
+            catch {
+                text += '⚠️ Could not fetch Ollama models. Is Ollama running?\n';
+            }
+            text += '\n💡 Use `/model <name>` to switch (e.g., `/model llama3.2`)';
+        }
+        else {
+            const modelBrand = providerModelNames[providerType] || 'Available';
+            text += `*Available ${modelBrand} Models:*\n`;
+            models.forEach((model, index) => {
+                const isActive = model.key === currentModel ? ' ✓' : '';
+                text += `${index + 1}. ${model.displayName}${isActive}\n`;
+            });
+            text += '\n💡 Use `/model <name>` to switch\n';
+            text += 'Example: `/model 2` or `/model <model-name>`';
+        }
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Handle /model command - show or change current model within current provider
+     */
+    async handleModelCommand(adapter, message, args) {
+        const status = provider_factory_1.LLMProviderFactory.getConfigStatus();
+        const settings = provider_factory_1.LLMProviderFactory.loadSettings();
+        const providerType = status.currentProvider;
+        const currentProviderInfo = status.providers.find(p => p.type === providerType);
+        // Get provider-specific models and current model
+        let models = [];
+        let currentModel = settings.modelKey;
+        // Get models based on current provider
+        switch (providerType) {
+            case 'anthropic':
+            case 'bedrock':
+                models = status.models;
+                break;
+            case 'openai': {
+                currentModel = settings.openai?.model || 'gpt-4o-mini';
+                const cachedOpenAI = provider_factory_1.LLMProviderFactory.getCachedModels('openai');
+                if (cachedOpenAI && cachedOpenAI.length > 0) {
+                    models = cachedOpenAI;
+                }
+                else {
+                    models = [
+                        { key: 'gpt-4o', displayName: 'GPT-4o' },
+                        { key: 'gpt-4o-mini', displayName: 'GPT-4o Mini' },
+                        { key: 'gpt-4-turbo', displayName: 'GPT-4 Turbo' },
+                        { key: 'gpt-3.5-turbo', displayName: 'GPT-3.5 Turbo' },
+                        { key: 'o1', displayName: 'o1' },
+                        { key: 'o1-mini', displayName: 'o1 Mini' },
+                    ];
+                }
+                break;
+            }
+            case 'gemini': {
+                currentModel = settings.gemini?.model || 'gemini-2.0-flash';
+                const cachedGemini = provider_factory_1.LLMProviderFactory.getCachedModels('gemini');
+                if (cachedGemini && cachedGemini.length > 0) {
+                    models = cachedGemini;
+                }
+                else {
+                    models = [
+                        { key: 'gemini-2.0-flash', displayName: 'Gemini 2.0 Flash' },
+                        { key: 'gemini-1.5-pro', displayName: 'Gemini 1.5 Pro' },
+                        { key: 'gemini-1.5-flash', displayName: 'Gemini 1.5 Flash' },
+                    ];
+                }
+                break;
+            }
+            case 'openrouter': {
+                currentModel = settings.openrouter?.model || 'anthropic/claude-3.5-sonnet';
+                const cachedOpenRouter = provider_factory_1.LLMProviderFactory.getCachedModels('openrouter');
+                if (cachedOpenRouter && cachedOpenRouter.length > 0) {
+                    models = cachedOpenRouter.slice(0, 10);
+                }
+                else {
+                    models = [
+                        { key: 'anthropic/claude-3.5-sonnet', displayName: 'Claude 3.5 Sonnet' },
+                        { key: 'openai/gpt-4o', displayName: 'GPT-4o' },
+                        { key: 'google/gemini-pro', displayName: 'Gemini Pro' },
+                    ];
+                }
+                break;
+            }
+            case 'ollama':
+                // Handled separately
+                break;
+            default:
+                models = status.models;
+        }
+        // If no args, show current model and available models
+        if (args.length === 0) {
+            let text = '🤖 *Current Model*\n\n';
+            text += `• Provider: ${currentProviderInfo?.name || providerType}\n`;
+            if (providerType === 'ollama') {
+                const ollamaModel = settings.ollama?.model || 'llama3.2';
+                text += `• Model: ${ollamaModel}\n\n`;
+                text += '*Available Models:*\n';
+                try {
+                    const ollamaModels = await provider_factory_1.LLMProviderFactory.getOllamaModels();
+                    if (ollamaModels.length === 0) {
+                        text += '⚠️ No models found.\n';
+                    }
+                    else {
+                        ollamaModels.slice(0, 8).forEach((model, index) => {
+                            const isActive = model.name === ollamaModel ? ' ✓' : '';
+                            const sizeGB = (model.size / 1e9).toFixed(1);
+                            text += `${index + 1}. ${model.name} (${sizeGB}GB)${isActive}\n`;
+                        });
+                        if (ollamaModels.length > 8) {
+                            text += `   ... and ${ollamaModels.length - 8} more\n`;
+                        }
+                    }
+                }
+                catch {
+                    text += '⚠️ Could not fetch models.\n';
+                }
+                text += '\n💡 Use `/model <name>` or `/model <number>` to switch';
+            }
+            else {
+                const modelInfo = models.find(m => m.key === currentModel);
+                text += `• Model: ${modelInfo?.displayName || currentModel}\n\n`;
+                text += '*Available Models:*\n';
+                models.forEach((model, index) => {
+                    const isActive = model.key === currentModel ? ' ✓' : '';
+                    text += `${index + 1}. ${model.displayName}${isActive}\n`;
+                });
+                text += '\n💡 Use `/model <name>` or `/model <number>` to switch';
+            }
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text,
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // Change model within current provider
+        const selector = args.join(' ').toLowerCase();
+        if (providerType === 'ollama') {
+            const result = await this.selectOllamaModel(selector, args);
+            if (!result.success) {
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: result.error,
+                    parseMode: 'markdown',
+                });
+                return;
+            }
+            const newSettings = {
+                ...settings,
+                ollama: {
+                    ...settings.ollama,
+                    model: result.model,
+                },
+            };
+            provider_factory_1.LLMProviderFactory.saveSettings(newSettings);
+            provider_factory_1.LLMProviderFactory.clearCache();
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `✅ Model changed to: *${result.model}*`,
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // For all other providers, use the provider-specific model list
+        const result = this.selectClaudeModel(selector, models);
+        if (!result.success) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: result.error,
+            });
+            return;
+        }
+        // Save to the appropriate provider-specific setting
+        let newSettings = { ...settings };
+        switch (providerType) {
+            case 'openai':
+                newSettings.openai = {
+                    ...settings.openai,
+                    model: result.model.key,
+                };
+                break;
+            case 'gemini':
+                newSettings.gemini = {
+                    ...settings.gemini,
+                    model: result.model.key,
+                };
+                break;
+            case 'openrouter':
+                newSettings.openrouter = {
+                    ...settings.openrouter,
+                    model: result.model.key,
+                };
+                break;
+            case 'anthropic':
+            case 'bedrock':
+            default:
+                newSettings.modelKey = result.model.key;
+                break;
+        }
+        provider_factory_1.LLMProviderFactory.saveSettings(newSettings);
+        provider_factory_1.LLMProviderFactory.clearCache();
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `✅ Model changed to: *${result.model.displayName}*`,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Handle /provider command - show or change current provider
+     */
+    async handleProviderCommand(adapter, message, args) {
+        const status = provider_factory_1.LLMProviderFactory.getConfigStatus();
+        const settings = provider_factory_1.LLMProviderFactory.loadSettings();
+        // If no args, show current provider and available options
+        if (args.length === 0) {
+            const currentProvider = status.providers.find(p => p.type === status.currentProvider);
+            let text = '🔌 *Current Provider*\n\n';
+            text += `• Provider: ${currentProvider?.name || status.currentProvider}\n`;
+            // Show current model for context
+            if (status.currentProvider === 'ollama') {
+                text += `• Model: ${settings.ollama?.model || 'gpt-oss:20b'}\n\n`;
+            }
+            else {
+                const currentModel = status.models.find(m => m.key === status.currentModel);
+                text += `• Model: ${currentModel?.displayName || status.currentModel}\n\n`;
+            }
+            text += '*Available Providers:*\n';
+            text += '1. anthropic - Anthropic API (direct)\n';
+            text += '2. openai - OpenAI/ChatGPT\n';
+            text += '3. gemini - Google Gemini\n';
+            text += '4. openrouter - OpenRouter\n';
+            text += '5. bedrock - AWS Bedrock\n';
+            text += '6. ollama - Ollama (local)\n\n';
+            text += '💡 Use `/provider <name>` to switch\n';
+            text += 'Example: `/provider bedrock` or `/provider 2`';
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text,
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        const selector = args[0].toLowerCase();
+        // Map of provider shortcuts
+        const providerMap = {
+            '1': 'anthropic',
+            'anthropic': 'anthropic',
+            'api': 'anthropic',
+            '2': 'openai',
+            'openai': 'openai',
+            'chatgpt': 'openai',
+            '3': 'gemini',
+            'gemini': 'gemini',
+            'google': 'gemini',
+            '4': 'openrouter',
+            'openrouter': 'openrouter',
+            'or': 'openrouter',
+            '5': 'bedrock',
+            'bedrock': 'bedrock',
+            'aws': 'bedrock',
+            '6': 'ollama',
+            'ollama': 'ollama',
+            'local': 'ollama',
+        };
+        const targetProvider = providerMap[selector];
+        if (!targetProvider) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `❌ Unknown provider: "${args[0]}"\n\n*Available providers:*\n1. anthropic\n2. openai\n3. gemini\n4. openrouter\n5. bedrock\n6. ollama\n\nUse \`/provider <name>\` or \`/provider <number>\``,
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // Update provider
+        const newSettings = {
+            ...settings,
+            providerType: targetProvider,
+        };
+        provider_factory_1.LLMProviderFactory.saveSettings(newSettings);
+        provider_factory_1.LLMProviderFactory.clearCache();
+        // Get provider display info
+        const providerInfo = status.providers.find(p => p.type === targetProvider);
+        let modelInfo;
+        if (targetProvider === 'ollama') {
+            modelInfo = settings.ollama?.model || 'gpt-oss:20b';
+        }
+        else {
+            const model = status.models.find(m => m.key === settings.modelKey);
+            modelInfo = model?.displayName || settings.modelKey;
+        }
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `✅ Provider changed to: *${providerInfo?.name || targetProvider}*\n\nCurrent model: ${modelInfo}\n\nUse \`/model\` to see available models for this provider.`,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Handle /shell command - enable or disable shell execution permission
+     */
+    async handleShellCommand(adapter, message, sessionId, args) {
+        let session = this.sessionRepo.findById(sessionId);
+        // Auto-assign temp workspace if none selected
+        if (!session?.workspaceId) {
+            const tempWorkspace = this.getOrCreateTempWorkspace();
+            this.sessionRepo.update(sessionId, { workspaceId: tempWorkspace.id });
+            session = this.sessionRepo.findById(sessionId);
+        }
+        const workspace = this.workspaceRepo.findById(session.workspaceId);
+        if (!workspace) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Workspace not found.',
+            });
+            return;
+        }
+        // If no args, show current status
+        if (args.length === 0) {
+            const status = workspace.permissions.shell ? '🟢 Enabled' : '🔴 Disabled';
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `🖥️ *Shell Commands*\n\nStatus: ${status}\n\nWhen enabled, the AI can execute shell commands like \`npm install\`, \`git\`, etc. Each command requires your approval before running.\n\n*Usage:*\n• \`/shell on\` - Enable shell commands\n• \`/shell off\` - Disable shell commands`,
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        const action = args[0].toLowerCase();
+        let newShellPermission;
+        if (action === 'on' || action === 'enable' || action === '1' || action === 'true') {
+            newShellPermission = true;
+        }
+        else if (action === 'off' || action === 'disable' || action === '0' || action === 'false') {
+            newShellPermission = false;
+        }
+        else {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Invalid option. Use `/shell on` or `/shell off`',
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        // Update workspace permissions
+        const updatedPermissions = {
+            ...workspace.permissions,
+            shell: newShellPermission,
+        };
+        // Update in database
+        this.workspaceRepo.updatePermissions(workspace.id, updatedPermissions);
+        const statusText = newShellPermission ? '🟢 enabled' : '🔴 disabled';
+        const warning = newShellPermission
+            ? '\n\n⚠️ The AI will now ask for approval before running each command.'
+            : '';
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `✅ Shell commands ${statusText} for workspace *${workspace.name}*${warning}`,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Helper to select an Ollama model from available models
+     */
+    async selectOllamaModel(selector, originalArgs) {
+        let ollamaModels = [];
+        try {
+            ollamaModels = await provider_factory_1.LLMProviderFactory.getOllamaModels();
+        }
+        catch {
+            return {
+                success: false,
+                error: `❌ Could not fetch Ollama models. Is Ollama running?\n\nMake sure Ollama is running with \`ollama serve\``,
+            };
+        }
+        if (ollamaModels.length === 0) {
+            return {
+                success: false,
+                error: `❌ No Ollama models found.\n\nRun \`ollama pull <model>\` to download a model first.`,
+            };
+        }
+        let selectedModel;
+        // Try to find model by number
+        const num = parseInt(selector, 10);
+        if (!isNaN(num) && num > 0 && num <= ollamaModels.length) {
+            selectedModel = ollamaModels[num - 1].name;
+        }
+        else {
+            // Try to find by name (exact or partial match)
+            const match = ollamaModels.find(m => m.name.toLowerCase() === selector ||
+                m.name.toLowerCase().includes(selector));
+            if (match) {
+                selectedModel = match.name;
+            }
+        }
+        if (!selectedModel) {
+            const modelList = ollamaModels.slice(0, 5).map((m, i) => `${i + 1}. ${m.name}`).join('\n');
+            const moreText = ollamaModels.length > 5 ? `\n   ... and ${ollamaModels.length - 5} more` : '';
+            return {
+                success: false,
+                error: `❌ Model not found: "${originalArgs.join(' ')}"\n\n*Available Ollama models:*\n${modelList}${moreText}\n\nUse \`/model <name>\` or \`/model <number>\``,
+            };
+        }
+        return { success: true, model: selectedModel };
+    }
+    /**
+     * Helper to select a Claude model from available models
+     */
+    selectClaudeModel(selector, models) {
+        let selectedModel;
+        // Try to find model by number
+        const num = parseInt(selector, 10);
+        if (!isNaN(num) && num > 0 && num <= models.length) {
+            selectedModel = models[num - 1];
+        }
+        else {
+            // Try to find by name (partial match)
+            selectedModel = models.find(m => m.key.toLowerCase() === selector ||
+                m.key.toLowerCase().includes(selector) ||
+                m.displayName.toLowerCase().includes(selector));
+        }
+        if (!selectedModel) {
+            return {
+                success: false,
+                error: `❌ Model not found: "${selector}"\n\nUse /models to see available options.`,
+            };
+        }
+        return { success: true, model: selectedModel };
+    }
+    /**
+     * Check if text looks like a pairing code
+     */
+    looksLikePairingCode(text) {
+        // Pairing codes are typically 6-8 alphanumeric characters
+        return /^[A-Z0-9]{6,8}$/i.test(text);
+    }
+    /**
+     * Handle pairing code attempt
+     */
+    async handlePairingAttempt(adapter, message, code) {
+        const channel = this.channelRepo.findByType(adapter.type);
+        if (!channel)
+            return;
+        const result = await this.securityManager.verifyPairingCode(channel, message.userId, code);
+        if (result.success) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '✅ Pairing successful! You can now use the bot.',
+                replyTo: message.messageId,
+            });
+            this.emitEvent({
+                type: 'user:paired',
+                channel: adapter.type,
+                timestamp: new Date(),
+                data: { userId: message.userId, userName: message.userName },
+            });
+        }
+        else {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `❌ ${result.error || 'Invalid pairing code. Please try again.'}`,
+                replyTo: message.messageId,
+            });
+        }
+    }
+    /**
+     * Forward message to desktop app / create task
+     */
+    async forwardToDesktopApp(adapter, message, sessionId) {
+        let session = this.sessionRepo.findById(sessionId);
+        // Auto-assign temp workspace if none selected
+        if (!session?.workspaceId) {
+            const tempWorkspace = this.getOrCreateTempWorkspace();
+            this.sessionManager.setSessionWorkspace(sessionId, tempWorkspace.id);
+            session = this.sessionRepo.findById(sessionId);
+        }
+        // Check if there's an existing task for this session (active or completed)
+        if (session.taskId) {
+            const existingTask = this.taskRepo.findById(session.taskId);
+            if (existingTask) {
+                // For active tasks, send follow-up message
+                // For completed tasks, also allow follow-up (continues the conversation)
+                const activeStatuses = ['pending', 'planning', 'executing', 'paused'];
+                const isActive = activeStatuses.includes(existingTask.status);
+                const isCompleted = existingTask.status === 'completed';
+                if (isActive || isCompleted) {
+                    if (this.agentDaemon) {
+                        try {
+                            const statusMsg = isActive
+                                ? '💬 Sending follow-up message...'
+                                : '💬 Continuing conversation...';
+                            await adapter.sendMessage({
+                                chatId: message.chatId,
+                                text: statusMsg,
+                                replyTo: message.messageId,
+                            });
+                            // Re-register task for response tracking (may have been removed after initial completion)
+                            this.pendingTaskResponses.set(session.taskId, {
+                                adapter,
+                                chatId: message.chatId,
+                                sessionId,
+                            });
+                            await this.agentDaemon.sendMessage(session.taskId, message.text);
+                        }
+                        catch (error) {
+                            console.error('Error sending follow-up message:', error);
+                            await adapter.sendMessage({
+                                chatId: message.chatId,
+                                text: '❌ Failed to send message. Use /newtask to start a new task.',
+                            });
+                        }
+                    }
+                    return;
+                }
+                // Task is in failed/cancelled state - unlink and create new task
+                this.sessionManager.unlinkSessionFromTask(sessionId);
+            }
+        }
+        // Create a new task
+        if (!this.agentDaemon) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Agent not available. Please try again later.',
+                replyTo: message.messageId,
+            });
+            return;
+        }
+        // Get workspace
+        const workspace = this.workspaceRepo.findById(session.workspaceId);
+        if (!workspace) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Workspace not found. Please select a workspace with /workspace.',
+                replyTo: message.messageId,
+            });
+            return;
+        }
+        // Create task
+        const taskTitle = message.text.length > 50
+            ? message.text.substring(0, 50) + '...'
+            : message.text;
+        const task = this.taskRepo.create({
+            workspaceId: workspace.id,
+            title: taskTitle,
+            prompt: message.text,
+            status: 'pending',
+        });
+        // Link session to task
+        this.sessionManager.linkSessionToTask(sessionId, task.id);
+        // Track this task for response handling
+        this.pendingTaskResponses.set(task.id, {
+            adapter,
+            chatId: message.chatId,
+            sessionId,
+            originalMessageId: message.messageId, // Track for reaction updates
+        });
+        // Start draft streaming for real-time response preview (Telegram)
+        if (adapter instanceof telegram_1.TelegramAdapter) {
+            await adapter.startDraftStream(message.chatId);
+        }
+        // Send acknowledgment - concise for WhatsApp and iMessage
+        const ackMessage = (adapter.type === 'whatsapp' || adapter.type === 'imessage')
+            ? `⏳ Working on it...`
+            : `🚀 Task Started: "${taskTitle}"\n\nI'll notify you when it's complete or if I need your input.`;
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: ackMessage,
+            replyTo: message.messageId,
+        });
+        // Notify desktop app via IPC
+        if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+            this.mainWindow.webContents.send('gateway:message', {
+                channel: adapter.type,
+                sessionId,
+                taskId: task.id,
+                message: {
+                    id: message.messageId,
+                    userId: message.userId,
+                    userName: message.userName,
+                    chatId: message.chatId,
+                    text: message.text,
+                    timestamp: message.timestamp.getTime(),
+                },
+            });
+        }
+        // Start task execution
+        try {
+            await this.agentDaemon.startTask(task);
+        }
+        catch (error) {
+            console.error('Error starting task:', error);
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `❌ Failed to start task: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+            // Cleanup
+            this.pendingTaskResponses.delete(task.id);
+            this.sessionManager.unlinkSessionFromTask(sessionId);
+        }
+    }
+    /**
+     * Send task update to channel
+     * Uses draft streaming for Telegram to show real-time progress
+     */
+    async sendTaskUpdate(taskId, text, isStreaming = false) {
+        const pending = this.pendingTaskResponses.get(taskId);
+        if (!pending) {
+            // This is expected for tasks started from the UI (not via Telegram)
+            return;
+        }
+        try {
+            // Use draft streaming for Telegram when streaming content
+            if (isStreaming && pending.adapter instanceof telegram_1.TelegramAdapter) {
+                await pending.adapter.updateDraftStream(pending.chatId, text);
+            }
+            else {
+                await pending.adapter.sendMessage({
+                    chatId: pending.chatId,
+                    text,
+                    parseMode: 'markdown',
+                });
+            }
+        }
+        catch (error) {
+            console.error('Error sending task update:', error);
+        }
+    }
+    /**
+     * Send typing indicator to channel
+     */
+    async sendTypingIndicator(taskId) {
+        const pending = this.pendingTaskResponses.get(taskId);
+        if (!pending)
+            return;
+        if (pending.adapter instanceof telegram_1.TelegramAdapter) {
+            await pending.adapter.sendTyping(pending.chatId);
+        }
+    }
+    /**
+     * Send any artifacts (images, documents) created during task execution
+     * Called when follow-ups complete to deliver screenshots, etc.
+     */
+    async sendArtifacts(taskId) {
+        const pending = this.pendingTaskResponses.get(taskId);
+        if (!pending) {
+            return;
+        }
+        await this.sendTaskArtifacts(taskId, pending.adapter, pending.chatId);
+    }
+    /**
+     * Handle task completion
+     * Note: We keep the session linked to the task for follow-up messages
+     */
+    async handleTaskCompletion(taskId, result) {
+        const pending = this.pendingTaskResponses.get(taskId);
+        if (!pending)
+            return;
+        try {
+            // WhatsApp/iMessage-optimized completion message (no follow-up hint)
+            const isSimpleMessaging = pending.adapter.type === 'whatsapp' || pending.adapter.type === 'imessage';
+            const msgCtx = this.getMessageContext();
+            const message = (0, channelMessages_1.getCompletionMessage)(msgCtx, result, !isSimpleMessaging);
+            // Finalize draft stream if using Telegram
+            if (pending.adapter instanceof telegram_1.TelegramAdapter) {
+                // Finalize the streaming draft with final message
+                await pending.adapter.finalizeDraftStream(pending.chatId, message);
+                // Update reaction from 👀 to ✅ on the original message
+                if (pending.originalMessageId) {
+                    await pending.adapter.sendCompletionReaction(pending.chatId, pending.originalMessageId);
+                }
+            }
+            else {
+                // Split long messages (Telegram has 4096 char limit, WhatsApp/iMessage ~65k but keep it reasonable)
+                const maxLen = isSimpleMessaging ? 4000 : 4000;
+                const chunks = this.splitMessage(message, maxLen);
+                for (const chunk of chunks) {
+                    await pending.adapter.sendMessage({
+                        chatId: pending.chatId,
+                        text: chunk,
+                        parseMode: 'markdown',
+                    });
+                }
+            }
+            // Send artifacts if any were created
+            await this.sendTaskArtifacts(taskId, pending.adapter, pending.chatId);
+            // Don't unlink session - keep it linked for follow-up messages
+            // User can use /newtask to explicitly start a new task
+        }
+        catch (error) {
+            console.error('Error sending task completion:', error);
+        }
+        finally {
+            this.pendingTaskResponses.delete(taskId);
+        }
+    }
+    /**
+     * Send task artifacts as documents/images to the channel
+     */
+    async sendTaskArtifacts(taskId, adapter, chatId) {
+        try {
+            const artifacts = this.artifactRepo.findByTaskId(taskId);
+            if (artifacts.length === 0)
+                return;
+            // Image extensions
+            const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp'];
+            // Document extensions
+            const documentExtensions = [
+                '.docx', '.xlsx', '.pptx', '.pdf', '.doc', '.xls', '.ppt',
+                '.txt', '.csv', '.json', '.md', '.html', '.xml'
+            ];
+            // Filter for sendable file types
+            const sendableArtifacts = artifacts.filter(artifact => {
+                const ext = path.extname(artifact.path).toLowerCase();
+                return (imageExtensions.includes(ext) || documentExtensions.includes(ext)) && fs.existsSync(artifact.path);
+            });
+            if (sendableArtifacts.length === 0)
+                return;
+            // Send each artifact
+            for (const artifact of sendableArtifacts) {
+                try {
+                    const ext = path.extname(artifact.path).toLowerCase();
+                    const fileName = path.basename(artifact.path);
+                    if (imageExtensions.includes(ext) && adapter.sendPhoto) {
+                        // Send as photo for better display
+                        await adapter.sendPhoto(chatId, artifact.path, `📷 ${fileName}`);
+                        console.log(`Sent image: ${fileName}`);
+                    }
+                    else if (adapter.sendDocument) {
+                        // Send as document
+                        await adapter.sendDocument(chatId, artifact.path, `📎 ${fileName}`);
+                        console.log(`Sent document: ${fileName}`);
+                    }
+                    else {
+                        console.log(`Adapter does not support sending ${ext} files, skipping: ${fileName}`);
+                    }
+                }
+                catch (err) {
+                    console.error(`Failed to send artifact ${artifact.path}:`, err);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error sending task artifacts:', error);
+        }
+    }
+    /**
+     * Handle task failure
+     */
+    async handleTaskFailure(taskId, error) {
+        const pending = this.pendingTaskResponses.get(taskId);
+        if (!pending)
+            return;
+        try {
+            // Cancel any draft stream
+            if (pending.adapter instanceof telegram_1.TelegramAdapter) {
+                await pending.adapter.cancelDraftStream(pending.chatId);
+                // Remove ACK reaction on failure
+                if (pending.originalMessageId) {
+                    await pending.adapter.removeAckReaction(pending.chatId, pending.originalMessageId);
+                }
+            }
+            const message = (0, channelMessages_1.getChannelMessage)('taskFailed', this.getMessageContext(), { error });
+            await pending.adapter.sendMessage({
+                chatId: pending.chatId,
+                text: message,
+            });
+            // Unlink session from task
+            this.sessionManager.unlinkSessionFromTask(pending.sessionId);
+        }
+        catch (err) {
+            console.error('Error sending task failure:', err);
+        }
+        finally {
+            this.pendingTaskResponses.delete(taskId);
+        }
+    }
+    /**
+     * Send approval request to Discord/Telegram
+     */
+    async sendApprovalRequest(taskId, approval) {
+        const pending = this.pendingTaskResponses.get(taskId);
+        if (!pending)
+            return;
+        // Store approval for response handling
+        this.pendingApprovals.set(approval.id, {
+            taskId,
+            approval,
+            sessionId: pending.sessionId,
+        });
+        // Format approval message
+        let message = `🔐 *Approval Required*\n\n`;
+        message += `**${approval.description}**\n\n`;
+        if (approval.type === 'run_command' && approval.details?.command) {
+            message += `\`\`\`\n${approval.details.command}\n\`\`\`\n\n`;
+        }
+        else if (approval.details) {
+            message += `Details: ${JSON.stringify(approval.details, null, 2)}\n\n`;
+        }
+        message += `⏳ _Expires in 5 minutes_`;
+        // WhatsApp/iMessage don't support inline keyboards - use text commands
+        if (pending.adapter.type === 'whatsapp' || pending.adapter.type === 'imessage') {
+            message += `\n\n━━━━━━━━━━━━━━━\nReply */approve* or */deny*`;
+            try {
+                await pending.adapter.sendMessage({
+                    chatId: pending.chatId,
+                    text: message,
+                    parseMode: 'markdown',
+                });
+            }
+            catch (error) {
+                console.error('Error sending approval request:', error);
+            }
+        }
+        else {
+            // Create inline keyboard with Approve/Deny buttons for Telegram/Discord
+            const keyboard = [
+                [
+                    { text: '✅ Approve', callbackData: 'approve:' + approval.id },
+                    { text: '❌ Deny', callbackData: 'deny:' + approval.id },
+                ],
+            ];
+            try {
+                await pending.adapter.sendMessage({
+                    chatId: pending.chatId,
+                    text: message,
+                    parseMode: 'markdown',
+                    inlineKeyboard: keyboard,
+                });
+            }
+            catch (error) {
+                console.error('Error sending approval request:', error);
+            }
+        }
+    }
+    /**
+     * Handle /approve command
+     */
+    async handleApproveCommand(adapter, message, sessionId) {
+        // Find pending approval for this session
+        const approvalEntry = Array.from(this.pendingApprovals.entries())
+            .find(([, data]) => data.sessionId === sessionId);
+        if (!approvalEntry) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ No pending approval request.',
+            });
+            return;
+        }
+        const [approvalId, data] = approvalEntry;
+        this.pendingApprovals.delete(approvalId);
+        try {
+            await this.agentDaemon?.respondToApproval(approvalId, true);
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '✅ Approved! Executing...',
+            });
+        }
+        catch (error) {
+            console.error('Error responding to approval:', error);
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Failed to process approval.',
+            });
+        }
+    }
+    /**
+     * Handle /deny command
+     */
+    async handleDenyCommand(adapter, message, sessionId) {
+        // Find pending approval for this session
+        const approvalEntry = Array.from(this.pendingApprovals.entries())
+            .find(([, data]) => data.sessionId === sessionId);
+        if (!approvalEntry) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ No pending approval request.',
+            });
+            return;
+        }
+        const [approvalId] = approvalEntry;
+        this.pendingApprovals.delete(approvalId);
+        try {
+            await this.agentDaemon?.respondToApproval(approvalId, false);
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '🛑 Denied. Action cancelled.',
+            });
+        }
+        catch (error) {
+            console.error('Error responding to denial:', error);
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Failed to process denial.',
+            });
+        }
+    }
+    /**
+     * Handle /queue command - view or clear task queue
+     */
+    async handleQueueCommand(adapter, message, args) {
+        if (!this.agentDaemon) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Agent daemon not available.',
+            });
+            return;
+        }
+        const subcommand = args[0]?.toLowerCase();
+        if (subcommand === 'clear' || subcommand === 'reset') {
+            // Clear stuck tasks (also properly cancels running tasks to clean up browser sessions)
+            const result = await this.agentDaemon.clearStuckTasks();
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `✅ Queue cleared!\n\n• Running tasks cancelled: ${result.clearedRunning}\n• Queued tasks removed: ${result.clearedQueued}\n\nBrowser sessions and other resources have been cleaned up. You can now start new tasks.`,
+            });
+        }
+        else {
+            // Show queue status
+            const status = this.agentDaemon.getQueueStatus();
+            const statusText = `📊 *Queue Status*
+
+• Running: ${status.runningCount}/${status.maxConcurrent}
+• Queued: ${status.queuedCount}
+
+${status.runningCount > 0 ? `Running task IDs: ${status.runningTaskIds.join(', ')}` : ''}
+${status.queuedCount > 0 ? `Queued task IDs: ${status.queuedTaskIds.join(', ')}` : ''}
+
+*Commands:*
+• \`/queue\` - Show this status
+• \`/queue clear\` - Clear stuck tasks`;
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: statusText,
+                parseMode: 'markdown',
+            });
+        }
+    }
+    /**
+     * Split a message into chunks for Telegram's character limit
+     */
+    splitMessage(text, maxLength) {
+        if (text.length <= maxLength) {
+            return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+            if (remaining.length <= maxLength) {
+                chunks.push(remaining);
+                break;
+            }
+            // Try to split at newline
+            let splitIndex = remaining.lastIndexOf('\n', maxLength);
+            if (splitIndex === -1 || splitIndex < maxLength / 2) {
+                // Try to split at space
+                splitIndex = remaining.lastIndexOf(' ', maxLength);
+            }
+            if (splitIndex === -1 || splitIndex < maxLength / 2) {
+                // Force split
+                splitIndex = maxLength;
+            }
+            chunks.push(remaining.substring(0, splitIndex));
+            remaining = remaining.substring(splitIndex).trimStart();
+        }
+        return chunks;
+    }
+    /**
+     * Handle cancel command
+     */
+    async handleCancelCommand(adapter, message, sessionId) {
+        const session = this.sessionRepo.findById(sessionId);
+        if (session?.taskId) {
+            // Notify desktop app to cancel the task
+            if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+                this.mainWindow.webContents.send('gateway:cancel-task', {
+                    taskId: session.taskId,
+                    sessionId,
+                });
+            }
+            // Update session state
+            this.sessionRepo.update(sessionId, { state: 'idle', taskId: undefined });
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '🛑 Task cancelled.',
+            });
+        }
+        else {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: 'No active task to cancel.',
+            });
+        }
+    }
+    /**
+     * Handle newtask command - start a fresh task session
+     */
+    async handleNewTaskCommand(adapter, message, sessionId) {
+        const session = this.sessionRepo.findById(sessionId);
+        if (session?.taskId) {
+            // Unlink current task from session
+            this.sessionManager.unlinkSessionFromTask(sessionId);
+            this.pendingTaskResponses.delete(session.taskId);
+        }
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: '🆕 Ready for a new task!\n\nSend me a message describing what you want to do.',
+        });
+    }
+    /**
+     * Handle /removeworkspace command
+     */
+    async handleRemoveWorkspaceCommand(adapter, message, sessionId, args) {
+        if (args.length === 0) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Please specify a workspace name to remove.\n\nUsage: `/removeworkspace <name>`',
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        const workspaceName = args.join(' ');
+        const workspaces = this.workspaceRepo.findAll();
+        const workspace = workspaces.find((w) => w.name.toLowerCase() === workspaceName.toLowerCase());
+        if (!workspace) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `❌ Workspace "${workspaceName}" not found.\n\nUse /workspaces to see available workspaces.`,
+            });
+            return;
+        }
+        // Check if this is the current workspace for the session
+        const session = this.sessionRepo.findById(sessionId);
+        if (session?.workspaceId === workspace.id) {
+            // Clear the workspace from session
+            this.sessionRepo.update(sessionId, { workspaceId: undefined });
+        }
+        // Remove the workspace
+        this.workspaceRepo.delete(workspace.id);
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `✅ Workspace "${workspace.name}" removed successfully.`,
+        });
+    }
+    /**
+     * Handle /retry command - retry the last failed task
+     */
+    async handleRetryCommand(adapter, message, sessionId) {
+        let session = this.sessionRepo.findById(sessionId);
+        // Auto-assign temp workspace if none selected
+        if (!session?.workspaceId) {
+            const tempWorkspace = this.getOrCreateTempWorkspace();
+            this.sessionRepo.update(sessionId, { workspaceId: tempWorkspace.id });
+            session = this.sessionRepo.findById(sessionId);
+        }
+        // Find the last task for this session's workspace that failed or was cancelled
+        const tasks = this.taskRepo.findByWorkspace(session.workspaceId);
+        const lastFailedTask = tasks
+            .filter((t) => t.status === 'failed' || t.status === 'cancelled')
+            .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+        if (!lastFailedTask) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ No failed task found to retry.\n\nStart a new task by sending a message.',
+            });
+            return;
+        }
+        // Re-submit the task by sending the original prompt as a new message
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `🔄 Retrying task...\n\nOriginal prompt: "${lastFailedTask.title}"`,
+        });
+        // Create a synthetic message with the original prompt
+        const retryMessage = {
+            ...message,
+            text: lastFailedTask.title,
+        };
+        // Route as a regular task message
+        await this.routeMessage(adapter, retryMessage, sessionId);
+    }
+    /**
+     * Handle /history command - show recent task history
+     */
+    async handleHistoryCommand(adapter, message, sessionId) {
+        let session = this.sessionRepo.findById(sessionId);
+        // Auto-assign temp workspace if none selected
+        if (!session?.workspaceId) {
+            const tempWorkspace = this.getOrCreateTempWorkspace();
+            this.sessionRepo.update(sessionId, { workspaceId: tempWorkspace.id });
+            session = this.sessionRepo.findById(sessionId);
+        }
+        const tasks = this.taskRepo.findByWorkspace(session.workspaceId);
+        const recentTasks = tasks
+            .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+            .slice(0, 10);
+        if (recentTasks.length === 0) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '📋 No task history found.\n\nStart a new task by sending a message.',
+            });
+            return;
+        }
+        const statusEmoji = {
+            completed: '✅',
+            running: '⏳',
+            pending: '⏸️',
+            error: '❌',
+            cancelled: '🚫',
+        };
+        const historyText = recentTasks
+            .map((t, i) => {
+            const emoji = statusEmoji[t.status] || '❓';
+            const date = new Date(t.createdAt).toLocaleDateString();
+            const title = t.title.length > 40 ? t.title.substring(0, 40) + '...' : t.title;
+            return `${i + 1}. ${emoji} ${title}\n   ${date} • ${t.status}`;
+        })
+            .join('\n\n');
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `📋 *Recent Tasks*\n\n${historyText}`,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Handle /skills command - list available skills
+     */
+    async handleSkillsCommand(adapter, message, _sessionId) {
+        try {
+            const skillLoader = (0, custom_skill_loader_1.getCustomSkillLoader)();
+            await skillLoader.initialize();
+            const skills = skillLoader.listTaskSkills();
+            if (skills.length === 0) {
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: '📚 No skills available.\n\nSkills are stored in:\n`~/Library/Application Support/cowork-os/skills/`',
+                    parseMode: 'markdown',
+                });
+                return;
+            }
+            // Group skills by category
+            const byCategory = new Map();
+            for (const skill of skills) {
+                const category = skill.category || 'Uncategorized';
+                if (!byCategory.has(category)) {
+                    byCategory.set(category, []);
+                }
+                byCategory.get(category).push(skill);
+            }
+            let text = '📚 *Available Skills*\n\n';
+            for (const [category, categorySkills] of byCategory) {
+                text += `*${category}*\n`;
+                for (const skill of categorySkills) {
+                    const status = skill.enabled !== false ? '✅' : '❌';
+                    text += `${skill.icon || '⚡'} ${skill.name} ${status}\n`;
+                    text += `   \`/skill ${skill.id}\` to toggle\n`;
+                }
+                text += '\n';
+            }
+            text += '_Use `/skill <name>` to toggle a skill on/off_';
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text,
+                parseMode: 'markdown',
+            });
+        }
+        catch (error) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Failed to load skills.',
+            });
+        }
+    }
+    /**
+     * Handle /skill command - toggle a skill on/off
+     */
+    async handleSkillCommand(adapter, message, _sessionId, args) {
+        if (args.length === 0) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Please specify a skill ID.\n\nUsage: `/skill <id>`\n\nUse /skills to see available skills.',
+                parseMode: 'markdown',
+            });
+            return;
+        }
+        try {
+            const skillLoader = (0, custom_skill_loader_1.getCustomSkillLoader)();
+            await skillLoader.initialize();
+            const skillId = args[0].toLowerCase();
+            const skill = skillLoader.getSkill(skillId);
+            if (!skill) {
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: `❌ Skill "${skillId}" not found.\n\nUse /skills to see available skills.`,
+                });
+                return;
+            }
+            // Toggle the enabled state
+            const newState = skill.enabled === false;
+            await skillLoader.updateSkill(skillId, { enabled: newState });
+            const statusText = newState ? '✅ enabled' : '❌ disabled';
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: `${skill.icon || '⚡'} *${skill.name}* is now ${statusText}`,
+                parseMode: 'markdown',
+            });
+        }
+        catch (error) {
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Failed to toggle skill.',
+            });
+        }
+    }
+    /**
+     * Handle /providers command - list available LLM providers
+     */
+    async handleProvidersCommand(adapter, message) {
+        const status = provider_factory_1.LLMProviderFactory.getConfigStatus();
+        const current = status.currentProvider;
+        const providerEmoji = {
+            anthropic: '🟠',
+            openai: '🟢',
+            gemini: '🔵',
+            bedrock: '🟡',
+            ollama: '⚪',
+            openrouter: '🟣',
+        };
+        // Build inline keyboard with provider buttons
+        const keyboard = [];
+        const row1 = [];
+        const row2 = [];
+        // Get configured providers for the keyboard
+        const providerOrder = ['anthropic', 'openai', 'gemini', 'bedrock', 'openrouter', 'ollama'];
+        for (let i = 0; i < providerOrder.length; i++) {
+            const provider = providerOrder[i];
+            const emoji = providerEmoji[provider] || '⚡';
+            const isCurrent = provider === current ? ' ✓' : '';
+            const providerInfo = status.providers.find(p => p.type === provider);
+            const name = providerInfo?.name || provider;
+            const button = {
+                text: `${emoji} ${name}${isCurrent}`,
+                callbackData: `provider:${provider}`,
+            };
+            // Split into two rows
+            if (i < 3) {
+                row1.push(button);
+            }
+            else {
+                row2.push(button);
+            }
+        }
+        keyboard.push(row1);
+        keyboard.push(row2);
+        const currentProviderInfo = status.providers.find(p => p.type === current);
+        // WhatsApp/iMessage don't support inline keyboards - use text-based selection
+        if (adapter.type === 'whatsapp' || adapter.type === 'imessage') {
+            let text = `🤖 *AI Providers*\n\nCurrent: *${currentProviderInfo?.name || current}*\n\n`;
+            providerOrder.forEach((provider, index) => {
+                const emoji = providerEmoji[provider] || '⚡';
+                const providerInfo = status.providers.find(p => p.type === provider);
+                const name = providerInfo?.name || provider;
+                const isCurrent = provider === current ? ' ✓' : '';
+                text += `${index + 1}. ${emoji} *${name}*${isCurrent}\n`;
+            });
+            text += '\n━━━━━━━━━━━━━━━\n';
+            text += 'Reply with number to switch.\nExample: `1` for Anthropic';
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text,
+                parseMode: 'markdown',
+                threadId: message.threadId,
+            });
+        }
+        else {
+            let text = `🤖 *AI Providers*\n\nCurrent: ${currentProviderInfo?.name || current}\n\nTap to switch:`;
+            await adapter.sendMessage({
+                chatId: message.chatId,
+                text,
+                parseMode: 'markdown',
+                inlineKeyboard: keyboard,
+                threadId: message.threadId,
+            });
+        }
+    }
+    /**
+     * Handle /settings command - view current settings
+     */
+    async handleSettingsCommand(adapter, message, sessionId) {
+        const session = this.sessionRepo.findById(sessionId);
+        const workspace = session?.workspaceId
+            ? this.workspaceRepo.findById(session.workspaceId)
+            : null;
+        const provider = provider_factory_1.LLMProviderFactory.getSelectedProvider();
+        const model = provider_factory_1.LLMProviderFactory.getSelectedModel();
+        const settings = provider_factory_1.LLMProviderFactory.getSettings();
+        let text = '⚙️ *Current Settings*\n\n';
+        text += '*Workspace*\n';
+        text += workspace ? `📁 ${workspace.name}\n` : '❌ None selected\n';
+        text += '\n';
+        text += '*AI Configuration*\n';
+        text += `🤖 Provider: \`${provider}\`\n`;
+        text += `🧠 Model: \`${model}\`\n`;
+        text += '\n';
+        text += '*Session*\n';
+        text += `🔧 Shell commands: ${session?.shellEnabled ? '✅' : '❌'}\n`;
+        text += `📝 Debug mode: ${session?.debugMode ? '✅' : '❌'}\n`;
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Handle /debug command - toggle debug mode
+     */
+    async handleDebugCommand(adapter, message, sessionId) {
+        const session = this.sessionRepo.findById(sessionId);
+        const currentDebug = session?.debugMode || false;
+        const newDebug = !currentDebug;
+        this.sessionRepo.update(sessionId, { debugMode: newDebug });
+        const statusText = newDebug ? '✅ enabled' : '❌ disabled';
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `🐛 Debug mode is now ${statusText}`,
+        });
+    }
+    /**
+     * Handle /version command - show version info
+     */
+    async handleVersionCommand(adapter, message) {
+        const version = electron_1.app.getVersion();
+        const electronVersion = process.versions.electron;
+        const nodeVersion = process.versions.node;
+        const platform = process.platform;
+        const arch = process.arch;
+        const text = `📦 *CoWork OS*
+
+Version: \`${version}\`
+Platform: \`${platform}\` (${arch})
+Electron: \`${electronVersion}\`
+Node.js: \`${nodeVersion}\`
+
+🔗 [GitHub](https://github.com/CoWork-OS/cowork-os)`;
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text,
+            parseMode: 'markdown',
+        });
+    }
+    /**
+     * Handle /start command with smart onboarding
+     */
+    async handleStartCommand(adapter, message, sessionId) {
+        const session = this.sessionRepo.findById(sessionId);
+        const workspaces = this.workspaceRepo.findAll();
+        // WhatsApp/iMessage-optimized welcome flow (no inline keyboards)
+        if (adapter.type === 'whatsapp' || adapter.type === 'imessage') {
+            if (session?.workspaceId) {
+                const workspace = this.workspaceRepo.findById(session.workspaceId);
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: `👋 *Welcome back!*\n\nWorkspace: *${workspace?.name || 'Unknown'}*\n\nJust send me what you'd like me to do.\n\nType /help for commands.`,
+                    parseMode: 'markdown',
+                });
+            }
+            else if (workspaces.length === 0) {
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: `👋 *Welcome to CoWork!*\n\nI'm your AI coding assistant.\n\nFirst, add a workspace:\n\`/addworkspace /path/to/project\`\n\nOr add one from the desktop app.`,
+                    parseMode: 'markdown',
+                });
+            }
+            else if (workspaces.length === 1) {
+                // Auto-select the only workspace
+                const workspace = workspaces[0];
+                this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text: `👋 *Welcome to CoWork!*\n\n✅ Workspace: *${workspace.name}*\n\nJust tell me what you'd like me to do!\n\nExamples:\n• "Add dark mode support"\n• "Fix the login bug"\n• "Create a new API endpoint"`,
+                    parseMode: 'markdown',
+                });
+            }
+            else {
+                // Multiple workspaces - show selection
+                let text = `👋 *Welcome to CoWork!*\n\nSelect a workspace to start:\n\n`;
+                workspaces.forEach((ws, index) => {
+                    text += `${index + 1}. *${ws.name}*\n`;
+                });
+                text += `\nReply with a number (e.g., \`1\`)`;
+                await adapter.sendMessage({
+                    chatId: message.chatId,
+                    text,
+                    parseMode: 'markdown',
+                });
+            }
+            return;
+        }
+        // Standard welcome for Telegram/Discord
+        await adapter.sendMessage({
+            chatId: message.chatId,
+            text: this.config.welcomeMessage,
+        });
+        // Show workspaces if none selected
+        if (!session?.workspaceId && workspaces.length > 0) {
+            await this.handleWorkspacesCommand(adapter, message);
+        }
+    }
+    /**
+     * Get help text - channel-specific for better UX
+     */
+    getHelpText(channelType) {
+        // Compact help for WhatsApp (mobile-friendly)
+        if (channelType === 'whatsapp') {
+            return `📚 *Commands*
+
+*Basics*
+/workspaces - Select workspace
+/status - Current status
+/newtask - Fresh start
+
+*Tasks*
+/cancel - Stop task
+/approve or /yes - Approve action
+/deny or /no - Reject action
+
+*Settings*
+/shell on|off - Shell access
+/models - Change AI model
+
+━━━━━━━━━━━━━━━
+💡 Just send your task directly!
+Example: "Add a login form"`;
+        }
+        // Full help for other channels
+        return `📚 *Available Commands*
+
+*Core*
+/start - Start the bot
+/help - Show this help message
+/status - Check bot status and workspace
+/version - Show version information
+
+*Workspaces*
+/workspaces - List available workspaces
+/workspace <name> - Select a workspace
+/addworkspace <path> - Add a new workspace
+/removeworkspace <name> - Remove a workspace
+
+*Tasks*
+/newtask - Start a fresh task/conversation
+/cancel - Cancel current task
+/retry - Retry the last failed task
+/history - Show recent task history
+/approve - Approve pending action (or /yes, /y)
+/deny - Reject pending action (or /no, /n)
+/queue - View/clear task queue
+
+*Models*
+/providers - List available AI providers
+/provider <name> - Show or change provider
+/models - List available AI models
+/model <name> - Show or change model
+
+*Skills*
+/skills - List available skills
+/skill <name> - Toggle a skill on/off
+
+*Settings*
+/settings - View current settings
+/shell - Enable/disable shell commands
+/debug - Toggle debug mode
+
+💬 *Quick Start*
+1. \`/workspaces\` → \`/workspace <name>\`
+2. \`/shell on\` (if needed)
+3. Send your task message
+4. \`/newtask\` to start fresh`;
+    }
+    /**
+     * Handle callback query from inline keyboard button press
+     */
+    async handleCallbackQuery(adapter, query) {
+        const { data, chatId } = query;
+        // Parse callback data (format: action:param)
+        const [action, ...params] = data.split(':');
+        const param = params.join(':');
+        try {
+            // Get or create session for this chat
+            const channel = this.channelRepo.findByType(adapter.type);
+            if (!channel) {
+                console.error(`No channel configuration found for ${adapter.type}`);
+                return;
+            }
+            // Find existing session or create one
+            let session = this.sessionRepo.findByChatId(channel.id, chatId);
+            if (!session) {
+                // Create a minimal session for handling callback
+                session = this.sessionRepo.create({
+                    channelId: channel.id,
+                    chatId,
+                    state: 'idle',
+                });
+            }
+            // Answer the callback to remove loading indicator
+            if (adapter.answerCallbackQuery) {
+                await adapter.answerCallbackQuery(query.id);
+            }
+            switch (action) {
+                case 'workspace':
+                    await this.handleWorkspaceCallback(adapter, query, session.id, param);
+                    break;
+                case 'provider':
+                    await this.handleProviderCallback(adapter, query, param);
+                    break;
+                case 'model':
+                    await this.handleModelCallback(adapter, query, param);
+                    break;
+                case 'approve':
+                    await this.handleApprovalCallback(adapter, query, session.id, true);
+                    break;
+                case 'deny':
+                    await this.handleApprovalCallback(adapter, query, session.id, false);
+                    break;
+                default:
+                    console.log(`Unknown callback action: ${action}`);
+            }
+        }
+        catch (error) {
+            console.error('Error handling callback query:', error);
+        }
+    }
+    /**
+     * Handle workspace selection callback
+     */
+    async handleWorkspaceCallback(adapter, query, sessionId, workspaceId) {
+        const workspace = this.workspaceRepo.findById(workspaceId);
+        if (!workspace) {
+            await adapter.sendMessage({
+                chatId: query.chatId,
+                text: '❌ Workspace not found.',
+            });
+            return;
+        }
+        // Update session workspace
+        this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+        // Update the original message with the selection
+        if (adapter.editMessageWithKeyboard) {
+            await adapter.editMessageWithKeyboard(query.chatId, query.messageId, `✅ Workspace selected: *${workspace.name}*\n\`${workspace.path}\`\n\nYou can now send messages to create tasks.`);
+        }
+        else {
+            await adapter.sendMessage({
+                chatId: query.chatId,
+                text: `✅ Workspace set to: *${workspace.name}*\n\`${workspace.path}\``,
+                parseMode: 'markdown',
+            });
+        }
+    }
+    /**
+     * Handle provider selection callback
+     */
+    async handleProviderCallback(adapter, query, providerType) {
+        const settings = provider_factory_1.LLMProviderFactory.loadSettings();
+        const status = provider_factory_1.LLMProviderFactory.getConfigStatus();
+        // Update provider
+        const newSettings = {
+            ...settings,
+            providerType: providerType,
+        };
+        provider_factory_1.LLMProviderFactory.saveSettings(newSettings);
+        provider_factory_1.LLMProviderFactory.clearCache();
+        const providerInfo = status.providers.find(p => p.type === providerType);
+        // Update the original message
+        if (adapter.editMessageWithKeyboard) {
+            await adapter.editMessageWithKeyboard(query.chatId, query.messageId, `✅ Provider changed to: *${providerInfo?.name || providerType}*\n\nUse /models to see available models.`);
+        }
+        else {
+            await adapter.sendMessage({
+                chatId: query.chatId,
+                text: `✅ Provider changed to: *${providerInfo?.name || providerType}*`,
+                parseMode: 'markdown',
+            });
+        }
+    }
+    /**
+     * Handle model selection callback
+     */
+    async handleModelCallback(adapter, query, modelKey) {
+        const settings = provider_factory_1.LLMProviderFactory.loadSettings();
+        const status = provider_factory_1.LLMProviderFactory.getConfigStatus();
+        const providerType = status.currentProvider;
+        // Save to the appropriate provider-specific setting
+        let newSettings = { ...settings };
+        let displayName = modelKey;
+        switch (providerType) {
+            case 'openai':
+                newSettings.openai = { ...settings.openai, model: modelKey };
+                break;
+            case 'gemini':
+                newSettings.gemini = { ...settings.gemini, model: modelKey };
+                break;
+            case 'openrouter':
+                newSettings.openrouter = { ...settings.openrouter, model: modelKey };
+                break;
+            case 'ollama':
+                newSettings.ollama = { ...settings.ollama, model: modelKey };
+                break;
+            default:
+                newSettings.modelKey = modelKey;
+                const modelInfo = status.models.find(m => m.key === modelKey);
+                displayName = modelInfo?.displayName || modelKey;
+        }
+        provider_factory_1.LLMProviderFactory.saveSettings(newSettings);
+        provider_factory_1.LLMProviderFactory.clearCache();
+        // Update the original message
+        if (adapter.editMessageWithKeyboard) {
+            await adapter.editMessageWithKeyboard(query.chatId, query.messageId, `✅ Model changed to: *${displayName}*`);
+        }
+        else {
+            await adapter.sendMessage({
+                chatId: query.chatId,
+                text: `✅ Model changed to: *${displayName}*`,
+                parseMode: 'markdown',
+            });
+        }
+    }
+    /**
+     * Handle approval/deny callback from inline buttons
+     */
+    async handleApprovalCallback(adapter, query, sessionId, approved) {
+        // Find pending approval for this session
+        const approvalEntry = Array.from(this.pendingApprovals.entries())
+            .find(([, data]) => data.sessionId === sessionId);
+        if (!approvalEntry) {
+            if (adapter.editMessageWithKeyboard) {
+                await adapter.editMessageWithKeyboard(query.chatId, query.messageId, '❌ No pending approval request (may have expired).');
+            }
+            return;
+        }
+        const [approvalId] = approvalEntry;
+        this.pendingApprovals.delete(approvalId);
+        try {
+            await this.agentDaemon?.respondToApproval(approvalId, approved);
+            const statusText = approved ? '✅ Approved! Executing...' : '🛑 Denied. Action cancelled.';
+            if (adapter.editMessageWithKeyboard) {
+                await adapter.editMessageWithKeyboard(query.chatId, query.messageId, statusText);
+            }
+            else {
+                await adapter.sendMessage({
+                    chatId: query.chatId,
+                    text: statusText,
+                });
+            }
+        }
+        catch (error) {
+            console.error('Error responding to approval:', error);
+            await adapter.sendMessage({
+                chatId: query.chatId,
+                text: '❌ Failed to process response.',
+            });
+        }
+    }
+    /**
+     * Emit an event to all handlers
+     */
+    emitEvent(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (error) {
+                console.error('Error in event handler:', error);
+            }
+        }
+    }
+}
+exports.MessageRouter = MessageRouter;