fluxy-bot 0.8.9 → 0.9.0

package/shared/ai.ts

@@ -1,225 +1,141 @@
 export interface ChatMessage {
-    role: 'user' | 'assistant' | 'system';
-    content: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
 }
 
 export interface AiProvider {
-    name: string;
-    chat(
-        messages: ChatMessage[],
-        model: string,
-        onToken: (token: string) => void,
-        onDone: (
-            full: string,
-            usage?: { tokensIn: number; tokensOut: number }
-        ) => void,
-        onError: (err: Error) => void,
-        signal?: AbortSignal
-    ): void;
+  name: string;
+  chat(
+    messages: ChatMessage[],
+    model: string,
+    onToken: (token: string) => void,
+    onDone: (full: string, usage?: { tokensIn: number; tokensOut: number }) => void,
+    onError: (err: Error) => void,
+    signal?: AbortSignal,
+  ): void;
 }
 
-export function createProvider(
-    provider: string,
-    apiKey: string,
-    baseUrl?: string
-): AiProvider | null {
-    switch (provider) {
-        case 'openai':
-            return openai(apiKey, baseUrl);
-        case 'anthropic':
-            return anthropic(apiKey);
-        case 'ollama':
-            return ollama(baseUrl);
-        default:
-            return null;
-    }
+export function createProvider(provider: string, apiKey: string, baseUrl?: string): AiProvider | null {
+  switch (provider) {
+    case 'openai': return openai(apiKey, baseUrl);
+    case 'anthropic': return anthropic(apiKey);
+    case 'ollama': return ollama(baseUrl);
+    default: return null;
+  }
 }
 
 // ── SSE line parser ──
 
-async function readSSE(
-    res: Response,
-    onLine: (line: string) => void,
-    signal?: AbortSignal
-) {
-    const reader = res.body!.getReader();
-    const dec = new TextDecoder();
-    let buf = '';
-    while (true) {
-        if (signal?.aborted) break;
-        const { done, value } = await reader.read();
-        if (done) break;
-        buf += dec.decode(value, { stream: true });
-        const lines = buf.split('\n');
-        buf = lines.pop()!;
-        for (const line of lines) {
-            if (line.startsWith('data: ') && line !== 'data: [DONE]')
-                onLine(line.slice(6));
-        }
+async function readSSE(res: Response, onLine: (line: string) => void, signal?: AbortSignal) {
+  const reader = res.body!.getReader();
+  const dec = new TextDecoder();
+  let buf = '';
+  while (true) {
+    if (signal?.aborted) break;
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    const lines = buf.split('\n');
+    buf = lines.pop()!;
+    for (const line of lines) {
+      if (line.startsWith('data: ') && line !== 'data: [DONE]') onLine(line.slice(6));
     }
+  }
 }
 
 // ── Providers (raw fetch, zero deps) ──
 
-function openai(
-    apiKey: string,
-    baseUrl = 'https://api.openai.com/v1'
-): AiProvider {
-    return {
-        name: 'openai',
-        async chat(messages, model, onToken, onDone, onError, signal) {
-            try {
-                const res = await fetch(`${baseUrl}/chat/completions`, {
-                    method: 'POST',
-                    headers: {
-                        Authorization: `Bearer ${apiKey}`,
-                        'Content-Type': 'application/json'
-                    },
-                    body: JSON.stringify({
-                        model,
-                        messages,
-                        stream: true,
-                        stream_options: { include_usage: true }
-                    }),
-                    signal
-                });
-                if (!res.ok)
-                    throw new Error(
-                        `OpenAI ${res.status}: ${await res.text()}`
-                    );
-                let full = '';
-                let usage: { tokensIn: number; tokensOut: number } | undefined;
-                await readSSE(
-                    res,
-                    line => {
-                        const j = JSON.parse(line);
-                        const t = j.choices?.[0]?.delta?.content;
-                        if (t) {
-                            full += t;
-                            onToken(t);
-                        }
-                        if (j.usage)
-                            usage = {
-                                tokensIn: j.usage.prompt_tokens,
-                                tokensOut: j.usage.completion_tokens
-                            };
-                    },
-                    signal
-                );
-                onDone(full, usage);
-            } catch (e) {
-                if (!signal?.aborted)
-                    onError(e instanceof Error ? e : new Error(String(e)));
-            }
-        }
-    };
+function openai(apiKey: string, baseUrl = 'https://api.openai.com/v1'): AiProvider {
+  return {
+    name: 'openai',
+    async chat(messages, model, onToken, onDone, onError, signal) {
+      try {
+        const res = await fetch(`${baseUrl}/chat/completions`, {
+          method: 'POST',
+          headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ model, messages, stream: true, stream_options: { include_usage: true } }),
+          signal,
+        });
+        if (!res.ok) throw new Error(`OpenAI ${res.status}: ${await res.text()}`);
+        let full = '';
+        let usage: { tokensIn: number; tokensOut: number } | undefined;
+        await readSSE(res, (line) => {
+          const j = JSON.parse(line);
+          const t = j.choices?.[0]?.delta?.content;
+          if (t) { full += t; onToken(t); }
+          if (j.usage) usage = { tokensIn: j.usage.prompt_tokens, tokensOut: j.usage.completion_tokens };
+        }, signal);
+        onDone(full, usage);
+      } catch (e) { if (!signal?.aborted) onError(e instanceof Error ? e : new Error(String(e))); }
+    },
+  };
 }
 
 function anthropic(apiKey: string): AiProvider {
-    return {
-        name: 'anthropic',
-        async chat(messages, model, onToken, onDone, onError, signal) {
-            try {
-                const sys = messages.find(m => m.role === 'system');
-                const msgs = messages.filter(m => m.role !== 'system');
-                const res = await fetch(
-                    'https://api.anthropic.com/v1/messages',
-                    {
-                        method: 'POST',
-                        headers: {
-                            'x-api-key': apiKey,
-                            'anthropic-version': '2023-06-01',
-                            'Content-Type': 'application/json'
-                        },
-                        body: JSON.stringify({
-                            model,
-                            max_tokens: 4096,
-                            system: sys?.content,
-                            messages: msgs,
-                            stream: true
-                        }),
-                        signal
-                    }
-                );
-                if (!res.ok)
-                    throw new Error(
-                        `Anthropic ${res.status}: ${await res.text()}`
-                    );
-                let full = '';
-                let usage: { tokensIn: number; tokensOut: number } | undefined;
-                await readSSE(
-                    res,
-                    line => {
-                        const j = JSON.parse(line);
-                        if (j.type === 'content_block_delta' && j.delta?.text) {
-                            full += j.delta.text;
-                            onToken(j.delta.text);
-                        }
-                        if (j.type === 'message_delta' && j.usage) {
-                            usage = {
-                                tokensIn: j.usage?.input_tokens ?? 0,
-                                tokensOut: j.usage.output_tokens
-                            };
-                        }
-                        if (j.type === 'message_start' && j.message?.usage) {
-                            usage = {
-                                tokensIn: j.message.usage.input_tokens,
-                                tokensOut: 0
-                            };
-                        }
-                    },
-                    signal
-                );
-                onDone(full, usage);
-            } catch (e) {
-                if (!signal?.aborted)
-                    onError(e instanceof Error ? e : new Error(String(e)));
-            }
-        }
-    };
+  return {
+    name: 'anthropic',
+    async chat(messages, model, onToken, onDone, onError, signal) {
+      try {
+        const sys = messages.find((m) => m.role === 'system');
+        const msgs = messages.filter((m) => m.role !== 'system');
+        const res = await fetch('https://api.anthropic.com/v1/messages', {
+          method: 'POST',
+          headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ model, max_tokens: 4096, system: sys?.content, messages: msgs, stream: true }),
+          signal,
+        });
+        if (!res.ok) throw new Error(`Anthropic ${res.status}: ${await res.text()}`);
+        let full = '';
+        let usage: { tokensIn: number; tokensOut: number } | undefined;
+        await readSSE(res, (line) => {
+          const j = JSON.parse(line);
+          if (j.type === 'content_block_delta' && j.delta?.text) {
+            full += j.delta.text;
+            onToken(j.delta.text);
+          }
+          if (j.type === 'message_delta' && j.usage) {
+            usage = { tokensIn: j.usage?.input_tokens ?? 0, tokensOut: j.usage.output_tokens };
+          }
+          if (j.type === 'message_start' && j.message?.usage) {
+            usage = { tokensIn: j.message.usage.input_tokens, tokensOut: 0 };
+          }
+        }, signal);
+        onDone(full, usage);
+      } catch (e) { if (!signal?.aborted) onError(e instanceof Error ? e : new Error(String(e))); }
+    },
+  };
 }
 
 function ollama(baseUrl = 'http://localhost:11434'): AiProvider {
-    return {
-        name: 'ollama',
-        async chat(messages, model, onToken, onDone, onError, signal) {
-            try {
-                const res = await fetch(`${baseUrl}/api/chat`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ model, messages, stream: true }),
-                    signal
-                });
-                if (!res.ok) throw new Error(`Ollama ${res.status}`);
-                const reader = res.body!.getReader();
-                const dec = new TextDecoder();
-                let full = '';
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) break;
-                    for (const line of dec
-                        .decode(value, { stream: true })
-                        .split('\n')
-                        .filter(Boolean)) {
-                        const j = JSON.parse(line);
-                        if (j.message?.content) {
-                            full += j.message.content;
-                            onToken(j.message.content);
-                        }
-                        if (j.done) {
-                            onDone(full, {
-                                tokensIn: j.prompt_eval_count ?? 0,
-                                tokensOut: j.eval_count ?? 0
-                            });
-                            return;
-                        }
-                    }
-                }
-                onDone(full);
-            } catch (e) {
-                if (!signal?.aborted)
-                    onError(e instanceof Error ? e : new Error(String(e)));
-            }
+  return {
+    name: 'ollama',
+    async chat(messages, model, onToken, onDone, onError, signal) {
+      try {
+        const res = await fetch(`${baseUrl}/api/chat`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ model, messages, stream: true }),
+          signal,
+        });
+        if (!res.ok) throw new Error(`Ollama ${res.status}`);
+        const reader = res.body!.getReader();
+        const dec = new TextDecoder();
+        let full = '';
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          for (const line of dec.decode(value, { stream: true }).split('\n').filter(Boolean)) {
+            const j = JSON.parse(line);
+            if (j.message?.content) { full += j.message.content; onToken(j.message.content); }
+            if (j.done) { onDone(full, { tokensIn: j.prompt_eval_count ?? 0, tokensOut: j.eval_count ?? 0 }); return; }
+          }
         }
-    };
+        onDone(full);
+      } catch (e) { if (!signal?.aborted) onError(e instanceof Error ? e : new Error(String(e))); }
+    },
+  };
 }

package/shared/config.ts

@@ -2,52 +2,50 @@ import fs from 'fs';
 import { paths, DATA_DIR } from './paths.js';
 
 export interface BotConfig {
-    port: number;
-    username: string;
-    ai: {
-        provider: 'openai' | 'anthropic' | 'ollama' | '';
-        model: string;
-        apiKey: string;
-        baseUrl?: string;
-    };
-    tunnel: {
-        mode: 'off' | 'quick' | 'named';
-        name?: string;
-        domain?: string;
-        configPath?: string;
-        enabled?: boolean; // for backward compatibility
-    };
-    relay: {
-        token: string;
-        tier: string;
-        url: string;
-    };
-    tunnelUrl?: string;
+  port: number;
+  username: string;
+  ai: {
+    provider: 'openai' | 'anthropic' | 'ollama' | '';
+    model: string;
+    apiKey: string;
+    baseUrl?: string;
+  };
+  tunnel: {
+    mode: 'off' | 'quick' | 'named';
+    name?: string;
+    domain?: string;
+    configPath?: string;
+  };
+  relay: {
+    token: string;
+    tier: string;
+    url: string;
+  };
+  tunnelUrl?: string;
 }
 
-export const DEFAULTS: BotConfig = {
-    port: 3000,
-    username: '',
-    ai: { provider: '', model: '', apiKey: '' },
-    tunnel: { mode: 'quick' },
-    relay: { token: '', tier: '', url: '' }
+const DEFAULTS: BotConfig = {
+  port: 3000,
+  username: '',
+  ai: { provider: '', model: '', apiKey: '' },
+  tunnel: { mode: 'quick' },
+  relay: { token: '', tier: '', url: '' },
 };
 
 export function loadConfig(): BotConfig {
-    if (!fs.existsSync(paths.config))
-        throw new Error('No config. Run `fluxy init`.');
-    const config = JSON.parse(fs.readFileSync(paths.config, 'utf-8'));
+  if (!fs.existsSync(paths.config)) throw new Error('No config. Run `fluxy init`.');
+  const config = JSON.parse(fs.readFileSync(paths.config, 'utf-8'));
 
-    // Backward compat: migrate old { enabled: boolean } → { mode }
-    if ('enabled' in config.tunnel && !('mode' in config.tunnel)) {
-        config.tunnel = { mode: config.tunnel.enabled ? 'quick' : 'off' };
-        saveConfig(config);
-    }
+  // Backward compat: migrate old { enabled: boolean } → { mode }
+  if ('enabled' in config.tunnel && !('mode' in config.tunnel)) {
+    config.tunnel = { mode: config.tunnel.enabled ? 'quick' : 'off' };
+    saveConfig(config);
+  }
 
-    return config;
+  return config;
 }
 
 export function saveConfig(config: BotConfig): void {
-    fs.mkdirSync(DATA_DIR, { recursive: true });
-    fs.writeFileSync(paths.config, JSON.stringify(config, null, 2));
-}
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  fs.writeFileSync(paths.config, JSON.stringify(config, null, 2));
+}

package/shared/logger.ts

@@ -1,21 +1,13 @@
 const c = {
-    r: '\x1b[0m',
-    d: '\x1b[2m',
-    g: '\x1b[32m',
-    y: '\x1b[33m',
-    red: '\x1b[31m',
-    cy: '\x1b[36m'
+  r: '\x1b[0m', d: '\x1b[2m',
+  g: '\x1b[32m', y: '\x1b[33m', red: '\x1b[31m', cy: '\x1b[36m',
 };
 
 const ts = () => new Date().toLocaleTimeString('en-GB', { hour12: false });
 
 export const log = {
-    info: (msg: string, ...a: unknown[]) =>
-        console.log(`${c.d}${ts()}${c.r} ${c.cy}INFO${c.r}  ${msg}`, ...a),
-    warn: (msg: string, ...a: unknown[]) =>
-        console.warn(`${c.d}${ts()}${c.r} ${c.y}WARN${c.r}  ${msg}`, ...a),
-    error: (msg: string, ...a: unknown[]) =>
-        console.error(`${c.d}${ts()}${c.r} ${c.red}ERR${c.r}   ${msg}`, ...a),
-    ok: (msg: string, ...a: unknown[]) =>
-        console.log(`${c.d}${ts()}${c.r} ${c.g}OK${c.r}    ${msg}`, ...a)
+  info: (msg: string, ...a: unknown[]) => console.log(`${c.d}${ts()}${c.r} ${c.cy}INFO${c.r}  ${msg}`, ...a),
+  warn: (msg: string, ...a: unknown[]) => console.warn(`${c.d}${ts()}${c.r} ${c.y}WARN${c.r}  ${msg}`, ...a),
+  error: (msg: string, ...a: unknown[]) => console.error(`${c.d}${ts()}${c.r} ${c.red}ERR${c.r}   ${msg}`, ...a),
+  ok: (msg: string, ...a: unknown[]) => console.log(`${c.d}${ts()}${c.r} ${c.g}OK${c.r}    ${msg}`, ...a),
 };

package/shared/paths.ts

@@ -2,25 +2,19 @@ import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
 
-export const PKG_DIR = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    '..'
-);
+export const PKG_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 export const DATA_DIR = path.join(os.homedir(), '.fluxy');
-export const WORKSPACE_DIR =
-    process.env.FLUXY_WORKSPACE || path.join(PKG_DIR, 'workspace');
-
-console.log('Using workspace directory:', WORKSPACE_DIR);
+export const WORKSPACE_DIR = path.join(PKG_DIR, 'workspace');
 
 const cfName = process.platform === 'win32' ? 'cloudflared.exe' : 'cloudflared';
 
 export const paths = {
-    config: path.join(DATA_DIR, 'config.json'),
-    db: path.join(DATA_DIR, 'memory.db'),
-    widgetJs: path.join(PKG_DIR, 'supervisor', 'widget.js'),
-    cloudflared: path.join(DATA_DIR, 'bin', cfName),
-    files: path.join(WORKSPACE_DIR, 'files'),
-    filesAudio: path.join(WORKSPACE_DIR, 'files', 'audio'),
-    filesImages: path.join(WORKSPACE_DIR, 'files', 'images'),
-    filesDocuments: path.join(WORKSPACE_DIR, 'files', 'documents')
+  config: path.join(DATA_DIR, 'config.json'),
+  db: path.join(DATA_DIR, 'memory.db'),
+  widgetJs: path.join(PKG_DIR, 'supervisor', 'widget.js'),
+  cloudflared: path.join(DATA_DIR, 'bin', cfName),
+  files: path.join(WORKSPACE_DIR, 'files'),
+  filesAudio: path.join(WORKSPACE_DIR, 'files', 'audio'),
+  filesImages: path.join(WORKSPACE_DIR, 'files', 'images'),
+  filesDocuments: path.join(WORKSPACE_DIR, 'files', 'documents'),
 };