fluxy-bot 0.15.1 → 0.15.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "releaseNotes": [
     "1. react router implemented",
     "2. new workspace design",

package/shared/config.ts

@@ -3,10 +3,10 @@ import { paths, DATA_DIR } from './paths.js';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'shared' = user's own number, 'dedicated' = Fluxy has its own number */
-  mode: 'shared' | 'dedicated';
-  /** The human/owner's phone number (used for role resolution in dedicated mode) */
-  humanPhone?: string;
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer support */
+  mode: 'channel' | 'business';
+  /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
+  admins?: string[];
 }
 
 export interface BotConfig {

package/supervisor/channels/manager.ts

@@ -3,10 +3,16 @@
  *
  * Responsibilities:
  * - Manages channel providers (WhatsApp, Telegram, etc.)
- * - Resolves sender role (human vs customer)
+ * - Resolves sender role (admin vs customer) based on mode
  * - Routes inbound messages to the agent with appropriate system prompt
- * - Routes outbound messages from agent/API back to channels
- * - Manages parallel agent instances for customer conversations
+ * - Routes agent responses back to channels
+ * - Manages parallel agent instances for customer conversations (business mode)
+ *
+ * Modes:
+ * - channel: Just talk to me. Only self-chat (fromMe=true) triggers the agent.
+ *            All other messages are ignored — it's the user's personal WhatsApp.
+ * - business: Fluxy has its own number. Numbers in the admins array get the main
+ *             system prompt. Everyone else gets the customer support prompt.
  */
 
 import fs from 'fs';
@@ -30,7 +36,6 @@ interface ChannelManagerOpts {
 interface ActiveAgentQuery {
   sender: string;
   channel: ChannelType;
-  abortController?: AbortController;
 }
 
 export class ChannelManager {
@@ -47,7 +52,7 @@ export class ChannelManager {
   /** Initialize channels based on config */
   async init(): Promise<void> {
     const config = loadConfig();
-    const channelConfigs = (config as any).channels as Record<string, ChannelConfig> | undefined;
+    const channelConfigs = config.channels;
 
     if (!channelConfigs?.whatsapp?.enabled) {
       log.info('[channels] WhatsApp not enabled — skipping');
@@ -75,7 +80,6 @@ export class ChannelManager {
   async connectWhatsApp(): Promise<void> {
     let provider = this.providers.get('whatsapp');
     if (!provider) {
-      // Create provider on-demand if not initialized
       const whatsapp = new WhatsAppChannel(
         (sender, senderName, text, fromMe) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe),
         (status) => this.handleStatusChange(status),
@@ -148,27 +152,10 @@ export class ChannelManager {
     }
   }
 
-  /** Resolve sender role based on channel config */
-  private resolveRole(channel: ChannelType, sender: string, fromMe: boolean): SenderRole {
+  /** Get the channel config, re-reading from disk each time */
+  private getChannelConfig(channel: ChannelType): ChannelConfig | undefined {
     const config = loadConfig();
-    const channelConfigs = (config as any).channels as Record<string, ChannelConfig> | undefined;
-    const channelConfig = channelConfigs?.[channel];
-
-    if (!channelConfig) return 'customer';
-
-    if (channelConfig.mode === 'shared') {
-      // Shared number mode: fromMe messages are from the human
-      return fromMe ? 'human' : 'customer';
-    }
-
-    // Dedicated number mode: check if sender matches human's phone
-    if (channelConfig.humanPhone) {
-      const senderPhone = sender.replace(/@.*/, '').replace(/[^0-9]/g, '');
-      const humanPhone = channelConfig.humanPhone.replace(/[^0-9]/g, '');
-      if (senderPhone === humanPhone) return 'human';
-    }
-
-    return 'customer';
+    return config.channels?.[channel];
   }
 
   /** Handle an incoming message from any channel */
@@ -179,7 +166,34 @@ export class ChannelManager {
     text: string,
     fromMe: boolean,
   ) {
-    const role = this.resolveRole(channel, sender, fromMe);
+    const channelConfig = this.getChannelConfig(channel);
+    if (!channelConfig) return;
+
+    const mode = channelConfig.mode || 'channel';
+
+    // ── Channel mode: only respond to self-chat (fromMe=true) ──
+    if (mode === 'channel') {
+      if (!fromMe) {
+        // Ignore messages from other people — this is the user's personal WhatsApp
+        return;
+      }
+
+      const message: InboundMessage = {
+        channel,
+        sender: sender.replace(/@.*/, ''),
+        senderName,
+        role: 'admin',
+        text,
+        rawSender: sender,
+      };
+
+      log.info(`[channels] Channel mode | self-chat | "${text.slice(0, 60)}"`);
+      await this.handleAdminMessage(message);
+      return;
+    }
+
+    // ── Business mode: resolve role based on admins array ──
+    const role = this.resolveBusinessRole(channelConfig, sender, fromMe);
 
     const message: InboundMessage = {
       channel,
@@ -190,31 +204,47 @@ export class ChannelManager {
       rawSender: sender,
     };
 
-    log.info(`[channels] Inbound ${channel} | ${message.sender} | role=${role} | "${text.slice(0, 60)}"`);
+    log.info(`[channels] Business mode | ${message.sender} | role=${role} | "${text.slice(0, 60)}"`);
 
-    if (role === 'human') {
-      await this.handleHumanMessage(message);
+    if (role === 'admin') {
+      await this.handleAdminMessage(message);
     } else {
       await this.handleCustomerMessage(message);
     }
   }
 
-  /** Handle message from the human/owner — mirrors to chat conversation */
-  private async handleHumanMessage(msg: InboundMessage) {
+  /** Resolve role in business mode — check admins array */
+  private resolveBusinessRole(config: ChannelConfig, sender: string, fromMe: boolean): SenderRole {
+    // fromMe is always admin (the number Fluxy is connected with)
+    if (fromMe) return 'admin';
+
+    // Check admins array
+    if (config.admins?.length) {
+      const senderPhone = sender.replace(/@.*/, '').replace(/[^0-9]/g, '');
+      for (const admin of config.admins) {
+        const adminPhone = admin.replace(/[^0-9]/g, '');
+        if (senderPhone === adminPhone || senderPhone.endsWith(adminPhone) || adminPhone.endsWith(senderPhone)) {
+          return 'admin';
+        }
+      }
+    }
+
+    return 'customer';
+  }
+
+  /** Handle message from an admin — mirrors to chat conversation, uses main system prompt */
+  private async handleAdminMessage(msg: InboundMessage) {
     const { workerApi, broadcastFluxy, getModel } = this.opts;
     const model = getModel();
 
-    // Get or create the human's WhatsApp conversation (mirrored with chat)
+    // Get or create conversation (shared with chat for mirroring)
     let convId: string | undefined;
     try {
       const ctx = await workerApi('/api/context/current');
       if (ctx.conversationId) {
         convId = ctx.conversationId;
       } else {
-        const conv = await workerApi('/api/conversations', 'POST', {
-          title: `WhatsApp`,
-          model,
-        });
+        const conv = await workerApi('/api/conversations', 'POST', { title: 'WhatsApp', model });
         convId = conv.id;
         await workerApi('/api/context/set', 'POST', { conversationId: convId });
       }
@@ -240,7 +270,7 @@ export class ChannelManager {
       message: { role: 'user', content: msg.text, timestamp: new Date().toISOString() },
     });
 
-    // Fetch agent/user names and recent messages
+    // Fetch names and recent messages
     let botName = 'Fluxy', humanName = 'Human';
     let recentMessages: RecentMessage[] = [];
     try {
@@ -261,8 +291,8 @@ export class ChannelManager {
       }
     } catch {}
 
-    // Run agent with main system prompt (same as chat)
-    const channelContext = `[WhatsApp | ${msg.sender} | human]\n`;
+    // Channel context — tells the agent this is a WhatsApp message, respond naturally
+    const channelContext = `[WhatsApp | ${msg.sender} | admin]\n`;
 
     startFluxyAgentQuery(
       convId,
@@ -270,7 +300,7 @@ export class ChannelManager {
       model,
       (type, eventData) => {
         if (type === 'bot:response' && eventData.content) {
-          // Send response back via WhatsApp
+          // Send agent's response back via WhatsApp
           this.sendMessage(msg.channel, msg.rawSender, eventData.content).catch((err) => {
             log.warn(`[channels] Failed to send WhatsApp reply: ${err.message}`);
           });
@@ -305,7 +335,6 @@ export class ChannelManager {
 
     // Check concurrent limit
     if (this.activeAgents.size >= MAX_CONCURRENT_AGENTS && !this.activeAgents.has(agentKey)) {
-      // Queue the message
       log.info(`[channels] Max concurrent agents reached — queuing message from ${msg.sender}`);
       this.messageQueue.push(msg);
       return;
@@ -317,7 +346,7 @@ export class ChannelManager {
     // Load support system prompt from skill
     const supportPrompt = this.loadSupportPrompt();
 
-    // Fetch agent/user names
+    // Fetch agent name
     let botName = 'Fluxy', humanName = 'Human';
     try {
       const status = await workerApi('/api/onboard/status');
@@ -325,7 +354,6 @@ export class ChannelManager {
       humanName = status.userName || 'Human';
     } catch {}
 
-    // Build channel context
     const channelContext = `[WhatsApp | ${msg.sender} | customer${msg.senderName ? ` | ${msg.senderName}` : ''}]\n`;
     const convId = `channel-${agentKey}-${Date.now()}`;
 
@@ -337,7 +365,6 @@ export class ChannelManager {
       model,
       (type, eventData) => {
         if (type === 'bot:response' && eventData.content) {
-          // Send response back via WhatsApp
           this.sendMessage(msg.channel, msg.rawSender, eventData.content).catch((err) => {
             log.warn(`[channels] Failed to send customer reply: ${err.message}`);
           });
@@ -345,12 +372,7 @@ export class ChannelManager {
 
         if (type === 'bot:done') {
           this.activeAgents.delete(agentKey);
-
-          if (eventData.usedFileTools) {
-            this.opts.restartBackend();
-          }
-
-          // Process queued messages
+          if (eventData.usedFileTools) this.opts.restartBackend();
           this.processQueue();
         }
       },
@@ -364,7 +386,6 @@ export class ChannelManager {
 
   /** Load customer-facing system prompt from skills */
   private loadSupportPrompt(): string | undefined {
-    // Look for SUPPORT.md in any skill directory
     const skillsDir = path.join(WORKSPACE_DIR, 'skills');
     try {
       for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {

package/supervisor/channels/types.ts

@@ -3,19 +3,19 @@
  */
 
 export type ChannelType = 'whatsapp' | 'telegram';
-export type SenderRole = 'human' | 'customer';
+export type SenderRole = 'admin' | 'customer';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'shared' = user's own number, 'dedicated' = Fluxy has its own number */
-  mode: 'shared' | 'dedicated';
-  /** The human/owner's phone number (used for role resolution in dedicated mode) */
-  humanPhone?: string;
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer support */
+  mode: 'channel' | 'business';
+  /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
+  admins?: string[];
 }
 
 export interface InboundMessage {
   channel: ChannelType;
-  /** Sender identifier (phone number / JID) */
+  /** Sender identifier (phone number) */
   sender: string;
   /** Sender display name if available */
   senderName?: string;
@@ -23,7 +23,7 @@ export interface InboundMessage {
   role: SenderRole;
   /** Message text content */
   text: string;
-  /** Raw sender JID (channel-specific format) */
+  /** Raw sender JID (channel-specific format, used for replies) */
   rawSender: string;
 }
 

package/supervisor/channels/whatsapp.ts

@@ -30,13 +30,18 @@ export class WhatsAppChannel implements ChannelProvider {
 
   private sock: WASocket | null = null;
   private connected = false;
-  private qrData: string | null = null; // raw QR string data
-  private qrSvg: string | null = null;  // SVG rendered QR
+  private qrData: string | null = null;
+  private qrSvg: string | null = null;
   private onMessage: OnWhatsAppMessage;
   private onStatusChange: (status: ChannelStatus) => void;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
   private intentionalDisconnect = false;
 
+  /** Maps LID JIDs to phone JIDs (WhatsApp uses LIDs internally for self-chat) */
+  private lidToPhoneMap = new Map<string, string>();
+  /** Our own phone JID (number@s.whatsapp.net) */
+  private ownPhoneJid: string | null = null;
+
   constructor(
     onMessage: OnWhatsAppMessage,
     onStatusChange: (status: ChannelStatus) => void,
@@ -110,6 +115,42 @@ export class WhatsAppChannel implements ChannelProvider {
 
   // ── Internal ──
 
+  /** Translate a JID from LID format to phone format if possible */
+  private translateJid(jid: string): string {
+    // If it's already a phone JID, return as-is
+    if (jid.endsWith('@s.whatsapp.net')) return jid;
+
+    // Check LID map
+    const mapped = this.lidToPhoneMap.get(jid);
+    if (mapped) return mapped;
+
+    // If it's a LID JID and we know our own phone, and this looks like a self-chat LID
+    // LID JIDs typically end with @lid or have a long numeric format
+    if (this.ownPhoneJid && (jid.includes('@lid') || jid.match(/^\d{15,}@/))) {
+      log.info(`[whatsapp] Unmapped LID ${jid} — assuming self-chat, using own phone JID`);
+      this.lidToPhoneMap.set(jid, this.ownPhoneJid);
+      return this.ownPhoneJid;
+    }
+
+    return jid;
+  }
+
+  /** Build the LID-to-phone mapping from sock.user */
+  private buildLidMap() {
+    if (!this.sock?.user) return;
+
+    const user = this.sock.user;
+    // user.id is "phone:device@s.whatsapp.net" — extract phone
+    const phone = user.id.split(':')[0];
+    this.ownPhoneJid = `${phone}@s.whatsapp.net`;
+
+    // user.lid (if available) is the LID JID
+    if ((user as any).lid) {
+      this.lidToPhoneMap.set((user as any).lid, this.ownPhoneJid);
+      log.info(`[whatsapp] LID map: ${(user as any).lid} → ${this.ownPhoneJid}`);
+    }
+  }
+
   private async connectInternal(): Promise<void> {
     // Ensure auth directory exists
     fs.mkdirSync(AUTH_DIR, { recursive: true });
@@ -164,6 +205,7 @@ export class WhatsAppChannel implements ChannelProvider {
         this.connected = true;
         this.qrData = null;
         this.qrSvg = null;
+        this.buildLidMap();
         log.ok(`[whatsapp] Connected as ${sock.user?.id}`);
         this.emitStatus();
       }
@@ -207,10 +249,13 @@ export class WhatsAppChannel implements ChannelProvider {
         if (!text) continue;
 
         const fromMe = msg.key.fromMe || false;
-        const sender = msg.key.remoteJid || '';
+        const rawSender = msg.key.remoteJid || '';
+
+        // Translate LID JIDs to phone JIDs
+        const sender = this.translateJid(rawSender);
         const pushName = msg.pushName || undefined;
 
-        log.info(`[whatsapp] Message from ${sender} (fromMe=${fromMe}): ${text.slice(0, 80)}`);
+        log.info(`[whatsapp] Message from ${sender} (raw=${rawSender}, fromMe=${fromMe}): ${text.slice(0, 80)}`);
 
         this.onMessage(sender, pushName, text, fromMe);
       }

package/supervisor/index.ts

@@ -429,7 +429,7 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
             // Enable WhatsApp in config
             const cfg = loadConfig();
             if (!cfg.channels) cfg.channels = {};
-            if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'shared' };
+            if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'channel' };
             cfg.channels.whatsapp.enabled = true;
             saveConfig(cfg);
 
@@ -480,7 +480,7 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
         return;
       }
 
-      // POST /api/channels/whatsapp/configure — set mode + human phone
+      // POST /api/channels/whatsapp/configure — set mode + admins
       if (req.method === 'POST' && channelPath === '/api/channels/whatsapp/configure') {
         let body = '';
         req.on('data', (chunk: Buffer) => { body += chunk.toString(); });
@@ -489,9 +489,9 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
             const data = JSON.parse(body);
             const cfg = loadConfig();
             if (!cfg.channels) cfg.channels = {};
-            if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'shared' };
+            if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'channel' };
             if (data.mode) cfg.channels.whatsapp.mode = data.mode;
-            if (data.humanPhone !== undefined) cfg.channels.whatsapp.humanPhone = data.humanPhone;
+            if (data.admins !== undefined) cfg.channels.whatsapp.admins = data.admins;
             saveConfig(cfg);
             res.writeHead(200);
             res.end(JSON.stringify({ ok: true, config: cfg.channels.whatsapp }));

package/worker/prompts/fluxy-system-prompt.txt

@@ -206,6 +206,14 @@ Complex cron tasks can have detailed instruction files in `tasks/{cron-id}.md`.
 
 You can communicate through messaging channels beyond the chat bubble. Currently supported: **WhatsApp**.
 
+### CRITICAL: How WhatsApp Responses Work
+
+**Your text response IS the WhatsApp reply.** When you receive a message tagged with `[WhatsApp | ...]`, the supervisor takes whatever you respond with and sends it directly to WhatsApp. You do NOT need to use curl or `/api/channels/send` to reply — just respond normally as if you're talking to the person.
+
+**Do NOT use `/api/channels/send` to reply to incoming WhatsApp messages.** That endpoint is ONLY for proactive messages (during pulse, cron, or when you want to initiate a conversation). If you use it to reply, the person will get duplicate messages.
+
+**Adjust your style for WhatsApp:** Keep messages shorter and more conversational than chat. No markdown headers, no code blocks unless asked. Think texting, not email.
+
 ### Channel Config
 
 Your channel configuration is injected below (if any channels are configured). It comes from `~/.fluxy/config.json` — a file OUTSIDE your workspace that the supervisor manages.
@@ -220,28 +228,41 @@ Hi, I'd like to schedule an appointment.
 
 The format is: `[Channel | phone | role | name (optional)]`
 
-- **role=human**: This is YOUR human (the owner). Use your normal personality, full capabilities, main system prompt.
+- **role=admin**: This is your human or an authorized admin. Use your normal personality, full capabilities, main system prompt.
 - **role=customer**: This is someone else messaging. You're in **support mode** — follow the instructions from your active skill's SUPPORT.md.
 
+### WhatsApp Modes
+
+**Channel Mode** (default): Your human's own WhatsApp number. Only self-chat triggers you — messages from other people are completely ignored. This is "just talk to me" mode.
+
+**Business Mode**: Fluxy has its own dedicated number. Numbers in the `admins` array get admin access (main system prompt). Everyone else is a customer (support prompt).
+
 ### Setting Up WhatsApp
 
 When your human asks to configure WhatsApp:
 1. Start the connection: `curl -s -X POST http://localhost:3000/api/channels/whatsapp/connect`
 2. Tell them to open the QR page: `http://localhost:3000/api/channels/whatsapp/qr-page` (or create a dashboard page that embeds it)
 3. They scan the QR with their WhatsApp app
-4. Once connected, configure the mode:
-   - **Shared number** (default): Your human's own WhatsApp. Messages they send to themselves trigger you.
-   - **Dedicated number**: A separate phone/SIM for you. Configure with: `curl -s -X POST http://localhost:3000/api/channels/whatsapp/configure -H "Content-Type: application/json" -d '{"mode":"dedicated","humanPhone":"+1234567890"}'`
+4. The default mode is **channel** (self-chat only)
+
+To switch to **business mode** with admin numbers:
+```bash
+curl -s -X POST http://localhost:3000/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" \
+  -d '{"mode":"business","admins":["+17865551234","+5511999887766"]}'
+```
 
-### Sending Messages
+### Sending Proactive Messages
 
-To send a WhatsApp message (during pulse, cron, or any time):
+To INITIATE a WhatsApp message (during pulse, cron, or when you want to reach out first):
 ```bash
 curl -s -X POST http://localhost:3000/api/channels/send \
   -H "Content-Type: application/json" \
   -d '{"channel":"whatsapp","to":"5511999888777","text":"Your appointment is confirmed for tomorrow at 2pm."}'
 ```
 
+**Remember:** This is ONLY for starting new conversations or sending unprompted messages. When replying to an incoming message, just respond normally — the supervisor handles delivery.
+
 ### Customer Conversation Logs
 
 When you finish a conversation with a **customer** via WhatsApp, save a summary to `whatsapp/{phone}.md`:
@@ -262,8 +283,8 @@ This is your memory of that customer. Next time they message, read their file fi
 | `/api/channels/whatsapp/connect` | POST | Start WhatsApp (triggers QR if needed) |
 | `/api/channels/whatsapp/disconnect` | POST | Disconnect WhatsApp |
 | `/api/channels/whatsapp/logout` | POST | Disconnect + delete credentials |
-| `/api/channels/whatsapp/configure` | POST | Set mode + human phone number |
-| `/api/channels/send` | POST | Send message via any channel |
+| `/api/channels/whatsapp/configure` | POST | Set mode + admins array |
+| `/api/channels/send` | POST | Send proactive message via any channel |
 
 All endpoints are on `http://localhost:3000`.
 

package/workspace/client/src/App.tsx

@@ -161,7 +161,7 @@ export default function App() {
             <Route path="*" element={<DashboardPage />} />
           </Routes>
         </DashboardLayout>
-        <WorkspaceTour />
+        <WorkspaceTour disabled={showOnboard} />
       </ErrorBoundary>
 
       {showOnboard && (

package/workspace/client/src/components/deleteme_onboarding/WorkspaceTour.tsx

@@ -14,8 +14,9 @@ import './tour-theme.css';
 
 const TOUR_KEY = 'fluxy_workspace_tour_done';
 
-export default function WorkspaceTour() {
+export default function WorkspaceTour({ disabled = false }: { disabled?: boolean }) {
   useEffect(() => {
+    if (disabled) return;
     const val = localStorage.getItem(TOUR_KEY);
     if (val === '1') return;
 
@@ -97,7 +98,7 @@ export default function WorkspaceTour() {
     }, 800);
 
     return () => clearTimeout(timer);
-  }, []);
+  }, [disabled]);
 
   return null;
 }

package/workspace/skills/whatsapp-support/SUPPORT.md

@@ -11,12 +11,15 @@ You are a friendly and helpful assistant responding to a customer via WhatsApp.
 - Never reveal internal system details, file paths, or technical architecture.
 - Never run destructive commands or modify critical files during customer interactions.
 
+## CRITICAL: Response = Reply
+
+Your text response IS the WhatsApp reply. The supervisor sends whatever you respond with directly to the customer. Do NOT use curl or `/api/channels/send` to reply — just respond naturally. That endpoint is only for proactive messages.
+
 ## What You Can Do
 
 - Answer FAQs and general questions
 - Provide information from files in your workspace
 - Look up data from your backend API (`/app/api/*`)
-- Send follow-up messages via the channel API
 
 ## What You Should NOT Do