bloby-bot 0.17.2

package/supervisor/app-ws.js

@@ -0,0 +1,200 @@
+(function () {
+  if (window.__appWs) return;
+
+  var RECONNECT_BASE = 1000;
+  var RECONNECT_MAX = 8000;
+  var HEARTBEAT_MS = 25000;
+  var REQUEST_TIMEOUT = 30000;
+
+  var ws = null;
+  var connected = false;
+  var reconnectDelay = RECONNECT_BASE;
+  var reconnectTimer = null;
+  var heartbeatTimer = null;
+  var pendingRequests = {};
+  var requestCounter = 0;
+  var intentionalClose = false;
+  var originalFetch = window.fetch;
+
+  function buildWsUrl() {
+    var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    return proto + '//' + location.host + '/app/ws';
+  }
+
+  function startHeartbeat() {
+    stopHeartbeat();
+    heartbeatTimer = setInterval(function () {
+      if (ws && ws.readyState === WebSocket.OPEN) ws.send('ping');
+    }, HEARTBEAT_MS);
+  }
+
+  function stopHeartbeat() {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  }
+
+  function failoverPending() {
+    var ids = Object.keys(pendingRequests);
+    for (var i = 0; i < ids.length; i++) {
+      var p = pendingRequests[ids[i]];
+      clearTimeout(p.timer);
+      console.log('[app-ws] WS dropped, falling back to fetch: ' + p.method + ' ' + p.path);
+      p.resolve(originalFetch(p.input, p.init));
+    }
+    pendingRequests = {};
+  }
+
+  function connect() {
+    intentionalClose = false;
+    var url = buildWsUrl();
+    ws = new WebSocket(url);
+
+    ws.onopen = function () {
+      connected = true;
+      reconnectDelay = RECONNECT_BASE;
+      startHeartbeat();
+      console.log('[app-ws] Connected to /app/ws');
+    };
+
+    ws.onmessage = function (e) {
+      if (e.data === 'pong') return;
+
+      var msg;
+      try {
+        msg = JSON.parse(e.data);
+      } catch (err) {
+        return;
+      }
+
+      if (msg.type === 'app:api:response' && msg.data && msg.data.id) {
+        var pending = pendingRequests[msg.data.id];
+        if (pending) {
+          clearTimeout(pending.timer);
+          delete pendingRequests[msg.data.id];
+
+          console.log('[app-ws] Response via WS: ' + msg.data.status + ' ' + pending.method + ' ' + pending.path);
+
+          var responseBody = msg.data.body;
+          if (responseBody === null || responseBody === undefined) responseBody = '';
+
+          var responseInit = {
+            status: msg.data.status,
+            headers: msg.data.headers || {},
+          };
+
+          pending.resolve(new Response(responseBody, responseInit));
+        }
+      }
+    };
+
+    ws.onclose = function () {
+      connected = false;
+      stopHeartbeat();
+      failoverPending();
+
+      if (!intentionalClose) {
+        console.log('[app-ws] Disconnected, reconnecting in ' + reconnectDelay + 'ms');
+        reconnectTimer = setTimeout(function () {
+          reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX);
+          connect();
+        }, reconnectDelay);
+      }
+    };
+
+    ws.onerror = function () {
+      if (ws) ws.close();
+    };
+  }
+
+  // Override window.fetch to intercept /app/api/* calls
+  window.fetch = function (input, init) {
+    var url = input instanceof Request ? input.url : String(input);
+    var method = (init && init.method) || (input instanceof Request ? input.method : 'GET');
+
+    // Only intercept /app/api/* calls
+    if (url.indexOf('/app/api') === -1) {
+      return originalFetch.apply(this, arguments);
+    }
+
+    // Fallback: WS not connected
+    if (!connected || !ws || ws.readyState !== WebSocket.OPEN) {
+      console.log('[app-ws] WS not connected, falling back to fetch: ' + method + ' ' + url);
+      return originalFetch.apply(this, arguments);
+    }
+
+    // Fallback: non-serializable body (FormData, Blob, ArrayBuffer)
+    var body = init && init.body;
+    if (body && (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer)) {
+      console.log('[app-ws] Non-serializable body, falling back to fetch: ' + method + ' ' + url);
+      return originalFetch.apply(this, arguments);
+    }
+
+    // Build request
+    var id = 'r' + ++requestCounter + '-' + Date.now().toString(36);
+
+    var reqPath = url;
+    try {
+      var parsed = new URL(url, location.origin);
+      reqPath = parsed.pathname + parsed.search;
+    } catch (e) {}
+
+    var headers = {};
+    if (init && init.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach(function (v, k) {
+          headers[k] = v;
+        });
+      } else if (typeof init.headers === 'object') {
+        var h = init.headers;
+        for (var k in h) {
+          if (Object.prototype.hasOwnProperty.call(h, k)) headers[k] = h[k];
+        }
+      }
+    }
+
+    var bodyStr = null;
+    if (body !== undefined && body !== null) {
+      bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
+    }
+
+    console.log('[app-ws] Proxying via WS: ' + method + ' ' + reqPath);
+
+    ws.send(
+      JSON.stringify({
+        type: 'app:api',
+        data: { id: id, method: method.toUpperCase(), path: reqPath, headers: headers, body: bodyStr },
+      })
+    );
+
+    var savedInput = input;
+    var savedInit = init;
+
+    return new Promise(function (resolve, reject) {
+      var timer = setTimeout(function () {
+        delete pendingRequests[id];
+        console.log('[app-ws] Request timed out, falling back to fetch: ' + method + ' ' + reqPath);
+        resolve(originalFetch(savedInput, savedInit));
+      }, REQUEST_TIMEOUT);
+
+      pendingRequests[id] = {
+        resolve: resolve,
+        reject: reject,
+        timer: timer,
+        input: savedInput,
+        init: savedInit,
+        method: method,
+        path: reqPath,
+      };
+    });
+  };
+
+  window.__appWs = {
+    connected: function () {
+      return connected;
+    },
+  };
+
+  connect();
+})();

package/supervisor/backend.ts

@@ -0,0 +1,143 @@
+import { spawn, type ChildProcess } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { PKG_DIR, WORKSPACE_DIR } from '../shared/paths.js';
+import { log } from '../shared/logger.js';
+
+let child: ChildProcess | null = null;
+let restarts = 0;
+let lastSpawnTime = 0;
+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(WORKSPACE_DIR, '.backend.log');
+
+export function getBackendPort(basePort: number): number {
+  return basePort + 4;
+}
+
+export function spawnBackend(port: number): ChildProcess {
+  const backendPath = path.join(WORKSPACE_DIR, 'backend', 'index.ts');
+  lastSpawnTime = Date.now();
+  intentionallyStopped = false;
+
+  // Clear log file on each restart — only keeps current run
+  try { fs.writeFileSync(LOG_FILE, ''); } catch {}
+
+  // Wrap the backend in an inline loader that:
+  // 1. Registers module resolution hooks to prevent walk-up to parent node_modules
+  // 2. Dynamically imports the user's backend (tsx handles .ts compilation)
+  // 3. Adds a keepalive timer so the event loop never drains (fixes exit code 0 under systemd)
+  // 4. Catches and logs import errors instead of silently exiting
+  const backendUrl = 'file://' + backendPath.replace(/\\/g, '/');
+  const boundary = WORKSPACE_DIR + path.sep;
+  const wrapper = [
+    // Workspace isolation: block module resolution outside workspace/node_modules.
+    // tsx loads via --import BEFORE this code runs, so it resolves from root (correct).
+    // All subsequent imports (the backend code) are restricted to workspace.
+    `const nodeModule = await import('node:module');`,
+    `const { fileURLToPath } = await import('node:url');`,
+    `if (nodeModule.registerHooks) {`,
+    `  const BOUNDARY = ${JSON.stringify(boundary)};`,
+    `  nodeModule.registerHooks({`,
+    `    resolve(specifier, context, nextResolve) {`,
+    `      const result = nextResolve(specifier, context);`,
+    `      if (result.url.startsWith('node:') || result.url.startsWith('data:')) return result;`,
+    `      if (fileURLToPath(result.url).startsWith(BOUNDARY)) return result;`,
+    `      throw new Error('[workspace-isolate] "' + specifier + '" resolved outside workspace: ' + fileURLToPath(result.url));`,
+    `    }`,
+    `  });`,
+    `} else {`,
+    `  console.warn('[backend] Node 22.15+ required for workspace isolation — running without module boundaries');`,
+    `}`,
+    `import('${backendUrl}')`,
+    `  .catch(e => { console.error('[backend] Fatal:', e); process.exit(1); });`,
+    `setInterval(() => {}, 60000);`,
+  ].join('\n');
+
+  child = spawn(process.execPath, ['--import', 'tsx/esm', '--input-type=module', '-e', wrapper], {
+    cwd: WORKSPACE_DIR,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env, BACKEND_PORT: String(port) },
+  });
+
+  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) => {
+    // Supervisor called stopBackend() — don't auto-restart
+    if (intentionallyStopped) return;
+
+    // Any unexpected exit (crash, SIGTERM, OOM, null code) — restart
+    log.warn(`Backend exited unexpectedly (code ${code})`);
+    // If backend was alive for >30s, it's not a crash loop — reset counter
+    if (Date.now() - lastSpawnTime > STABLE_THRESHOLD) {
+      restarts = 0;
+    }
+    if (restarts < MAX_RESTARTS) {
+      restarts++;
+      const delay = Math.min(1000 * restarts, 5000);
+      log.info(`Restarting backend (${restarts}/${MAX_RESTARTS}, delay ${delay}ms)...`);
+      setTimeout(() => spawnBackend(port), delay);
+    } else {
+      log.error('Backend failed too many times. Use Bloby chat to debug.');
+    }
+  });
+
+  log.ok(`Backend spawned on port ${port}`);
+  return child;
+}
+
+/** 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).
+ *  Concurrent calls return the same promise to avoid double-spawn races. */
+let stopPromise: Promise<void> | null = null;
+
+export function stopBackend(): Promise<void> {
+  if (stopPromise) return stopPromise;
+
+  if (!child || child.exitCode !== null) {
+    child = null;
+    return Promise.resolve();
+  }
+
+  intentionallyStopped = true;
+  const dying = child;
+  child = null;
+
+  stopPromise = new Promise<void>((resolve) => {
+    dying.once('exit', () => {
+      stopPromise = null;
+      resolve();
+    });
+    dying.kill();
+    // Safety: force kill after 3s if SIGTERM doesn't work
+    setTimeout(() => {
+      try { dying.kill('SIGKILL'); } catch {}
+      stopPromise = null;
+      resolve();
+    }, 3000);
+  });
+
+  return stopPromise;
+}
+
+export function isBackendAlive(): boolean {
+  return child !== null && child.exitCode === null;
+}
+
+export function isBackendStopping(): boolean {
+  return stopPromise !== null;
+}
+
+export function resetBackendRestarts(): void {
+  restarts = 0;
+}

package/supervisor/bloby-agent.ts

@@ -0,0 +1,299 @@
+/**
+ * Lightweight Claude Agent SDK wrapper for the supervisor's bloby chat.
+ * Fresh context per turn — memory files and conversation history are injected into the system prompt.
+ */
+
+import { query, type SDKMessage, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import fs from 'fs';
+import path from 'path';
+import { log } from '../shared/logger.js';
+import { WORKSPACE_DIR } from '../shared/paths.js';
+import type { SavedFile } from './file-saver.js';
+import { getClaudeAccessToken } from '../worker/claude-auth.js';
+
+const PROMPT_FILE = path.join(import.meta.dirname, '..', 'worker', 'prompts', 'bloby-system-prompt.txt');
+
+export interface RecentMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+interface ActiveQuery {
+  abortController: AbortController;
+}
+
+const activeQueries = new Map<string, ActiveQuery>();
+
+export interface AgentAttachment {
+  type: 'image' | 'file';
+  name: string;
+  mediaType: string;
+  data: string; // base64
+}
+
+/** Read a memory file from workspace, returning '(empty)' if missing or empty */
+function readMemoryFile(filename: string): string {
+  try {
+    const content = fs.readFileSync(path.join(WORKSPACE_DIR, filename), 'utf-8').trim();
+    return content || '(empty)';
+  } catch {
+    return '(empty)';
+  }
+}
+
+/** Read all memory + config files and return their contents */
+function readMemoryFiles(): { myself: string; myhuman: string; memory: string; pulse: string; crons: string } {
+  return {
+    myself: readMemoryFile('MYSELF.md'),
+    myhuman: readMemoryFile('MYHUMAN.md'),
+    memory: readMemoryFile('MEMORY.md'),
+    pulse: readMemoryFile('PULSE.json'),
+    crons: readMemoryFile('CRONS.json'),
+  };
+}
+
+/** Format recent messages as conversation history text */
+function formatConversationHistory(messages: RecentMessage[]): string {
+  if (!messages.length) return '';
+  return messages.map((m) => `${m.role}: ${m.content}`).join('\n\n');
+}
+
+/** Build a multi-part prompt with attachments for the SDK */
+function buildMultiPartPrompt(text: string, attachments: AgentAttachment[], savedFiles?: SavedFile[]): AsyncIterable<SDKUserMessage> {
+  return (async function* () {
+    const content: any[] = [];
+
+    for (const att of attachments) {
+      if (att.type === 'image') {
+        content.push({
+          type: 'image',
+          source: { type: 'base64', media_type: att.mediaType, data: att.data },
+        });
+      } else {
+        content.push({
+          type: 'document',
+          source: { type: 'base64', media_type: att.mediaType, data: att.data },
+        });
+      }
+    }
+
+    // Append local file paths so Claude can reference them with tools
+    let promptText = text || '(attached files)';
+    if (savedFiles?.length) {
+      const lines = savedFiles.map((f) => `- ${f.name} -> ${f.relPath}`);
+      promptText += `\n\n[Attached files saved to disk]\n${lines.join('\n')}\nYou can read or reference these files using the paths above (relative to your cwd).`;
+    }
+
+    content.push({ type: 'text', text: promptText });
+
+    yield {
+      type: 'user' as const,
+      message: { role: 'user' as const, content },
+      parent_tool_use_id: null,
+    } as SDKUserMessage;
+  })();
+}
+
+/** Read the custom system prompt, replacing $BOT and $HUMAN placeholders */
+function readSystemPrompt(botName = 'Bloby', humanName = 'Human'): string {
+  try {
+    const raw = fs.readFileSync(PROMPT_FILE, 'utf-8').trim();
+    if (!raw) {
+      log.warn('System prompt file is empty — using minimal fallback');
+      return `You are ${botName}, a helpful AI agent. Your human is ${humanName}.`;
+    }
+    return raw.replace(/\$BOT/g, botName).replace(/\$HUMAN/g, humanName);
+  } catch {
+    log.warn('System prompt file not found — using minimal fallback');
+    return `You are ${botName}, a helpful AI agent. Your human is ${humanName}.`;
+  }
+}
+
+/**
+ * Run an Agent SDK query for a bloby chat conversation.
+ * Fresh context each turn — memory files and history are injected into the system prompt.
+ */
+export async function startBlobyAgentQuery(
+  conversationId: string,
+  prompt: string,
+  model: string,
+  onMessage: (type: string, data: any) => void,
+  attachments?: AgentAttachment[],
+  savedFiles?: SavedFile[],
+  names?: { botName: string; humanName: string },
+  recentMessages?: RecentMessage[],
+  /** Override system prompt (used for customer-facing channel messages via SUPPORT.md) */
+  supportPrompt?: string,
+): Promise<void> {
+  const oauthToken = await getClaudeAccessToken();
+  if (!oauthToken) {
+    onMessage('bot:error', { conversationId, error: 'Claude OAuth token not found. Please authenticate via the dashboard.' });
+    return;
+  }
+
+  const abortController = new AbortController();
+  const memoryFiles = readMemoryFiles();
+
+  // Build enriched system prompt
+  let enrichedPrompt: string;
+  if (supportPrompt) {
+    // Customer-facing: SCRIPT.md is the ENTIRE prompt. Nothing else.
+    // No memory files, no skill instructions, no config — just the script + conversation history.
+    enrichedPrompt = supportPrompt;
+  } else {
+    // Admin/chat: full main system prompt with all context
+    const basePrompt = readSystemPrompt(names?.botName, names?.humanName);
+    enrichedPrompt = basePrompt;
+    enrichedPrompt += `\n\n---\n# Your Memory Files\n\n## MYSELF.md\n${memoryFiles.myself}\n\n## MYHUMAN.md\n${memoryFiles.myhuman}\n\n## MEMORY.md\n${memoryFiles.memory}\n\n---\n# Your Config Files\n\n## PULSE.json\n${memoryFiles.pulse}\n\n## CRONS.json\n${memoryFiles.crons}`;
+
+    // Inject channel config (admin only)
+    try {
+      const { loadConfig: loadCfg } = await import('../shared/config.js');
+      const cfg = loadCfg();
+      const channels = (cfg as any).channels;
+      if (channels) {
+        enrichedPrompt += `\n\n---\n# Channel Config\n\`\`\`json\n${JSON.stringify(channels, null, 2)}\n\`\`\``;
+      }
+    } catch {}
+  }
+
+  if (recentMessages?.length) {
+    enrichedPrompt += `\n\n---\n# Recent Conversation\n${formatConversationHistory(recentMessages)}`;
+  }
+
+  activeQueries.set(conversationId, { abortController });
+
+  let fullText = '';
+  const usedTools = new Set<string>();
+  let stderrBuf = '';
+
+  // If there are saved files but no inline attachments, append path info to plain text prompt
+  let plainPrompt = prompt;
+  if (savedFiles?.length && !attachments?.length) {
+    const lines = savedFiles.map((f) => `- ${f.name} -> ${f.relPath}`);
+    plainPrompt += `\n\n[Attached files saved to disk]\n${lines.join('\n')}\nYou can read or reference these files using the paths above (relative to your cwd).`;
+  }
+
+  const sdkPrompt: string | AsyncIterable<SDKUserMessage> =
+    attachments?.length ? buildMultiPartPrompt(prompt, attachments, savedFiles) : plainPrompt;
+
+  // Skills are discovered natively by the Claude Agent SDK via .claude-plugin/plugin.json
+  // in each skill folder. No manual injection needed — the SDK handles lazy loading.
+  // Customer mode uses SCRIPT.md exclusively (passed via supportPrompt parameter).
+
+  try {
+
+    // Load MCP server config from workspace/MCP.json if it exists
+    // Format: { "server-name": { command, args, env }, ... } (object, not array)
+    let mcpServers: Record<string, any> | undefined;
+    try {
+      const mcpConfigPath = path.join(WORKSPACE_DIR, 'MCP.json');
+      const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf-8'));
+      if (mcpConfig && typeof mcpConfig === 'object' && !Array.isArray(mcpConfig) && Object.keys(mcpConfig).length) {
+        // Already in correct format: { "name": { command, args, env } }
+        mcpServers = mcpConfig;
+      } else if (Array.isArray(mcpConfig) && mcpConfig.length) {
+        // Legacy array format: merge all entries into a single object
+        mcpServers = Object.assign({}, ...mcpConfig);
+      }
+      if (mcpServers) {
+        const names = Object.keys(mcpServers).join(', ');
+        log.info(`Loaded MCP server(s): [${names}]`);
+      }
+    } catch {}
+
+    const claudeQuery = query({
+      prompt: sdkPrompt,
+      options: {
+        model,
+        cwd: WORKSPACE_DIR,
+        permissionMode: 'bypassPermissions',
+        allowDangerouslySkipPermissions: true,
+        maxTurns: 50,
+        abortController,
+        systemPrompt: enrichedPrompt,
+        mcpServers,
+        stderr: (chunk: string) => { stderrBuf += chunk; },
+        env: {
+          ...process.env as Record<string, string>,
+          CLAUDE_CODE_OAUTH_TOKEN: oauthToken,
+          CLAUDE_CODE_BUBBLEWRAP: '1',
+        },
+      },
+    });
+
+    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;
+
+          for (const block of assistantMsg.content) {
+            if (block.type === 'text' && block.text) {
+              // Add separator between text from different assistant turns
+              if (fullText && !fullText.endsWith('\n')) {
+                fullText += '\n\n';
+                onMessage('bot:token', { conversationId, token: '\n\n' });
+              }
+              fullText += block.text;
+              onMessage('bot:token', { conversationId, token: block.text });
+            } else if (block.type === 'tool_use') {
+              usedTools.add(block.name);
+              onMessage('bot:tool', { conversationId, name: block.name, input: block.input });
+            }
+          }
+          break;
+        }
+
+        case 'result': {
+          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) {
+      const detail = stderrBuf.trim();
+      const msg = detail ? `${err.message}\n\nCLI stderr:\n${detail}` : err.message;
+      log.warn(`Bloby agent error (${conversationId}): ${msg}`);
+      onMessage('bot:error', { conversationId, error: msg });
+    }
+  } finally {
+    activeQueries.delete(conversationId);
+    const FILE_TOOLS = ['Write', 'Edit'];
+    const usedFileTools = FILE_TOOLS.some((t) => usedTools.has(t));
+    onMessage('bot:done', { conversationId, usedFileTools });
+  }
+}
+
+/** Stop an in-flight query */
+export function stopBlobyAgentQuery(conversationId: string): void {
+  const q = activeQueries.get(conversationId);
+  if (q) {
+    q.abortController.abort();
+    activeQueries.delete(conversationId);
+  }
+}