fluxy-bot 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Self-hosted AI bot — run your own AI assistant from anywhere",
   "type": "module",
   "license": "MIT",

package/supervisor/fluxy-agent.ts

@@ -0,0 +1,169 @@
+/**
+ * Lightweight Claude Agent SDK wrapper for the supervisor's fluxy chat.
+ * No DB dependency — sessions are tracked in-memory.
+ */
+
+import { query, type SDKMessage, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from '../shared/logger.js';
+
+const CREDENTIALS_FILE = path.join(os.homedir(), '.claude', '.credentials.json');
+const PROMPT_FILE = path.join(import.meta.dirname, '..', 'worker', 'prompts', 'fluxy-system-prompt.txt');
+
+// In-memory session tracking (conversationId → sessionId)
+const sessions = new Map<string, string>();
+
+interface ActiveQuery {
+  abortController: AbortController;
+}
+
+const activeQueries = new Map<string, ActiveQuery>();
+
+/** Read the OAuth token stored by claude-auth */
+function readOAuthToken(): string | null {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      const creds = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf-8'));
+      if (creds.accessToken) {
+        if (creds.expiresAt && Date.now() >= creds.expiresAt) return null;
+        return creds.accessToken;
+      }
+    }
+  } catch {}
+  return null;
+}
+
+/** Read the custom system prompt addendum */
+function readSystemPromptAddendum(): string {
+  try {
+    return fs.readFileSync(PROMPT_FILE, 'utf-8').trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Run an Agent SDK query for a fluxy chat conversation.
+ * Streams events back via onMessage callback.
+ */
+export async function startFluxyAgentQuery(
+  conversationId: string,
+  prompt: string,
+  model: string,
+  onMessage: (type: string, data: any) => void,
+): Promise<void> {
+  const oauthToken = readOAuthToken();
+  if (!oauthToken) {
+    onMessage('bot:error', { conversationId, error: 'Claude OAuth token not found. Please authenticate via the dashboard.' });
+    return;
+  }
+
+  const abortController = new AbortController();
+  const existingSessionId = sessions.get(conversationId);
+  const addendum = readSystemPromptAddendum();
+
+  activeQueries.set(conversationId, { abortController });
+
+  let fullText = '';
+
+  try {
+    const claudeQuery = query({
+      prompt,
+      options: {
+        model,
+        cwd: process.cwd(),
+        permissionMode: 'bypassPermissions',
+        allowDangerouslySkipPermissions: true,
+        maxTurns: 50,
+        abortController,
+        systemPrompt: addendum
+          ? { type: 'preset', preset: 'claude_code', append: addendum }
+          : { type: 'preset', preset: 'claude_code' },
+        ...(existingSessionId ? { resume: existingSessionId } : {}),
+        env: {
+          ...process.env as Record<string, string>,
+          CLAUDE_CODE_OAUTH_TOKEN: oauthToken,
+        },
+      },
+    });
+
+    onMessage('bot:typing', { conversationId });
+
+    for await (const msg of claudeQuery) {
+      if (abortController.signal.aborted) break;
+
+      switch (msg.type) {
+        case 'assistant': {
+          const assistantMsg = msg.message;
+          if (!assistantMsg?.content) break;
+
+          // Save session_id from first assistant message
+          if (msg.session_id && !sessions.has(conversationId)) {
+            sessions.set(conversationId, msg.session_id);
+          }
+
+          for (const block of assistantMsg.content) {
+            if (block.type === 'text' && block.text) {
+              fullText += block.text;
+              onMessage('bot:token', { conversationId, token: block.text });
+            } else if (block.type === 'tool_use') {
+              onMessage('bot:tool', { conversationId, name: block.name, input: block.input });
+            }
+          }
+          break;
+        }
+
+        case 'result': {
+          if (msg.session_id) {
+            sessions.set(conversationId, msg.session_id);
+          }
+
+          if (fullText) {
+            onMessage('bot:response', { conversationId, content: fullText });
+            fullText = ''; // prevent duplicate
+          } else if (msg.subtype?.startsWith('error')) {
+            const errorText = (msg as any).errors?.join('; ') || 'Agent query failed';
+            onMessage('bot:error', { conversationId, error: errorText });
+          }
+          break;
+        }
+
+        case 'tool_progress':
+          onMessage('bot:tool', {
+            conversationId,
+            name: (msg as any).tool_name || 'working',
+            status: 'running',
+          });
+          break;
+      }
+    }
+
+    // If we accumulated text but didn't hit a result message, send what we have
+    if (fullText && !abortController.signal.aborted) {
+      onMessage('bot:response', { conversationId, content: fullText });
+    }
+  } catch (err: any) {
+    if (!abortController.signal.aborted) {
+      log.warn(`Fluxy agent error (${conversationId}): ${err.message}`);
+      onMessage('bot:error', { conversationId, error: err.message });
+    }
+  } finally {
+    activeQueries.delete(conversationId);
+  }
+}
+
+/** Stop an in-flight query */
+export function stopFluxyAgentQuery(conversationId: string): void {
+  const q = activeQueries.get(conversationId);
+  if (q) {
+    q.abortController.abort();
+    activeQueries.delete(conversationId);
+  }
+}
+
+/** Clear a conversation's session (for "clear context") */
+export function clearFluxySession(conversationId: string): void {
+  sessions.delete(conversationId);
+}

package/supervisor/index.ts

@@ -10,6 +10,7 @@ import { log } from '../shared/logger.js';
 import { startTunnel, stopTunnel, isTunnelAlive, restartTunnel } from './tunnel.js';
 import { spawnWorker, stopWorker, getWorkerPort, isWorkerAlive } from './worker.js';
 import { updateTunnelUrl, startHeartbeat, stopHeartbeat, disconnect } from '../shared/relay.js';
+import { startFluxyAgentQuery, stopFluxyAgentQuery } from './fluxy-agent.js';
 
 const RECOVERING_HTML = `<!DOCTYPE html><html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Recovering</title>
 <style>body{background:#0a0a0f;color:#94a3b8;font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0}
@@ -123,6 +124,15 @@ export async function startSupervisor() {
         if (!content) return;
         if (data.conversationId) convId = data.conversationId;
 
+        // Route Anthropic through Agent SDK (uses OAuth token, not API key)
+        if (config.ai.provider === 'anthropic') {
+          startFluxyAgentQuery(convId, content, config.ai.model, (type, eventData) => {
+            ws.send(JSON.stringify({ type, data: eventData }));
+          });
+          return;
+        }
+
+        // Other providers: use ai.chat() with conversation history
         const history = conversations.get(ws) || [];
         history.push({ role: 'user', content });
 
@@ -131,7 +141,7 @@ export async function startSupervisor() {
           return;
         }
 
-        ws.send(JSON.stringify({ type: 'bot:typing' }));
+        ws.send(JSON.stringify({ type: 'bot:typing', data: { conversationId: convId } }));
 
         ai.chat(
           [{ role: 'system', content: 'You are Fluxy, a helpful AI assistant. You help users manage and customize their self-hosted bot.' }, ...history],
@@ -147,31 +157,9 @@ export async function startSupervisor() {
       }
 
       if (msg.type === 'user:stop') {
-        // Stop streaming (best-effort — AI provider may not support cancellation)
+        stopFluxyAgentQuery(convId);
         return;
       }
-
-      // Legacy protocol support (old fluxy.html format)
-      if (msg.type === 'message' && msg.content) {
-        const history = conversations.get(ws) || [];
-        history.push({ role: 'user', content: msg.content });
-
-        if (!ai) {
-          ws.send(JSON.stringify({ type: 'error', error: 'AI not configured. Set up your provider first.' }));
-          return;
-        }
-
-        ai.chat(
-          [{ role: 'system', content: 'You are Fluxy, a helpful AI assistant. You help users manage and customize their self-hosted bot.' }, ...history],
-          config.ai.model,
-          (token) => ws.send(JSON.stringify({ type: 'token', token })),
-          (full) => {
-            history.push({ role: 'assistant', content: full });
-            ws.send(JSON.stringify({ type: 'done' }));
-          },
-          (err) => ws.send(JSON.stringify({ type: 'error', error: err.message })),
-        );
-      }
     });
 
     ws.on('close', () => conversations.delete(ws));