fluxy-bot 0.5.23 → 0.5.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.5.23",
+  "version": "0.5.25",
   "description": "Self-hosted, self-evolving AI agent with its own dashboard.",
   "type": "module",
   "license": "MIT",

package/supervisor/backend.ts

@@ -1,4 +1,5 @@
 import { spawn, type ChildProcess } from 'child_process';
+import fs from 'fs';
 import path from 'path';
 import { PKG_DIR } from '../shared/paths.js';
 import { log } from '../shared/logger.js';
@@ -10,6 +11,8 @@ let intentionallyStopped = false;
 const MAX_RESTARTS = 3;
 const STABLE_THRESHOLD = 30_000; // 30s — if backend ran this long, it wasn't a crash loop
 
+const LOG_FILE = path.join(PKG_DIR, 'workspace', '.backend.log');
+
 export function getBackendPort(basePort: number): number {
   return basePort + 4;
 }
@@ -19,6 +22,9 @@ export function spawnBackend(port: number): ChildProcess {
   lastSpawnTime = Date.now();
   intentionallyStopped = false;
 
+  // Clear log file on each restart — only keeps current run
+  try { fs.writeFileSync(LOG_FILE, ''); } catch {}
+
   child = spawn(process.execPath, ['--import', 'tsx/esm', backendPath], {
     cwd: path.join(PKG_DIR, 'workspace'),
     stdio: ['ignore', 'pipe', 'pipe'],
@@ -27,10 +33,12 @@ export function spawnBackend(port: number): ChildProcess {
 
   child.stdout?.on('data', (d) => {
     process.stdout.write(d);
+    try { fs.appendFileSync(LOG_FILE, d); } catch {}
   });
 
   child.stderr?.on('data', (d) => {
     process.stderr.write(d);
+    try { fs.appendFileSync(LOG_FILE, d); } catch {}
   });
 
   child.on('exit', (code) => {
@@ -56,10 +64,26 @@ export function spawnBackend(port: number): ChildProcess {
   return child;
 }
 
-export function stopBackend(): void {
-  intentionallyStopped = true;
-  child?.kill();
-  child = null;
+/** Stop the backend and wait for the process to fully exit before resolving.
+ *  This prevents port collisions when restarting (old process must release the port first). */
+export function stopBackend(): Promise<void> {
+  return new Promise((resolve) => {
+    if (!child || child.exitCode !== null) {
+      child = null;
+      resolve();
+      return;
+    }
+    intentionallyStopped = true;
+    const dying = child;
+    child = null;
+    dying.once('exit', () => resolve());
+    dying.kill();
+    // Safety: force kill after 3s if SIGTERM doesn't work
+    setTimeout(() => {
+      try { dying.kill('SIGKILL'); } catch {}
+      resolve();
+    }, 3000);
+  });
 }
 
 export function isBackendAlive(): boolean {

package/supervisor/fluxy-agent.ts

@@ -169,6 +169,17 @@ export async function startFluxyAgentQuery(
       }
     } catch {}
 
+    // Load MCP server config from workspace/MCP.json if it exists
+    let mcpServers: any[] | undefined;
+    try {
+      const mcpConfigPath = path.join(WORKSPACE_DIR, 'MCP.json');
+      const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf-8'));
+      if (Array.isArray(mcpConfig) && mcpConfig.length) {
+        mcpServers = mcpConfig;
+        log.info(`Loaded ${mcpConfig.length} MCP server(s) from MCP.json`);
+      }
+    } catch {}
+
     const claudeQuery = query({
       prompt: sdkPrompt,
       options: {
@@ -180,6 +191,7 @@ export async function startFluxyAgentQuery(
         abortController,
         systemPrompt: enrichedPrompt,
         plugins: plugins.length ? plugins : undefined,
+        mcpServers,
         env: {
           ...process.env as Record<string, string>,
           CLAUDE_CODE_OAUTH_TOKEN: oauthToken,

package/supervisor/index.ts

@@ -507,8 +507,7 @@ export async function startSupervisor() {
                   console.log('[supervisor] Agent turn ended — restarting backend');
                   pendingBackendRestart = false;
                   resetBackendRestarts();
-                  stopBackend();
-                  spawnBackend(backendPort);
+                  stopBackend().then(() => spawnBackend(backendPort));
                 }
                 return; // don't forward bot:done to client
               }
@@ -640,9 +639,9 @@ export async function startSupervisor() {
   startScheduler({
     broadcastFluxy,
     workerApi,
-    restartBackend: () => {
+    restartBackend: async () => {
       resetBackendRestarts();
-      stopBackend();
+      await stopBackend();
       spawnBackend(backendPort);
     },
     getModel: () => loadConfig().ai.model,
@@ -662,10 +661,10 @@ export async function startSupervisor() {
       return;
     }
     if (backendRestartTimer) clearTimeout(backendRestartTimer);
-    backendRestartTimer = setTimeout(() => {
+    backendRestartTimer = setTimeout(async () => {
       log.info(`[watcher] ${reason} — restarting backend...`);
       resetBackendRestarts();
-      stopBackend();
+      await stopBackend();
       spawnBackend(backendPort);
     }, 1000);
   }
@@ -799,7 +798,7 @@ export async function startSupervisor() {
     delete latestConfig.tunnelUrl;
     saveConfig(latestConfig);
     stopWorker();
-    stopBackend();
+    await stopBackend();
     stopTunnel();
     console.log('[supervisor] Stopping Vite dev servers...');
     await stopViteDevServers();

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

@@ -230,7 +230,7 @@ The supervisor manages the backend process. You don't need to manage it yourself
 
 **During your turn:** The backend does NOT restart mid-turn. All your edits are batched — the backend restarts once when you're done. This means if you're writing multi-file changes, everything applies atomically.
 
-**If the backend crashes:** It auto-restarts up to 3 times. If it keeps crashing, check `backend/index.ts` for syntax errors or bad imports.
+**If the backend crashes:** It auto-restarts up to 3 times. If it keeps crashing, read `.backend.log` to see the error output, then fix the code. The log file is cleared on each restart so it only contains the current/last run — no need to truncate it yourself.
 
 **NEVER do these:**
 - Never `kill` processes or run `pkill`/`killall` — you don't manage the supervisor or its children
@@ -238,6 +238,32 @@ The supervisor manages the backend process. You don't need to manage it yourself
 - Never run `npm start` or `node backend/index.ts` directly — the supervisor handles it
 - If something is truly broken and won't self-heal, tell your human to restart fluxy
 
+## MCP Servers (Model Context Protocol)
+
+You can connect to external tools via MCP servers. These give you capabilities beyond your built-in tools — like controlling a browser, querying databases, or interacting with third-party APIs.
+
+**Config file:** `MCP.json` (in your workspace root)
+
+```json
+[
+  {
+    "server-name": {
+      "command": "npx",
+      "args": ["@some/mcp-server"],
+      "env": {}
+    }
+  }
+]
+```
+
+Each entry is an object where the key is the server name and the value has `command`, optional `args`, and optional `env`. The array is read fresh on every turn — add, remove, or edit entries anytime.
+
+**Your human can ask you to add MCP servers.** When they do, read `MCP.json` (create it if missing), add the new server config, and write it back. Common examples:
+- **Playwright** (browser control): `{ "playwright": { "command": "npx", "args": ["@playwright/mcp@latest", "--headless", "--browser", "chromium"] } }`
+- **Fetch** (HTTP requests): `{ "fetch": { "command": "npx", "args": ["@anthropic-ai/mcp-fetch@latest"] } }`
+
+When an MCP server is configured, its tools appear alongside your built-in tools. Use them naturally — no special syntax needed.
+
 ## Sacred Files — NEVER Modify
 - `supervisor/` — chat UI, proxy, process management
 - `worker/` — platform APIs and database