bloby-bot 0.17.2

package/supervisor/scheduler.ts

@@ -0,0 +1,309 @@
+/**
+ * Pulse & Cron Scheduler
+ * Runs inside the supervisor, checks timing every 60 seconds,
+ * and fires startBlobyAgentQuery for autonomous agent actions.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { CronExpressionParser } from 'cron-parser';
+import { WORKSPACE_DIR } from '../shared/paths.js';
+import { log } from '../shared/logger.js';
+import { startBlobyAgentQuery } from './bloby-agent.js';
+
+const PULSE_FILE = path.join(WORKSPACE_DIR, 'PULSE.json');
+const CRONS_FILE = path.join(WORKSPACE_DIR, 'CRONS.json');
+
+interface PulseConfig {
+  enabled: boolean;
+  intervalMinutes: number;
+  quietHours: { start: string; end: string };
+}
+
+interface CronConfig {
+  id: string;
+  schedule: string;
+  task: string;
+  enabled: boolean;
+  oneShot?: boolean;
+}
+
+interface SchedulerOpts {
+  broadcastBloby: (type: string, data: any) => void;
+  workerApi: (path: string, method?: string, body?: any) => Promise<any>;
+  restartBackend: () => void;
+  getModel: () => string;
+}
+
+// State
+let lastPulseTime = 0;
+const lastCronRuns = new Map<string, number>();
+let intervalHandle: ReturnType<typeof setInterval> | null = null;
+let schedulerOpts: SchedulerOpts | null = null;
+
+function readPulseConfig(): PulseConfig {
+  try {
+    const raw = fs.readFileSync(PULSE_FILE, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return {
+      enabled: !!parsed.enabled,
+      intervalMinutes: parsed.intervalMinutes || 30,
+      quietHours: parsed.quietHours || { start: '23:00', end: '07:00' },
+    };
+  } catch {
+    return { enabled: false, intervalMinutes: 30, quietHours: { start: '23:00', end: '07:00' } };
+  }
+}
+
+function readCronsConfig(): CronConfig[] {
+  try {
+    const raw = fs.readFileSync(CRONS_FILE, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Write crons back to disk (for oneShot cleanup) */
+function writeCronsConfig(crons: CronConfig[]) {
+  try {
+    fs.writeFileSync(CRONS_FILE, JSON.stringify(crons, null, 2) + '\n', 'utf-8');
+  } catch (err: any) {
+    log.warn(`[scheduler] Failed to write CRONS.json: ${err.message}`);
+  }
+}
+
+function isInQuietHours(quietHours: { start: string; end: string }): boolean {
+  const now = new Date();
+  const [startH, startM] = quietHours.start.split(':').map(Number);
+  const [endH, endM] = quietHours.end.split(':').map(Number);
+  const currentMinutes = now.getHours() * 60 + now.getMinutes();
+  const startMinutes = startH * 60 + startM;
+  const endMinutes = endH * 60 + endM;
+
+  if (startMinutes <= endMinutes) {
+    return currentMinutes >= startMinutes && currentMinutes < endMinutes;
+  } else {
+    return currentMinutes >= startMinutes || currentMinutes < endMinutes;
+  }
+}
+
+/** Check if a cron schedule has no future occurrences (expired one-shot) */
+function cronIsExpired(schedule: string): boolean {
+  try {
+    const interval = CronExpressionParser.parse(schedule);
+    interval.next(); // throws if no future occurrence
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+function cronMatchesNow(schedule: string): boolean {
+  try {
+    const interval = CronExpressionParser.parse(schedule);
+    const prev = interval.prev().toDate();
+    const now = new Date();
+    return (
+      prev.getFullYear() === now.getFullYear() &&
+      prev.getMonth() === now.getMonth() &&
+      prev.getDate() === now.getDate() &&
+      prev.getHours() === now.getHours() &&
+      prev.getMinutes() === now.getMinutes()
+    );
+  } catch {
+    return false;
+  }
+}
+
+function triggerAgent(prompt: string, label: string, onComplete?: () => void) {
+  if (!schedulerOpts) return;
+  const { broadcastBloby, workerApi, restartBackend, getModel } = schedulerOpts;
+  const timestamp = Date.now();
+  const convId = label.startsWith('pulse') ? `pulse-${timestamp}` : `cron-${label}-${timestamp}`;
+  const model = getModel();
+
+  log.info(`[scheduler] ${label} triggered — starting agent query`);
+
+  (async () => {
+    // Use the user's current conversation (or create one)
+    let dbConvId: string | undefined;
+    try {
+      const ctx = await workerApi('/api/context/current');
+      if (ctx.conversationId) {
+        dbConvId = ctx.conversationId;
+      } else {
+        const conv = await workerApi('/api/conversations', 'POST', {
+          title: `Chat`,
+          model,
+        });
+        dbConvId = conv.id;
+        await workerApi('/api/context/set', 'POST', { conversationId: dbConvId });
+      }
+    } catch (err: any) {
+      log.warn(`[scheduler] Failed to get/create conversation for ${label}: ${err.message}`);
+    }
+
+    // Fetch bot name for push notification title
+    let botName = 'Bloby';
+    try {
+      const status = await workerApi('/api/onboard/status');
+      if (status.agentName) botName = status.agentName;
+    } catch {}
+
+    let fullResponse = '';
+
+    startBlobyAgentQuery(convId, prompt, model, (type, eventData) => {
+      if (type === 'bot:response') {
+        fullResponse = eventData.content || '';
+      }
+
+      if (type === 'bot:done') {
+        // Extract <Message> blocks after agent turn completes
+        if (fullResponse) {
+          const messageRegex = /<Message(?:\s+([^>]*))?>(([\s\S]*?))<\/Message>/g;
+          let match;
+          while ((match = messageRegex.exec(fullResponse)) !== null) {
+            const attrs = match[1] || '';
+            const messageContent = match[2].trim();
+            const titleMatch = attrs.match(/title="([^"]*)"/);
+
+            log.info(`[scheduler] Agent message: ${messageContent.slice(0, 80)}...`);
+
+            const msgTimestamp = new Date().toISOString();
+
+            // Save to the user's conversation in DB
+            if (dbConvId) {
+              workerApi(`/api/conversations/${dbConvId}/messages`, 'POST', {
+                role: 'assistant',
+                content: messageContent,
+                meta: { model },
+              }).catch((err: any) => {
+                log.warn(`[scheduler] DB persist error: ${err.message}`);
+              });
+            }
+
+            // Broadcast as a regular message to all connected clients
+            broadcastBloby('chat:sync', {
+              conversationId: dbConvId,
+              message: { role: 'assistant', content: messageContent, timestamp: msgTimestamp },
+            });
+
+            // Send push notification for closed tabs / locked devices
+            workerApi('/api/push/send', 'POST', {
+              title: titleMatch?.[1] || botName,
+              body: messageContent.slice(0, 200),
+              tag: `bloby-${label}`,
+              url: '/',
+            }).then((r: any) => {
+              log.info(`[scheduler] Push sent: ${r.sent}/${r.total}`);
+            }).catch((err: any) => {
+              log.warn(`[scheduler] Push send failed: ${err.message}`);
+            });
+          }
+        }
+
+        log.info(`[scheduler] ${label} agent query complete`);
+        if (eventData.usedFileTools) {
+          log.info(`[scheduler] File tools used — restarting backend`);
+          restartBackend();
+        }
+        onComplete?.();
+      }
+
+      if (type === 'bot:error') {
+        log.warn(`[scheduler] ${label} agent error: ${eventData.error}`);
+      }
+    });
+  })();
+}
+
+function tick() {
+  const now = Date.now();
+
+  // ── Pulse check ──
+  const pulse = readPulseConfig();
+  if (pulse.enabled && !isInQuietHours(pulse.quietHours)) {
+    const elapsed = now - lastPulseTime;
+    const intervalMs = pulse.intervalMinutes * 60 * 1000;
+    if (elapsed >= intervalMs) {
+      lastPulseTime = now;
+      triggerAgent('<PULSE/>', 'pulse');
+    }
+  }
+
+  // ── Cron check ──
+  const crons = readCronsConfig();
+
+  for (const cron of crons) {
+    if (!cron.enabled || !cron.id || !cron.schedule) continue;
+
+    const matches = cronMatchesNow(cron.schedule);
+    const nowDate = new Date();
+    log.info(`[scheduler] Cron "${cron.id}" schedule="${cron.schedule}" matches=${matches} now=${nowDate.getHours()}:${String(nowDate.getMinutes()).padStart(2,'0')}`);
+
+    if (matches) {
+      const lastRun = lastCronRuns.get(cron.id) || 0;
+      const oneMinuteAgo = now - 60_000;
+      if (lastRun < oneMinuteAgo) {
+        lastCronRuns.set(cron.id, now);
+        // One-shots: defer removal until agent completes (so agent can still read CRONS.json)
+        const onComplete = cron.oneShot ? () => {
+          log.info(`[scheduler] Removing fired one-shot cron: ${cron.id}`);
+          const fresh = readCronsConfig().filter((c) => c.id !== cron.id);
+          writeCronsConfig(fresh);
+          // Also remove the task file if it exists
+          try {
+            fs.unlinkSync(path.join(WORKSPACE_DIR, 'tasks', `${cron.id}.md`));
+          } catch {}
+        } : undefined;
+        // Inject task file content if tasks/{id}.md exists
+        let cronPrompt = `<CRON>${cron.id}</CRON>`;
+        try {
+          const taskFile = path.join(WORKSPACE_DIR, 'tasks', `${cron.id}.md`);
+          const taskContent = fs.readFileSync(taskFile, 'utf-8').trim();
+          if (taskContent) {
+            cronPrompt += `\n<CRON_TASK_DETAIL>\n${taskContent}\n</CRON_TASK_DETAIL>`;
+          }
+        } catch {}
+        triggerAgent(cronPrompt, cron.id, onComplete);
+      }
+    }
+  }
+
+  // ── Cleanup: remove expired one-shots (schedule in the past, never gonna fire) ──
+  if (crons.length > 0) {
+    const cleaned = crons.filter((c) => {
+      if (c.oneShot && cronIsExpired(c.schedule)) {
+        log.info(`[scheduler] cronIsExpired=true for "${c.id}" schedule="${c.schedule}"`);
+        log.info(`[scheduler] Removing expired one-shot cron: ${c.id}`);
+        try {
+          fs.unlinkSync(path.join(WORKSPACE_DIR, 'tasks', `${c.id}.md`));
+        } catch {}
+        return false;
+      }
+      return true;
+    });
+
+    if (cleaned.length !== crons.length) {
+      writeCronsConfig(cleaned);
+    }
+  }
+}
+
+export function startScheduler(opts: SchedulerOpts) {
+  schedulerOpts = opts;
+  lastPulseTime = Date.now();
+  intervalHandle = setInterval(tick, 60_000);
+  log.info('[scheduler] Started — checking every 60s');
+}
+
+export function stopScheduler() {
+  if (intervalHandle) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+  }
+  schedulerOpts = null;
+  log.info('[scheduler] Stopped');
+}

package/supervisor/tunnel.ts

@@ -0,0 +1,156 @@
+import { spawn, execSync, type ChildProcess } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { paths } from '../shared/paths.js';
+import { log } from '../shared/logger.js';
+
+let proc: ChildProcess | null = null;
+
+const MIN_CF_SIZE = 10 * 1024 * 1024; // 10 MB — valid cloudflared is ~30-50 MB
+
+function findBinary(): string | null {
+  // Check system-wide install
+  const which = process.platform === 'win32' ? 'where cloudflared' : 'which cloudflared';
+  try { execSync(which, { stdio: 'ignore' }); return 'cloudflared'; } catch {}
+
+  // Check local install (validate by file size, never execute — avoids Windows popup)
+  if (!fs.existsSync(paths.cloudflared)) return null;
+  const size = fs.statSync(paths.cloudflared).size;
+  if (size < MIN_CF_SIZE) {
+    fs.unlinkSync(paths.cloudflared);
+    return null;
+  }
+  return paths.cloudflared;
+}
+
+export async function installCloudflared(): Promise<string> {
+  const existing = findBinary();
+  if (existing) return existing;
+
+  const dir = path.dirname(paths.cloudflared);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const p = os.platform();
+  const a = p === 'win32'
+    ? (process.env.PROCESSOR_ARCHITECTURE || os.arch()).toLowerCase()
+    : os.arch();
+  const base = 'https://github.com/cloudflare/cloudflared/releases/latest/download';
+
+  let url: string;
+  if (p === 'win32') url = `${base}/cloudflared-windows-${a.includes('arm') ? 'arm64' : 'amd64'}.exe`;
+  else if (p === 'darwin') url = `${base}/cloudflared-darwin-${a === 'arm64' ? 'arm64' : 'amd64'}.tgz`;
+  else if (a === 'arm64' || a === 'aarch64') url = `${base}/cloudflared-linux-arm64`;
+  else if (a.startsWith('arm')) url = `${base}/cloudflared-linux-arm`;
+  else url = `${base}/cloudflared-linux-amd64`;
+
+  log.info('Installing cloudflared...');
+  if (p === 'win32') {
+    execSync(`curl.exe -fsSL -o "${paths.cloudflared}" "${url}"`, { stdio: 'ignore' });
+  } else if (url.endsWith('.tgz')) {
+    execSync(`curl -fsSL "${url}" | tar xz -C "${dir}"`, { stdio: 'ignore' });
+  } else {
+    execSync(`curl -fsSL -o "${paths.cloudflared}" "${url}"`, { stdio: 'ignore' });
+  }
+  if (p !== 'win32') fs.chmodSync(paths.cloudflared, 0o755);
+  log.ok('cloudflared installed');
+  return paths.cloudflared;
+}
+
+export function startTunnel(port: number): Promise<string> {
+  return new Promise(async (resolve, reject) => {
+    const bin = await installCloudflared();
+    const timeout = setTimeout(() => reject(new Error('Tunnel timeout')), 30_000);
+
+    proc = spawn(bin, ['tunnel', '--url', `http://localhost:${port}`, '--no-autoupdate'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+
+    let buf = '';
+    const onData = (d: Buffer) => {
+      buf += d.toString();
+      const m = buf.match(/https:\/\/[^\s]+\.trycloudflare\.com/);
+      if (m) { clearTimeout(timeout); resolve(m[0]); }
+    };
+
+    proc.stdout?.on('data', onData);
+    proc.stderr?.on('data', onData);
+    proc.on('error', (e) => { clearTimeout(timeout); reject(e); });
+    proc.on('exit', (code) => { if (code !== 0) { clearTimeout(timeout); reject(new Error(`cloudflared exited with code ${code}`)); } });
+  });
+}
+
+export async function startNamedTunnel(configPath: string, name: string): Promise<void> {
+  const bin = await installCloudflared();
+
+  proc = spawn(bin, ['tunnel', '--config', configPath, 'run', name], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+
+  proc.stdout?.on('data', (d: Buffer) => log.info(`[named-tunnel] ${d.toString().trim()}`));
+  proc.stderr?.on('data', (d: Buffer) => log.info(`[named-tunnel] ${d.toString().trim()}`));
+  proc.on('error', (e) => log.error(`Named tunnel error: ${e.message}`));
+  proc.on('exit', (code) => { if (code !== 0) log.warn(`Named tunnel exited with code ${code}`); });
+}
+
+export async function startTunnelForMode(
+  mode: 'off' | 'quick' | 'named',
+  port: number,
+  configPath?: string,
+  name?: string,
+): Promise<string | null> {
+  if (mode === 'off') return null;
+  if (mode === 'named') {
+    if (!configPath || !name) throw new Error('Named tunnel requires configPath and name');
+    await startNamedTunnel(configPath, name);
+    return null; // URL is known from config.tunnel.domain
+  }
+  // mode === 'quick'
+  return startTunnel(port);
+}
+
+export function stopTunnel(): void {
+  proc?.kill();
+  proc = null;
+}
+
+/** Check if the cloudflared child process is still running */
+export function isTunnelProcessAlive(): boolean {
+  return proc !== null && proc.exitCode === null && proc.signalCode === null;
+}
+
+export async function isTunnelAlive(url: string, localPort?: number): Promise<boolean> {
+  // 1. Process check — if cloudflared exited, tunnel is definitely dead
+  if (!isTunnelProcessAlive()) return false;
+
+  // 2. Local reachability check — confirm the local server is still responding.
+  //    We probe localhost directly instead of the tunnel URL because on macOS
+  //    the server can't reach itself through the Cloudflare tunnel (DNS/firewall).
+  //    If localhost responds and cloudflared is running, the tunnel is alive.
+  if (localPort) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${localPort}/api/health?_cb=${Date.now()}`, {
+        signal: AbortSignal.timeout(3000),
+      });
+      if (res.ok) return true;
+    } catch {}
+    // Local server not responding — but cloudflared is alive, so tunnel is still up.
+    // The worker may be restarting. Don't kill the tunnel for a local issue.
+    return true;
+  }
+
+  // No local port provided — process alive is enough
+  return true;
+}
+
+export async function restartTunnel(port: number): Promise<string> {
+  stopTunnel();
+  return startTunnel(port);
+}
+
+export async function restartNamedTunnel(configPath: string, name: string): Promise<void> {
+  stopTunnel();
+  await startNamedTunnel(configPath, name);
+}

package/supervisor/vite-dev.ts

@@ -0,0 +1,72 @@
+import { createServer as createViteServer, type ViteDevServer } from 'vite';
+import type http from 'http';
+import path from 'path';
+import { PKG_DIR } from '../shared/paths.js';
+import { log } from '../shared/logger.js';
+
+let dashboardVite: ViteDevServer | null = null;
+
+export async function startViteDevServers(supervisorPort: number, hmrServer: http.Server): Promise<{ dashboard: number }> {
+  const ports = {
+    dashboard: supervisorPort + 2,
+  };
+
+  console.log(`[vite-dev] Starting dashboard Vite dev server on :${ports.dashboard}`);
+  console.log(`[vite-dev] HMR attached to supervisor server`);
+  console.log(`[vite-dev] PKG_DIR = ${PKG_DIR}`);
+
+  try {
+    dashboardVite = await createViteServer({
+      configFile: path.join(PKG_DIR, 'vite.config.ts'),
+      server: {
+        port: ports.dashboard,
+        host: '127.0.0.1',
+        strictPort: true,
+        allowedHosts: true,
+        // HMR WebSocket is attached directly to the supervisor's HTTP server.
+        // No clientPort — the browser connects on the same origin the page is served from,
+        // so it works both locally (localhost:3000) and through the relay (riven.bloby.bot:443).
+        hmr: { server: hmrServer },
+      },
+      logLevel: 'info',
+    });
+    await dashboardVite.listen();
+    console.log(`[vite-dev] ✓ Dashboard Vite ready on :${ports.dashboard}`);
+  } catch (err) {
+    console.error('[vite-dev] ✗ Dashboard Vite failed:', err);
+    throw err;
+  }
+
+  log.ok(`Vite HMR active — dashboard :${ports.dashboard}`);
+
+  // Warm up: fetch the dashboard entry to pre-transform modules
+  fetch(`http://127.0.0.1:${ports.dashboard}/`).then(r => r.text()).then(async (html) => {
+    const scriptRe = /src="([^"]+\.tsx)"/g;
+    let m;
+    while ((m = scriptRe.exec(html)) !== null) {
+      const url = `http://127.0.0.1:${ports.dashboard}${m[1].startsWith('/') ? '' : '/'}${m[1]}`;
+      await fetch(url).then(r => r.text()).catch(() => {});
+    }
+    console.log('__VITE_WARM__');
+  }).catch(() => {
+    console.log('__VITE_WARM__');
+  });
+
+  return ports;
+}
+
+/** Tell connected browsers to full-reload via Vite's HMR WebSocket */
+export function reloadDashboard(): void {
+  if (!dashboardVite) return;
+  console.log('[vite-dev] Sending full-reload to dashboard clients');
+  dashboardVite.hot.send({ type: 'full-reload', path: '*' });
+}
+
+export async function stopViteDevServers(): Promise<void> {
+  console.log('[vite-dev] Stopping Vite dev servers...');
+  if (dashboardVite) {
+    await dashboardVite.close();
+    dashboardVite = null;
+    console.log('[vite-dev] Dashboard Vite stopped');
+  }
+}