cowork-os 0.3.21 → 0.3.25

package/src/electron/gateway/channels/matrix.ts

@@ -50,6 +50,11 @@ export class MatrixAdapter implements ChannelAdapter {
   // User cache
   private userCache: Map<string, MatrixUser> = new Map();
 
+  // Direct (1:1) rooms cache
+  private directRooms: Set<string> | null = null;
+  private directRoomsLoadedAt = 0;
+  private readonly DIRECT_ROOMS_TTL_MS = 5 * 60 * 1000;
+
   // Message deduplication
   private processedMessages: Map<string, number> = new Map();
   private readonly DEDUP_CACHE_TTL = 60000; // 1 minute
@@ -479,6 +484,9 @@ export class MatrixAdapter implements ChannelAdapter {
     // Get reply-to
     const replyTo = event.content['m.relates_to']?.['m.in_reply_to']?.event_id;
 
+    const directRooms = await this.getDirectRooms();
+    const isGroup = directRooms ? !directRooms.has(event.room_id) : undefined;
+
     // Convert to IncomingMessage
     const message: IncomingMessage = {
       messageId: event.event_id,
@@ -486,6 +494,7 @@ export class MatrixAdapter implements ChannelAdapter {
       userId: event.sender,
       userName,
       chatId: event.room_id,
+      isGroup,
       text: body,
       timestamp: new Date(event.origin_server_ts),
       replyTo,
@@ -552,6 +561,28 @@ export class MatrixAdapter implements ChannelAdapter {
     ];
   }
 
+  private async getDirectRooms(): Promise<Set<string> | null> {
+    if (!this.client) {
+      return this.directRooms;
+    }
+
+    const now = Date.now();
+    if (this.directRooms && now - this.directRoomsLoadedAt < this.DIRECT_ROOMS_TTL_MS) {
+      return this.directRooms;
+    }
+
+    try {
+      const rooms = await this.client.getDirectRooms();
+      this.directRooms = new Set(rooms);
+      this.directRoomsLoadedAt = now;
+      return this.directRooms;
+    } catch (error) {
+      console.warn('Failed to load Matrix direct rooms:', error);
+      this.directRoomsLoadedAt = now;
+      return null;
+    }
+  }
+
   /**
    * Get user info with caching
    */

package/src/electron/gateway/channels/mattermost.ts

@@ -393,6 +393,8 @@ export class MattermostAdapter implements ChannelAdapter {
     // Convert attachments
     const attachments = this.convertAttachments(post);
 
+    const isGroup = channelType !== 'D';
+
     // Convert to IncomingMessage
     const message: IncomingMessage = {
       messageId: post.id,
@@ -400,6 +402,7 @@ export class MattermostAdapter implements ChannelAdapter {
       userId: post.user_id,
       userName,
       chatId: post.channel_id,
+      isGroup,
       text: post.message,
       timestamp: new Date(post.create_at),
       replyTo: post.root_id || undefined,

package/src/electron/gateway/channels/signal.ts

@@ -491,6 +491,8 @@ export class SignalAdapter implements ChannelAdapter {
       return;
     }
 
+    const isGroup = Boolean(dataMessage.groupInfo?.groupId);
+
     // Convert to IncomingMessage
     const message: IncomingMessage = {
       messageId,
@@ -498,6 +500,7 @@ export class SignalAdapter implements ChannelAdapter {
       userId: envelope.source,
       userName: envelope.source, // Signal doesn't provide names in messages
       chatId: dataMessage.groupInfo?.groupId || envelope.source,
+      isGroup,
       text: dataMessage.message,
       timestamp: new Date(envelope.timestamp),
       replyTo: dataMessage.quote?.id?.toString(),

package/src/electron/gateway/channels/slack.ts

@@ -82,11 +82,13 @@ export class SlackAdapter implements ChannelAdapter {
 
         // Check if it's a DM or mentions the bot
         const channelInfo = await client.conversations.info({ channel: message.channel });
-        const isDM = channelInfo.channel?.is_im || channelInfo.channel?.is_mpim;
+        const isDirect = channelInfo.channel?.is_im === true;
+        const isMultiPartyDm = channelInfo.channel?.is_mpim === true;
+        const isGroup = isDirect ? false : true;
         const isMentioned = message.text.includes(`<@${this._botId}>`);
 
-        if (isDM || isMentioned) {
-          const incomingMessage = await this.mapMessageToIncoming(message, client);
+        if (isDirect || isMultiPartyDm || isMentioned) {
+          const incomingMessage = await this.mapMessageToIncoming(message, client, isGroup);
           console.log(`Processing Slack message from ${incomingMessage.userName}: ${incomingMessage.text.slice(0, 50)}`);
           await this.handleIncomingMessage(incomingMessage);
         }
@@ -96,12 +98,14 @@ export class SlackAdapter implements ChannelAdapter {
       this.app.command(/.*/, async ({ command, ack, respond }) => {
         await ack();
 
+        const isGroup = command.channel_id ? !command.channel_id.startsWith('D') : undefined;
         const incomingMessage: IncomingMessage = {
           messageId: command.trigger_id,
           channel: 'slack',
           userId: command.user_id,
           userName: command.user_name,
           chatId: command.channel_id,
+          isGroup,
           text: `/${command.command.replace('/', '')} ${command.text}`.trim(),
           timestamp: new Date(),
           raw: command,
@@ -363,7 +367,7 @@ export class SlackAdapter implements ChannelAdapter {
 
   // Private methods
 
-  private async mapMessageToIncoming(message: any, client: any): Promise<IncomingMessage> {
+  private async mapMessageToIncoming(message: any, client: any, isGroup?: boolean): Promise<IncomingMessage> {
     // Remove bot mention from the text if present
     let text = message.text || '';
     if (this._botId) {
@@ -390,6 +394,7 @@ export class SlackAdapter implements ChannelAdapter {
       userId: message.user || '',
       userName,
       chatId: message.channel || '',
+      isGroup,
       text: commandText || text,
       timestamp: new Date(parseFloat(message.ts || '0') * 1000),
       replyTo: message.thread_ts,

package/src/electron/gateway/channels/teams.ts

@@ -299,6 +299,9 @@ export class TeamsAdapter implements ChannelAdapter {
     const userName = activity.from?.name || 'Unknown User';
     const userId = activity.from?.id || '';
 
+    const conversationType = activity.conversation?.conversationType;
+    const isGroup = conversationType ? conversationType !== 'personal' : undefined;
+
     // Map to IncomingMessage format
     const incomingMessage: IncomingMessage = {
       messageId: messageId,
@@ -306,6 +309,7 @@ export class TeamsAdapter implements ChannelAdapter {
       userId: userId,
       userName: userName,
       chatId: activity.conversation.id,
+      isGroup,
       text: text.trim(),
       timestamp: activity.timestamp ? new Date(activity.timestamp) : new Date(),
       replyTo: activity.replyToId,

package/src/electron/gateway/channels/telegram.ts

@@ -1660,6 +1660,7 @@ export class TelegramAdapter implements ChannelAdapter {
     const msg = ctx.message!;
     const from = msg.from!;
     const chat = msg.chat;
+    const isGroup = chat.type !== 'private';
 
     // Check for forum topic (message_thread_id indicates a forum topic)
     const threadId = msg.message_thread_id?.toString();
@@ -1671,6 +1672,7 @@ export class TelegramAdapter implements ChannelAdapter {
       userId: from.id.toString(),
       userName: from.first_name + (from.last_name ? ` ${from.last_name}` : ''),
       chatId: chat.id.toString(),
+      isGroup,
       text: overrideText ?? msg.text ?? '',
       timestamp: new Date(msg.date * 1000),
       replyTo: msg.reply_to_message?.message_id.toString(),

package/src/electron/gateway/channels/twitch.ts

@@ -357,12 +357,14 @@ export class TwitchAdapter implements ChannelAdapter {
 
     // Convert to IncomingMessage
     // For Twitch, chatId is the channel name (without #)
+    const isGroup = !twitchMessage.isWhisper;
     const message: IncomingMessage = {
       messageId: twitchMessage.id,
       channel: 'twitch',
       userId: twitchMessage.userId,
       userName: twitchMessage.displayName || twitchMessage.username,
       chatId: twitchMessage.channel || twitchMessage.username, // Use username for whispers
+      isGroup,
       text: twitchMessage.message,
       timestamp: twitchMessage.timestamp,
       replyTo: twitchMessage.replyTo?.messageId,

package/src/electron/gateway/channels/types.ts

@@ -29,6 +29,8 @@ export interface IncomingMessage {
   userName: string;
   /** Chat/conversation ID (for group chats) */
   chatId: string;
+  /** Whether this message is from a group chat */
+  isGroup?: boolean;
   /** Message content */
   text: string;
   /** Timestamp */
@@ -530,6 +532,12 @@ export interface ChannelAdapter {
    */
   onMessage(handler: MessageHandler): void;
 
+  /**
+   * Update adapter configuration at runtime (if supported).
+   * Useful for channels with dynamic settings like self-chat mode.
+   */
+  updateConfig?(config: ChannelConfig): void;
+
   /**
    * Register a callback query handler (for inline keyboard buttons)
    * @param handler Function to call when a button is pressed

package/src/electron/gateway/channels/whatsapp.ts

@@ -36,6 +36,7 @@ import { app } from 'electron';
 import {
   ChannelAdapter,
   ChannelStatus,
+  ChannelConfig,
   IncomingMessage,
   OutgoingMessage,
   MessageHandler,
@@ -110,6 +111,8 @@ export class WhatsAppAdapter implements ChannelAdapter {
   private backoffAttempt = 0;
   private backoffTimer?: ReturnType<typeof setTimeout>;
   private currentQr?: string;
+  private shouldReconnect = true;
+  private selfChatIgnoreLogAt = 0;
 
   private readonly DEFAULT_BACKOFF: BackoffConfig = {
     initialDelay: 2000,
@@ -136,6 +139,7 @@ export class WhatsAppAdapter implements ChannelAdapter {
     // In self-chat mode, disable read receipts by default
     if (this.config.selfChatMode && config.sendReadReceipts === undefined) {
       this.config.sendReadReceipts = false;
+      console.log('[WhatsApp] Self-chat mode enabled; defaulting sendReadReceipts to false.');
     }
 
     // Set auth directory
@@ -187,6 +191,7 @@ export class WhatsAppAdapter implements ChannelAdapter {
       return;
     }
 
+    this.shouldReconnect = true;
     this.setStatus('connecting');
     this.resetBackoff();
 
@@ -256,6 +261,17 @@ export class WhatsAppAdapter implements ChannelAdapter {
   private handleConnectionUpdate(update: Partial<ConnectionState>): void {
     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;
@@ -345,6 +361,14 @@ export class WhatsAppAdapter implements ChannelAdapter {
       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;
       }
@@ -430,6 +454,7 @@ export class WhatsAppAdapter implements ChannelAdapter {
       userId: senderE164 || participantJid || remoteJid,
       userName: msg.pushName || senderE164 || 'Unknown',
       chatId: remoteJid,
+      isGroup,
       text: body || (attachments.length === 0 ? this.extractMediaPlaceholder(msg.message) : '') || '',
       timestamp: messageTimestampMs ? new Date(messageTimestampMs) : new Date(),
       attachments: attachments.length > 0 ? attachments : undefined,
@@ -444,6 +469,7 @@ export class WhatsAppAdapter implements ChannelAdapter {
    * Disconnect from WhatsApp
    */
   async disconnect(): Promise<void> {
+    this.shouldReconnect = false;
     this.resetBackoff();
 
     // Clear timers
@@ -746,6 +772,37 @@ export class WhatsAppAdapter implements ChannelAdapter {
     this.qrCodeHandlers.push(handler);
   }
 
+  /**
+   * Update adapter configuration at runtime
+   */
+  updateConfig(config: ChannelConfig): void {
+    const next = config as Partial<WhatsAppConfig>;
+    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;
+      console.log('[WhatsApp] Self-chat mode enabled; defaulting sendReadReceipts to 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
    */
@@ -839,6 +896,10 @@ export class WhatsAppAdapter implements ChannelAdapter {
    * Attempt reconnection with exponential backoff
    */
   private async attemptReconnection(): Promise<void> {
+    if (!this.shouldReconnect) {
+      return;
+    }
+
     if (this.isReconnecting) return;
 
     const config = this.DEFAULT_BACKOFF;
@@ -857,6 +918,11 @@ export class WhatsAppAdapter implements ChannelAdapter {
 
     this.backoffTimer = setTimeout(async () => {
       try {
+        if (!this.shouldReconnect) {
+          this.isReconnecting = false;
+          return;
+        }
+
         this.sock = null;
         this.isReconnecting = false;
         this.setStatus('disconnected');

package/src/electron/gateway/index.ts

@@ -5,14 +5,17 @@
  * Manages channel adapters, routing, and sessions.
  */
 
-import { BrowserWindow } from 'electron';
+import { BrowserWindow, app } from 'electron';
 import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
 import { MessageRouter, RouterConfig } from './router';
 import { SecurityManager } from './security';
 import { SessionManager } from './session';
 import {
   ChannelAdapter,
   ChannelType,
+  ChannelConfig,
   TelegramConfig,
   DiscordConfig,
   SlackConfig,
@@ -84,6 +87,7 @@ export class ChannelGateway {
   private initialized = false;
   private agentDaemon?: AgentDaemon;
   private daemonListeners: Array<{ event: string; handler: (...args: any[]) => void }> = [];
+  private pendingCleanupInterval: ReturnType<typeof setInterval> | null = null;
 
   constructor(db: Database.Database, config: GatewayConfig = {}) {
     this.db = db;
@@ -116,6 +120,7 @@ export 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 || DEFAULT_QUIRKS,
         };
@@ -255,6 +260,8 @@ export class ChannelGateway {
       await this.router.connectAll();
     }
 
+    this.startPendingCleanup();
+
     this.initialized = true;
     console.log('Channel Gateway initialized');
   }
@@ -279,10 +286,48 @@ export class ChannelGateway {
     }
 
     await this.router.disconnectAll();
+    this.stopPendingCleanup();
     this.initialized = false;
     console.log('Channel Gateway shutdown');
   }
 
+  private startPendingCleanup(): void {
+    if (this.pendingCleanupInterval) return;
+    // Run once at startup to clear any stale entries.
+    this.cleanupPendingUsers();
+    // Then run every 10 minutes.
+    this.pendingCleanupInterval = setInterval(() => {
+      this.cleanupPendingUsers();
+    }, 10 * 60 * 1000);
+  }
+
+  private stopPendingCleanup(): void {
+    if (this.pendingCleanupInterval) {
+      clearInterval(this.pendingCleanupInterval);
+      this.pendingCleanupInterval = null;
+    }
+  }
+
+  private cleanupPendingUsers(): void {
+    const channels = this.channelRepo.findAll();
+    for (const channel of channels) {
+      const removed = this.userRepo.deleteExpiredPending(channel.id);
+      if (removed > 0) {
+        this.emitUsersUpdated(channel);
+      }
+    }
+  }
+
+  private emitUsersUpdated(channel: Channel): void {
+    const mainWindow = this.router.getMainWindow();
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      mainWindow.webContents.send('gateway:users-updated', {
+        channelId: channel.id,
+        channelType: channel.type,
+      });
+    }
+  }
+
   // Channel Management
 
   /**
@@ -401,6 +446,9 @@ export class ChannelGateway {
       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',
@@ -771,6 +819,16 @@ export class ChannelGateway {
    */
   updateChannel(channelId: string, updates: Partial<Channel>): void {
     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 as ChannelType);
+    if (adapter?.updateConfig) {
+      adapter.updateConfig(channel.config as ChannelConfig);
+    }
   }
 
   /**
@@ -896,6 +954,8 @@ export class ChannelGateway {
     const adapter = this.router.getAdapter('whatsapp') as WhatsAppAdapter | undefined;
     if (adapter) {
       await adapter.logout();
+    } else {
+      this.clearWhatsAppAuthDir();
     }
 
     const channel = this.channelRepo.findByType('whatsapp');
@@ -908,7 +968,21 @@ export class ChannelGateway {
    * Remove a channel
    */
   async removeChannel(channelId: string): Promise<void> {
-    await this.disableChannel(channelId);
+    const channel = this.channelRepo.findById(channelId);
+    if (!channel) return;
+
+    if (channel.type === 'whatsapp') {
+      const adapter = this.router.getAdapter('whatsapp') as WhatsAppAdapter | undefined;
+      if (adapter) {
+        await adapter.logout();
+      } else {
+        const tempAdapter = this.createAdapterForChannel(channel) as WhatsAppAdapter;
+        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);
@@ -1084,6 +1158,25 @@ export class ChannelGateway {
 
   // Private methods
 
+  private resolveWhatsAppAuthDir(channel?: Channel): string {
+    const configured = (channel?.config as { authDir?: string } | undefined)?.authDir;
+    if (configured && configured.trim()) {
+      return configured;
+    }
+    return path.join(app.getPath('userData'), 'whatsapp-auth');
+  }
+
+  private clearWhatsAppAuthDir(channel?: Channel): void {
+    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
    */