cowork-os 0.3.21 → 0.3.25

package/dist/electron/electron/agent/tools/sharepoint-tools.js

@@ -0,0 +1,243 @@
+"use strict";
+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.SharePointTools = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sharepoint_manager_1 = require("../../settings/sharepoint-manager");
+const sharepoint_api_1 = require("../../utils/sharepoint-api");
+class SharePointTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    static isEnabled() {
+        return sharepoint_manager_1.SharePointSettingsManager.loadSettings().enabled;
+    }
+    async requireApproval(summary, details) {
+        const approved = await this.daemon.requestApproval(this.taskId, 'external_service', summary, details);
+        if (!approved) {
+            throw new Error('User denied SharePoint action');
+        }
+    }
+    resolveFilePath(inputPath) {
+        if (!this.workspace.permissions.read) {
+            throw new Error('Read permission not granted for uploads');
+        }
+        const workspaceRoot = path.resolve(this.workspace.path);
+        const allowedPaths = this.workspace.permissions.allowedPaths || [];
+        const canReadOutside = this.workspace.isTemp || this.workspace.permissions.unrestrictedFileAccess;
+        const isPathAllowed = (absolutePath) => {
+            if (allowedPaths.length === 0)
+                return false;
+            const normalizedPath = path.normalize(absolutePath);
+            return allowedPaths.some((allowed) => {
+                const normalizedAllowed = path.normalize(allowed);
+                return normalizedPath === normalizedAllowed || normalizedPath.startsWith(normalizedAllowed + path.sep);
+            });
+        };
+        const candidate = path.isAbsolute(inputPath)
+            ? path.normalize(inputPath)
+            : path.resolve(workspaceRoot, inputPath);
+        const relative = path.relative(workspaceRoot, candidate);
+        const isInsideWorkspace = !(relative.startsWith('..') || path.isAbsolute(relative));
+        if (!isInsideWorkspace && !canReadOutside && !isPathAllowed(candidate)) {
+            throw new Error('File path must be inside the workspace or in Allowed Paths');
+        }
+        if (!fs.existsSync(candidate)) {
+            throw new Error(`File not found: ${inputPath}`);
+        }
+        const stats = fs.statSync(candidate);
+        if (!stats.isFile()) {
+            throw new Error(`Path is not a file: ${inputPath}`);
+        }
+        return candidate;
+    }
+    getSiteId(inputSiteId) {
+        const settings = sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+        const siteId = inputSiteId || settings.siteId;
+        if (!siteId) {
+            throw new Error('Missing site_id. Provide it in settings or the tool input.');
+        }
+        return siteId;
+    }
+    getDriveId(inputDriveId) {
+        const settings = sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+        const driveId = inputDriveId || settings.driveId;
+        if (!driveId) {
+            throw new Error('Missing drive_id. Provide it in settings or the tool input.');
+        }
+        return driveId;
+    }
+    async executeAction(input) {
+        const settings = sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            throw new Error('SharePoint integration is disabled. Enable it in Settings > Integrations > SharePoint.');
+        }
+        const action = input.action;
+        if (!action) {
+            throw new Error('Missing required "action" parameter');
+        }
+        let result;
+        switch (action) {
+            case 'get_current_user': {
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: '/me' });
+                break;
+            }
+            case 'search_sites': {
+                if (!input.query)
+                    throw new Error('Missing query for search_sites');
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, {
+                    method: 'GET',
+                    path: '/sites',
+                    query: { search: input.query },
+                });
+                break;
+            }
+            case 'get_site': {
+                const siteId = this.getSiteId(input.site_id);
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: `/sites/${siteId}` });
+                break;
+            }
+            case 'list_site_drives': {
+                const siteId = this.getSiteId(input.site_id);
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: `/sites/${siteId}/drives` });
+                break;
+            }
+            case 'list_drive_items': {
+                const driveId = this.getDriveId(input.drive_id);
+                const pathSuffix = input.item_id ? `/items/${input.item_id}/children` : '/root/children';
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: `/drives/${driveId}${pathSuffix}` });
+                break;
+            }
+            case 'get_item': {
+                if (!input.item_id)
+                    throw new Error('Missing item_id for get_item');
+                const driveId = this.getDriveId(input.drive_id);
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: `/drives/${driveId}/items/${input.item_id}` });
+                break;
+            }
+            case 'create_folder': {
+                if (!input.name)
+                    throw new Error('Missing name for create_folder');
+                const driveId = this.getDriveId(input.drive_id);
+                const parentPath = input.parent_id
+                    ? `/items/${input.parent_id}/children`
+                    : '/root/children';
+                await this.requireApproval('Create a SharePoint folder', {
+                    action: 'create_folder',
+                    parent_id: input.parent_id || 'root',
+                    name: input.name,
+                });
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, {
+                    method: 'POST',
+                    path: `/drives/${driveId}${parentPath}`,
+                    body: {
+                        name: input.name,
+                        folder: {},
+                        '@microsoft.graph.conflictBehavior': input.conflict_behavior || 'rename',
+                    },
+                });
+                break;
+            }
+            case 'upload_file': {
+                if (!input.file_path)
+                    throw new Error('Missing file_path for upload_file');
+                const driveId = this.getDriveId(input.drive_id);
+                const resolved = this.resolveFilePath(input.file_path);
+                const data = fs.readFileSync(resolved);
+                const fileName = input.name || path.basename(resolved);
+                let uploadPath;
+                if (input.remote_path) {
+                    const cleaned = input.remote_path.replace(/^\/+/, '');
+                    const encoded = cleaned
+                        .split('/')
+                        .map(segment => encodeURIComponent(segment))
+                        .join('/');
+                    uploadPath = `/drives/${driveId}/root:/${encoded}:/content`;
+                }
+                else if (input.parent_id) {
+                    uploadPath = `/drives/${driveId}/items/${input.parent_id}:/${encodeURIComponent(fileName)}:/content`;
+                }
+                else {
+                    uploadPath = `/drives/${driveId}/root:/${encodeURIComponent(fileName)}:/content`;
+                }
+                await this.requireApproval(`Upload file to SharePoint: ${fileName}`, {
+                    action: 'upload_file',
+                    destination: input.remote_path || input.parent_id || 'root',
+                    file: fileName,
+                });
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, {
+                    method: 'PUT',
+                    path: uploadPath,
+                    body: data,
+                    headers: { 'Content-Type': 'application/octet-stream' },
+                });
+                break;
+            }
+            case 'delete_item': {
+                if (!input.item_id)
+                    throw new Error('Missing item_id for delete_item');
+                const driveId = this.getDriveId(input.drive_id);
+                await this.requireApproval('Delete a SharePoint item', {
+                    action: 'delete_item',
+                    item_id: input.item_id,
+                });
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'DELETE', path: `/drives/${driveId}/items/${input.item_id}` });
+                break;
+            }
+            default:
+                throw new Error(`Unsupported action: ${action}`);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'sharepoint_action',
+            action,
+            status: result?.status,
+            hasData: result?.data ? true : false,
+        });
+        return {
+            success: true,
+            action,
+            status: result?.status,
+            data: result?.data,
+            raw: result?.raw,
+        };
+    }
+}
+exports.SharePointTools = SharePointTools;

package/dist/electron/electron/agent/tools/shell-tools.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._testUtils = exports.ShellTools = void 0;
 const child_process_1 = require("child_process");
 const guardrail_manager_1 = require("../../guardrails/guardrail-manager");
+const builtin_settings_1 = require("./builtin-settings");
 // Limits to prevent runaway commands
 const MAX_TIMEOUT = 5 * 60 * 1000; // 5 minutes max
 const DEFAULT_TIMEOUT = 60 * 1000; // 1 minute default
@@ -321,9 +322,9 @@ class ShellTools {
         }
     }
     /**
-     * Execute a shell command (requires user approval)
+     * Execute a shell command (requires user approval unless auto-approve is enabled)
      * Note: We don't check workspace.permissions.shell here because
-     * shell commands always require explicit user approval via requestApproval()
+     * shell commands are gated by approval flow (or auto-approve/trust settings)
      */
     async runCommand(command, options) {
         // Check if command is blocked by guardrails BEFORE anything else
@@ -335,8 +336,16 @@ class ShellTools {
         }
         // Check if command is trusted (auto-approve without user confirmation)
         const trustCheck = guardrail_manager_1.GuardrailManager.isCommandTrusted(command);
+        const autoApproveEnabled = builtin_settings_1.BuiltinToolsSettingsManager.getToolAutoApprove('run_command');
         let approved = false;
-        if (trustCheck.trusted) {
+        if (autoApproveEnabled && this.isAutoApprovalSafe(command)) {
+            approved = true;
+            this.daemon.logEvent(this.taskId, 'log', {
+                message: 'Auto-approved command (user setting enabled)',
+                command,
+            });
+        }
+        else if (trustCheck.trusted) {
             // Auto-approve trusted commands
             approved = true;
             this.daemon.logEvent(this.taskId, 'log', {

package/dist/electron/electron/agent/tools/x-tools.js

@@ -111,7 +111,7 @@ class XTools {
     async executeAction(input) {
         const settings = x_manager_1.XSettingsManager.loadSettings();
         if (!settings.enabled) {
-            throw new Error('X integration is disabled. Enable it in Settings > More Channels > X.');
+            throw new Error('X integration is disabled. Enable it in Settings > X (Twitter).');
         }
         const action = input.action;
         if (!action) {

package/dist/electron/electron/agents/agent-dispatch.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAgentDispatchPrompt = void 0;
+const buildSoulSummary = (soul) => {
+    if (!soul)
+        return null;
+    try {
+        const parsed = JSON.parse(soul);
+        const parts = [];
+        if (typeof parsed.name === 'string')
+            parts.push(`Name: ${parsed.name}`);
+        if (typeof parsed.role === 'string')
+            parts.push(`Role: ${parsed.role}`);
+        if (typeof parsed.personality === 'string')
+            parts.push(`Personality: ${parsed.personality}`);
+        if (typeof parsed.communicationStyle === 'string')
+            parts.push(`Style: ${parsed.communicationStyle}`);
+        if (Array.isArray(parsed.focusAreas))
+            parts.push(`Focus: ${parsed.focusAreas.join(', ')}`);
+        if (Array.isArray(parsed.strengths))
+            parts.push(`Strengths: ${parsed.strengths.join(', ')}`);
+        if (parts.length === 0) {
+            return null;
+        }
+        return parts.join('\n');
+    }
+    catch {
+        return soul;
+    }
+};
+const buildAgentDispatchPrompt = (role, parentTask, options) => {
+    const lines = [
+        `You are ${role.displayName}${role.description ? ` — ${role.description}` : ''}.`,
+    ];
+    if (role.capabilities && role.capabilities.length > 0) {
+        lines.push(`Capabilities: ${role.capabilities.join(', ')}`);
+    }
+    if (role.systemPrompt) {
+        lines.push('System guidance:');
+        lines.push(role.systemPrompt);
+    }
+    const soulSummary = buildSoulSummary(role.soul || undefined);
+    if (soulSummary) {
+        lines.push('Role notes:');
+        lines.push(soulSummary);
+    }
+    if (options?.planSummary) {
+        lines.push('');
+        lines.push('Main agent plan summary (context only):');
+        lines.push(options.planSummary);
+    }
+    lines.push('');
+    lines.push(`Parent task: ${parentTask.title}`);
+    lines.push('Request:');
+    lines.push(parentTask.prompt);
+    lines.push('');
+    lines.push('Deliverables:');
+    lines.push('- Provide a concise summary of your findings.');
+    lines.push('- Call out risks or open questions.');
+    lines.push('- Recommend next steps.');
+    return lines.join('\n');
+};
+exports.buildAgentDispatchPrompt = buildAgentDispatchPrompt;

package/dist/electron/electron/database/repositories.js

@@ -20,18 +20,20 @@ class WorkspaceRepository {
         this.db = db;
     }
     create(name, path, permissions) {
+        const now = Date.now();
         const workspace = {
             id: (0, uuid_1.v4)(),
             name,
             path,
-            createdAt: Date.now(),
+            createdAt: now,
+            lastUsedAt: now,
             permissions,
         };
         const stmt = this.db.prepare(`
-      INSERT INTO workspaces (id, name, path, created_at, permissions)
-      VALUES (?, ?, ?, ?, ?)
+      INSERT INTO workspaces (id, name, path, created_at, last_used_at, permissions)
+      VALUES (?, ?, ?, ?, ?, ?)
     `);
-        stmt.run(workspace.id, workspace.name, workspace.path, workspace.createdAt, JSON.stringify(workspace.permissions));
+        stmt.run(workspace.id, workspace.name, workspace.path, workspace.createdAt, workspace.lastUsedAt, JSON.stringify(workspace.permissions));
         return workspace;
     }
     findById(id) {
@@ -40,7 +42,11 @@ class WorkspaceRepository {
         return row ? this.mapRowToWorkspace(row) : undefined;
     }
     findAll() {
-        const stmt = this.db.prepare('SELECT * FROM workspaces ORDER BY created_at DESC');
+        const stmt = this.db.prepare(`
+      SELECT *
+      FROM workspaces
+      ORDER BY COALESCE(last_used_at, created_at) DESC
+    `);
         const rows = stmt.all();
         return rows.map(row => this.mapRowToWorkspace(row));
     }
@@ -67,6 +73,13 @@ class WorkspaceRepository {
         const stmt = this.db.prepare('UPDATE workspaces SET permissions = ? WHERE id = ?');
         stmt.run(JSON.stringify(permissions), id);
     }
+    /**
+     * Update last used timestamp for recency ordering
+     */
+    updateLastUsedAt(id, lastUsedAt = Date.now()) {
+        const stmt = this.db.prepare('UPDATE workspaces SET last_used_at = ? WHERE id = ?');
+        stmt.run(lastUsedAt, id);
+    }
     /**
      * Delete a workspace by ID
      */
@@ -94,6 +107,7 @@ class WorkspaceRepository {
             name: row.name,
             path: row.path,
             createdAt: row.created_at,
+            lastUsedAt: row.last_used_at ?? undefined,
             permissions: mergedPermissions,
         };
     }

package/dist/electron/electron/database/schema.js

@@ -207,6 +207,7 @@ class DatabaseManager {
         name TEXT NOT NULL,
         path TEXT NOT NULL UNIQUE,
         created_at INTEGER NOT NULL,
+        last_used_at INTEGER,
         permissions TEXT NOT NULL
       );
 
@@ -560,6 +561,13 @@ class DatabaseManager {
                 // Column already exists, ignore
             }
         }
+        // Migration: Add last_used_at to workspaces for recency ordering
+        try {
+            this.db.exec('ALTER TABLE workspaces ADD COLUMN last_used_at INTEGER');
+        }
+        catch {
+            // Column already exists, ignore
+        }
         // Migration: Add Sub-Agent / Parallel Agent columns to tasks table
         const subAgentColumns = [
             'ALTER TABLE tasks ADD COLUMN parent_task_id TEXT REFERENCES tasks(id)',

package/dist/electron/electron/gateway/channels/whatsapp.js

@@ -72,6 +72,8 @@ class WhatsAppAdapter {
         this.connectedAtMs = 0;
         this.isReconnecting = false;
         this.backoffAttempt = 0;
+        this.shouldReconnect = true;
+        this.selfChatIgnoreLogAt = 0;
         this.DEFAULT_BACKOFF = {
             initialDelay: 2000,
             maxDelay: 30000,
@@ -135,6 +137,7 @@ class WhatsAppAdapter {
         if (this._status === 'connected' || this._status === 'connecting') {
             return;
         }
+        this.shouldReconnect = true;
         this.setStatus('connecting');
         this.resetBackoff();
         try {
@@ -194,6 +197,17 @@ class WhatsAppAdapter {
      */
     handleConnectionUpdate(update) {
         const { connection, lastDisconnect, qr } = update;
+        if (!this.shouldReconnect) {
+            if (connection === 'open') {
+                // If a manual disconnect happened mid-handshake, close immediately.
+                this.sock?.ws?.close();
+                this.setStatus('disconnected');
+            }
+            else if (connection === 'close') {
+                this.setStatus('disconnected');
+            }
+            return;
+        }
         // Handle QR code for authentication
         if (qr) {
             this.currentQr = qr;
@@ -275,6 +289,12 @@ class WhatsAppAdapter {
             const selfJidNormalized = normalizeJid(this._selfJid);
             const remoteJidNormalized = normalizeJid(remoteJid);
             if (remoteJidNormalized !== selfJidNormalized) {
+                const now = Date.now();
+                if (now - this.selfChatIgnoreLogAt > 30000) {
+                    console.log(`WhatsApp: Ignoring message from ${remoteJidNormalized} because self-chat mode is enabled. ` +
+                        'Disable self-chat mode to accept messages from other numbers.');
+                    this.selfChatIgnoreLogAt = now;
+                }
                 // Message is NOT in self-chat, silently ignore it
                 return;
             }
@@ -365,6 +385,7 @@ class WhatsAppAdapter {
      * Disconnect from WhatsApp
      */
     async disconnect() {
+        this.shouldReconnect = false;
         this.resetBackoff();
         // Clear timers
         if (this.dedupCleanupTimer) {
@@ -625,6 +646,33 @@ class WhatsAppAdapter {
     onQrCode(handler) {
         this.qrCodeHandlers.push(handler);
     }
+    /**
+     * Update adapter configuration at runtime
+     */
+    updateConfig(config) {
+        const next = config;
+        const prevDedupEnabled = this.config.deduplicationEnabled !== false;
+        const prevSelfChat = this.config.selfChatMode === true;
+        this.config = {
+            ...this.config,
+            ...next,
+        };
+        // If self-chat was just enabled and read receipts weren't explicitly set, default to false.
+        if (!prevSelfChat && this.config.selfChatMode && next.sendReadReceipts === undefined) {
+            this.config.sendReadReceipts = false;
+        }
+        const nextDedupEnabled = this.config.deduplicationEnabled !== false;
+        if (nextDedupEnabled && !prevDedupEnabled) {
+            this.startDedupCleanup();
+        }
+        else if (!nextDedupEnabled && prevDedupEnabled) {
+            if (this.dedupCleanupTimer) {
+                clearInterval(this.dedupCleanupTimer);
+                this.dedupCleanupTimer = undefined;
+            }
+            this.processedMessages.clear();
+        }
+    }
     /**
      * Get channel info
      */
@@ -712,6 +760,9 @@ class WhatsAppAdapter {
      * Attempt reconnection with exponential backoff
      */
     async attemptReconnection() {
+        if (!this.shouldReconnect) {
+            return;
+        }
         if (this.isReconnecting)
             return;
         const config = this.DEFAULT_BACKOFF;
@@ -726,6 +777,10 @@ class WhatsAppAdapter {
         console.log(`WhatsApp: Reconnection attempt ${this.backoffAttempt}/${config.maxAttempts} in ${delay}ms`);
         this.backoffTimer = setTimeout(async () => {
             try {
+                if (!this.shouldReconnect) {
+                    this.isReconnecting = false;
+                    return;
+                }
                 this.sock = null;
                 this.isReconnecting = false;
                 this.setStatus('disconnected');

package/dist/electron/electron/gateway/index.js

@@ -16,11 +16,36 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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;
+    };
+})();
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAutoTunnel = exports.getAvailableTunnelProviders = exports.TunnelManager = exports.EmailClient = exports.createEmailAdapter = exports.EmailAdapter = exports.BlueBubblesClient = exports.createBlueBubblesAdapter = exports.BlueBubblesAdapter = exports.LineClient = exports.createLineAdapter = exports.LineAdapter = exports.TwitchClient = exports.createTwitchAdapter = exports.TwitchAdapter = exports.MatrixClient = exports.createMatrixAdapter = exports.MatrixAdapter = exports.MattermostClient = exports.createMattermostAdapter = exports.MattermostAdapter = exports.SignalClient = exports.createSignalAdapter = exports.SignalAdapter = exports.createImessageAdapter = exports.ImessageAdapter = exports.createWhatsAppAdapter = exports.WhatsAppAdapter = exports.createSlackAdapter = exports.SlackAdapter = exports.createDiscordAdapter = exports.DiscordAdapter = exports.createTelegramAdapter = exports.TelegramAdapter = exports.ChannelGateway = void 0;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const router_1 = require("./router");
 const security_1 = require("./security");
 const session_1 = require("./session");
@@ -77,6 +102,7 @@ class ChannelGateway {
                     agentName: settings.agentName || 'CoWork',
                     userName: settings.relationship?.userName,
                     personality: settings.activePersonality || 'professional',
+                    persona: settings.activePersona,
                     emojiUsage: settings.responseStyle?.emojiUsage || 'minimal',
                     quirks: settings.quirks || types_1.DEFAULT_QUIRKS,
                 };
@@ -310,6 +336,8 @@ class ChannelGateway {
         if (existing) {
             throw new Error('WhatsApp channel already configured. Update or remove it first.');
         }
+        // Always clear any stale auth so a new QR is required for a new number.
+        this.clearWhatsAppAuthDir();
         // Create channel record
         const channel = this.channelRepo.create({
             type: 'whatsapp',
@@ -591,6 +619,15 @@ class ChannelGateway {
      */
     updateChannel(channelId, updates) {
         this.channelRepo.update(channelId, updates);
+        if (updates.config === undefined)
+            return;
+        const channel = this.channelRepo.findById(channelId);
+        if (!channel)
+            return;
+        const adapter = this.router.getAdapter(channel.type);
+        if (adapter?.updateConfig) {
+            adapter.updateConfig(channel.config);
+        }
     }
     /**
      * Enable a channel and connect
@@ -702,6 +739,9 @@ class ChannelGateway {
         if (adapter) {
             await adapter.logout();
         }
+        else {
+            this.clearWhatsAppAuthDir();
+        }
         const channel = this.channelRepo.findByType('whatsapp');
         if (channel) {
             this.channelRepo.update(channel.id, { enabled: false, status: 'disconnected', botUsername: undefined });
@@ -711,7 +751,23 @@ class ChannelGateway {
      * Remove a channel
      */
     async removeChannel(channelId) {
-        await this.disableChannel(channelId);
+        const channel = this.channelRepo.findById(channelId);
+        if (!channel)
+            return;
+        if (channel.type === 'whatsapp') {
+            const adapter = this.router.getAdapter('whatsapp');
+            if (adapter) {
+                await adapter.logout();
+            }
+            else {
+                const tempAdapter = this.createAdapterForChannel(channel);
+                await tempAdapter.logout();
+            }
+            this.clearWhatsAppAuthDir(channel);
+        }
+        else {
+            await this.disableChannel(channelId);
+        }
         // Delete associated data first (to avoid foreign key constraint errors)
         this.messageRepo.deleteByChannelId(channelId);
         this.sessionRepo.deleteByChannelId(channelId);
@@ -853,6 +909,24 @@ class ChannelGateway {
         return this.router.handleTaskFailure(taskId, error);
     }
     // Private methods
+    resolveWhatsAppAuthDir(channel) {
+        const configured = channel?.config?.authDir;
+        if (configured && configured.trim()) {
+            return configured;
+        }
+        return path.join(electron_1.app.getPath('userData'), 'whatsapp-auth');
+    }
+    clearWhatsAppAuthDir(channel) {
+        try {
+            const authDir = this.resolveWhatsAppAuthDir(channel);
+            if (fs.existsSync(authDir)) {
+                fs.rmSync(authDir, { recursive: true, force: true });
+            }
+        }
+        catch (error) {
+            console.error('Failed to clear WhatsApp auth directory:', error);
+        }
+    }
     /**
      * Load and register channel adapters
      */