fluxy-bot 0.15.2 → 0.15.5

package/package.json

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

package/shared/config.ts

@@ -3,10 +3,12 @@ import { paths, DATA_DIR } from './paths.js';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer support */
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode */
   mode: 'channel' | 'business';
   /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
   admins?: string[];
+  /** Active skill for customer-facing mode (folder name in workspace/skills/) */
+  skill?: string;
 }
 
 export interface BotConfig {

package/supervisor/channels/manager.ts

@@ -25,6 +25,7 @@ import { WhatsAppChannel } from './whatsapp.js';
 import type { ChannelConfig, ChannelProvider, ChannelStatus, ChannelType, InboundMessage, SenderRole } from './types.js';
 
 const MAX_CONCURRENT_AGENTS = 5;
+const MAX_BUFFER_MESSAGES = 30;
 
 interface ChannelManagerOpts {
   broadcastFluxy: (type: string, data: any) => void;
@@ -38,12 +39,19 @@ interface ActiveAgentQuery {
   channel: ChannelType;
 }
 
+interface BufferedMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
 export class ChannelManager {
   private providers = new Map<ChannelType, ChannelProvider>();
   private opts: ChannelManagerOpts;
   private activeAgents = new Map<string, ActiveAgentQuery>();
   private messageQueue: InboundMessage[] = [];
   private statusListeners: ((status: ChannelStatus) => void)[] = [];
+  /** In-memory conversation history per customer (keyed by "channel:phone") */
+  private customerBuffers = new Map<string, BufferedMessage[]>();
 
   constructor(opts: ChannelManagerOpts) {
     this.opts = opts;
@@ -61,7 +69,7 @@ export class ChannelManager {
 
     log.info('[channels] Initializing WhatsApp channel...');
     const whatsapp = new WhatsAppChannel(
-      (sender, senderName, text, fromMe) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe),
+      (sender, senderName, text, fromMe, isSelfChat) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat),
       (status) => this.handleStatusChange(status),
     );
     this.providers.set('whatsapp', whatsapp);
@@ -81,7 +89,7 @@ export class ChannelManager {
     let provider = this.providers.get('whatsapp');
     if (!provider) {
       const whatsapp = new WhatsAppChannel(
-        (sender, senderName, text, fromMe) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe),
+        (sender, senderName, text, fromMe, isSelfChat) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat),
         (status) => this.handleStatusChange(status),
       );
       this.providers.set('whatsapp', whatsapp);
@@ -165,16 +173,17 @@ export class ChannelManager {
     senderName: string | undefined,
     text: string,
     fromMe: boolean,
+    isSelfChat: boolean,
   ) {
     const channelConfig = this.getChannelConfig(channel);
     if (!channelConfig) return;
 
     const mode = channelConfig.mode || 'channel';
 
-    // ── Channel mode: only respond to self-chat (fromMe=true) ──
+    // ── Channel mode: ONLY respond to self-chat ──
     if (mode === 'channel') {
-      if (!fromMe) {
-        // Ignore messages from other people — this is the user's personal WhatsApp
+      if (!fromMe || !isSelfChat) {
+        // Ignore everything except self-chat messages
         return;
       }
 
@@ -192,8 +201,16 @@ export class ChannelManager {
       return;
     }
 
-    // ── Business mode: resolve role based on admins array ──
-    const role = this.resolveBusinessRole(channelConfig, sender, fromMe);
+    // ── Business mode: only respond to INCOMING messages (fromMe=false) ──
+    // fromMe=true means either:
+    //   - Fluxy's own sent replies (would cause loops)
+    //   - User typing on Fluxy's WhatsApp Web (not intended for the bot)
+    // Both should be ignored.
+    if (fromMe) {
+      return;
+    }
+
+    const role = this.resolveBusinessRole(channelConfig, sender);
 
     const message: InboundMessage = {
       channel,
@@ -209,16 +226,12 @@ export class ChannelManager {
     if (role === 'admin') {
       await this.handleAdminMessage(message);
     } else {
-      await this.handleCustomerMessage(message);
+      await this.handleCustomerMessage(message, channelConfig);
     }
   }
 
   /** 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
+  private resolveBusinessRole(config: ChannelConfig, sender: string): SenderRole {
     if (config.admins?.length) {
       const senderPhone = sender.replace(/@.*/, '').replace(/[^0-9]/g, '');
       for (const admin of config.admins) {
@@ -329,8 +342,8 @@ export class ChannelManager {
     );
   }
 
-  /** Handle message from a customer — runs support agent in parallel */
-  private async handleCustomerMessage(msg: InboundMessage) {
+  /** Handle message from a customer — runs support agent in parallel with conversation context */
+  private async handleCustomerMessage(msg: InboundMessage, channelConfig: ChannelConfig) {
     const agentKey = `${msg.channel}:${msg.sender}`;
 
     // Check concurrent limit
@@ -343,8 +356,8 @@ export class ChannelManager {
     const { workerApi, getModel } = this.opts;
     const model = getModel();
 
-    // Load support system prompt from skill
-    const supportPrompt = this.loadSupportPrompt();
+    // Load the active skill's SCRIPT.md as the customer-facing system prompt
+    const scriptPrompt = this.loadActiveScript(channelConfig);
 
     // Fetch agent name
     let botName = 'Fluxy', humanName = 'Human';
@@ -354,17 +367,60 @@ export class ChannelManager {
       humanName = status.userName || 'Human';
     } catch {}
 
+    // Get or create conversation buffer for this customer
+    let buffer = this.customerBuffers.get(agentKey);
+    if (!buffer) {
+      buffer = [];
+      this.customerBuffers.set(agentKey, buffer);
+    }
+
+    // Add the new user message to the buffer
+    buffer.push({ role: 'user', content: msg.text });
+
+    // Trim buffer to max size
+    if (buffer.length > MAX_BUFFER_MESSAGES) {
+      buffer.splice(0, buffer.length - MAX_BUFFER_MESSAGES);
+    }
+
+    // Build recent messages for context (everything except the last one, which is the current message)
+    const recentMessages: RecentMessage[] = buffer.length > 1
+      ? buffer.slice(0, -1).map((m) => ({ role: m.role, content: m.content }))
+      : [];
+
+    // Also load long-term memory from whatsapp/{phone}.md if it exists
+    let customerMemory = '';
+    try {
+      const memoryPath = path.join(WORKSPACE_DIR, 'whatsapp', `${msg.sender}.md`);
+      if (fs.existsSync(memoryPath)) {
+        customerMemory = fs.readFileSync(memoryPath, 'utf-8').trim();
+      }
+    } catch {}
+
     const channelContext = `[WhatsApp | ${msg.sender} | customer${msg.senderName ? ` | ${msg.senderName}` : ''}]\n`;
-    const convId = `channel-${agentKey}-${Date.now()}`;
+
+    // Stable convId per customer (not per message)
+    const convId = `channel-${agentKey}`;
 
     this.activeAgents.set(agentKey, { sender: msg.sender, channel: msg.channel });
 
+    // Build an enriched script prompt with customer memory if available
+    let enrichedScript = scriptPrompt;
+    if (customerMemory && enrichedScript) {
+      enrichedScript += `\n\n---\n# Customer History (${msg.sender})\n\n${customerMemory}`;
+    }
+
     startFluxyAgentQuery(
       convId,
       channelContext + msg.text,
       model,
       (type, eventData) => {
         if (type === 'bot:response' && eventData.content) {
+          // Add assistant response to the buffer
+          buffer!.push({ role: 'assistant', content: eventData.content });
+          if (buffer!.length > MAX_BUFFER_MESSAGES) {
+            buffer!.splice(0, buffer!.length - MAX_BUFFER_MESSAGES);
+          }
+
           this.sendMessage(msg.channel, msg.rawSender, eventData.content).catch((err) => {
             log.warn(`[channels] Failed to send customer reply: ${err.message}`);
           });
@@ -379,27 +435,32 @@ export class ChannelManager {
       undefined,
       undefined,
       { botName, humanName },
-      undefined,
-      supportPrompt,
+      recentMessages,
+      enrichedScript,
     );
   }
 
-  /** Load customer-facing system prompt from skills */
-  private loadSupportPrompt(): string | undefined {
-    const skillsDir = path.join(WORKSPACE_DIR, 'skills');
+  /** Load SCRIPT.md from the active skill configured for this channel */
+  private loadActiveScript(channelConfig: ChannelConfig): string | undefined {
+    const skillName = channelConfig.skill;
+    if (!skillName) {
+      log.warn('[channels] No active skill configured — customer will get no script');
+      return undefined;
+    }
+
+    const scriptPath = path.join(WORKSPACE_DIR, 'skills', skillName, 'SCRIPT.md');
     try {
-      for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
-        if (!entry.isDirectory()) continue;
-        const supportPath = path.join(skillsDir, entry.name, 'SUPPORT.md');
-        if (fs.existsSync(supportPath)) {
-          const content = fs.readFileSync(supportPath, 'utf-8').trim();
-          if (content) {
-            log.info(`[channels] Loaded support prompt from skill: ${entry.name}`);
-            return content;
-          }
+      if (fs.existsSync(scriptPath)) {
+        const content = fs.readFileSync(scriptPath, 'utf-8').trim();
+        if (content) {
+          log.info(`[channels] Loaded SCRIPT.md from skill: ${skillName}`);
+          return content;
         }
       }
-    } catch {}
+      log.warn(`[channels] SCRIPT.md not found in skill: ${skillName}`);
+    } catch (err: any) {
+      log.warn(`[channels] Failed to load SCRIPT.md from ${skillName}: ${err.message}`);
+    }
     return undefined;
   }
 
@@ -407,8 +468,10 @@ export class ChannelManager {
   private processQueue() {
     while (this.messageQueue.length > 0 && this.activeAgents.size < MAX_CONCURRENT_AGENTS) {
       const queued = this.messageQueue.shift()!;
+      const config = this.getChannelConfig(queued.channel);
+      if (!config) continue;
       log.info(`[channels] Processing queued message from ${queued.sender}`);
-      this.handleCustomerMessage(queued);
+      this.handleCustomerMessage(queued, config);
     }
   }
 }

package/supervisor/channels/types.ts

@@ -7,10 +7,12 @@ export type SenderRole = 'admin' | 'customer';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer support */
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode */
   mode: 'channel' | 'business';
   /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
   admins?: string[];
+  /** Active skill for customer-facing mode (folder name in workspace/skills/) */
+  skill?: string;
 }
 
 export interface InboundMessage {

package/supervisor/channels/whatsapp.ts

@@ -23,7 +23,7 @@ import type { ChannelProvider, ChannelStatus, ChannelType } from './types.js';
 const AUTH_DIR = path.join(DATA_DIR, 'channels', 'whatsapp', 'auth');
 
 /** Callback when a new message arrives */
-export type OnWhatsAppMessage = (sender: string, senderName: string | undefined, text: string, fromMe: boolean) => void;
+export type OnWhatsAppMessage = (sender: string, senderName: string | undefined, text: string, fromMe: boolean, isSelfChat: boolean) => void;
 
 export class WhatsAppChannel implements ChannelProvider {
   readonly type: ChannelType = 'whatsapp';
@@ -255,9 +255,12 @@ export class WhatsAppChannel implements ChannelProvider {
         const sender = this.translateJid(rawSender);
         const pushName = msg.pushName || undefined;
 
-        log.info(`[whatsapp] Message from ${sender} (raw=${rawSender}, fromMe=${fromMe}): ${text.slice(0, 80)}`);
+        // Detect self-chat: remoteJid matches our own phone number
+        const isSelfChat = this.ownPhoneJid !== null && sender === this.ownPhoneJid;
 
-        this.onMessage(sender, pushName, text, fromMe);
+        log.info(`[whatsapp] Message from ${sender} (raw=${rawSender}, fromMe=${fromMe}, selfChat=${isSelfChat}): ${text.slice(0, 80)}`);
+
+        this.onMessage(sender, pushName, text, fromMe, isSelfChat);
       }
     });
   }

package/supervisor/fluxy-agent.ts

@@ -7,7 +7,7 @@ import { query, type SDKMessage, type SDKUserMessage } from '@anthropic-ai/claud
 import fs from 'fs';
 import path from 'path';
 import { log } from '../shared/logger.js';
-import { PKG_DIR, WORKSPACE_DIR } from '../shared/paths.js';
+import { WORKSPACE_DIR } from '../shared/paths.js';
 import type { SavedFile } from './file-saver.js';
 import { getClaudeAccessToken } from '../worker/claude-auth.js';
 
@@ -178,29 +178,23 @@ export async function startFluxyAgentQuery(
   const sdkPrompt: string | AsyncIterable<SDKUserMessage> =
     attachments?.length ? buildMultiPartPrompt(prompt, attachments, savedFiles) : plainPrompt;
 
+  // Auto-discover skills — inject SKILL.md contents into system prompt (no SDK plugin system needed)
   try {
-    // Auto-discover all skill plugins in workspace/skills/ — any folder with a valid plugin.json is loaded
-    // Skills use a flat structure on disk (SKILL.md at the root), but the SDK expects
-    // skills/{name}/SKILL.md — we bridge the gap with symlinks created on discovery.
-    const skillsDir = path.join(PKG_DIR, 'workspace', 'skills');
-    const plugins: { type: 'local'; path: string }[] = [];
+    const skillsDir = path.join(WORKSPACE_DIR, 'skills');
+    const skillContents: string[] = [];
     try {
       for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && fs.existsSync(path.join(skillsDir, entry.name, '.claude-plugin', 'plugin.json'))) {
-          plugins.push({ type: 'local' as const, path: path.join(skillsDir, entry.name) });
-
-          // Bridge flat SKILL.md → nested path the SDK expects (via symlink)
-          const skillName = entry.name;
-          const flatSkillMd = path.join(skillsDir, skillName, 'SKILL.md');
-          const sdkDir = path.join(skillsDir, skillName, 'skills', skillName);
-          const sdkSkillMd = path.join(sdkDir, 'SKILL.md');
-          if (fs.existsSync(flatSkillMd) && !fs.existsSync(sdkSkillMd)) {
-            fs.mkdirSync(sdkDir, { recursive: true });
-            fs.symlinkSync(flatSkillMd, sdkSkillMd);
-          }
+        if (!entry.isDirectory()) continue;
+        const skillMd = path.join(skillsDir, entry.name, 'SKILL.md');
+        if (fs.existsSync(skillMd)) {
+          const content = fs.readFileSync(skillMd, 'utf-8').trim();
+          if (content) skillContents.push(`## Skill: ${entry.name}\n\n${content}`);
         }
       }
     } catch {}
+    if (skillContents.length) {
+      enrichedPrompt += `\n\n---\n# Installed Skills\n\n${skillContents.join('\n\n---\n\n')}`;
+    }
 
     // Load MCP server config from workspace/MCP.json if it exists
     // Format: { "server-name": { command, args, env }, ... } (object, not array)
@@ -231,7 +225,6 @@ export async function startFluxyAgentQuery(
         maxTurns: 50,
         abortController,
         systemPrompt: enrichedPrompt,
-        plugins: plugins.length ? plugins : undefined,
         mcpServers,
         stderr: (chunk: string) => { stderrBuf += chunk; },
         env: {

package/supervisor/index.ts

@@ -492,6 +492,7 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
             if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'channel' };
             if (data.mode) cfg.channels.whatsapp.mode = data.mode;
             if (data.admins !== undefined) cfg.channels.whatsapp.admins = data.admins;
+            if (data.skill !== undefined) cfg.channels.whatsapp.skill = data.skill;
             saveConfig(cfg);
             res.writeHead(200);
             res.end(JSON.stringify({ ok: true, config: cfg.channels.whatsapp }));

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

@@ -202,6 +202,37 @@ Complex cron tasks can have detailed instruction files in `tasks/{cron-id}.md`.
 
 ---
 
+## Skills
+
+Skills live in `skills/` — each skill is a folder with instructions and resources:
+
+```
+skills/
+  whatsapp-clinic/
+    SKILL.md          # Instructions for you (how to use this skill)
+    SCRIPT.md         # Customer-facing prompt (loaded as system prompt in business mode)
+    files/            # RAG documents, FAQs, etc.
+```
+
+Only ONE skill can be active for customer-facing mode at a time. The active skill is set in the channel config (`channels.whatsapp.skill`). When your human asks to switch skills, update the config:
+```bash
+curl -s -X POST http://localhost:3000/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" -d '{"skill":"whatsapp-clinic"}'
+```
+
+**IMPORTANT: When editing skill files, always use the full path inside the skill directory.**
+- Correct: `skills/whatsapp-clinic/SCRIPT.md`
+- Wrong: `SCRIPT.md` (this writes to workspace root!)
+
+Your installed skills and their SKILL.md contents are injected below in your context. If your human asks you to update a skill's behavior or script, edit the files INSIDE `skills/{skill-name}/`.
+
+**Separation of concerns:**
+- `MYSELF.md`, `MYHUMAN.md`, `MEMORY.md` — about YOU and your human. Always yours.
+- `skills/{name}/SCRIPT.md` — business logic for customer interactions. Belongs to the skill.
+- `whatsapp/{phone}.md` — customer conversation logs. Your memory of each customer.
+
+---
+
 ## Channels (WhatsApp, Telegram, etc.)
 
 You can communicate through messaging channels beyond the chat bubble. Currently supported: **WhatsApp**.
@@ -229,7 +260,7 @@ Hi, I'd like to schedule an appointment.
 The format is: `[Channel | phone | role | name (optional)]`
 
 - **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.
+- **role=customer**: This is someone else messaging. Follow the instructions from the active skill's SCRIPT.md (loaded as your system prompt).
 
 ### WhatsApp Modes
 

package/workspace/skills/whatsapp-support/.claude-plugin/plugin.json

@@ -1,5 +0,0 @@
-{
-  "name": "whatsapp-support",
-  "description": "WhatsApp customer support skill — handles incoming customer messages with a friendly support persona",
-  "version": "0.1.0"
-}