@owloops/browserbird 1.0.2 → 1.0.3

package/src/cron/parse.ts

@@ -1,146 +0,0 @@
-/** @fileoverview Cron expression parser. Standard 5-field syntax + common macros. */
-
-import { isWithinTimeRange } from '../core/utils.ts';
-
-const MACROS: Record<string, string> = {
-  '@yearly': '0 0 1 1 *',
-  '@annually': '0 0 1 1 *',
-  '@monthly': '0 0 1 * *',
-  '@weekly': '0 0 * * 0',
-  '@daily': '0 0 * * *',
-  '@midnight': '0 0 * * *',
-  '@hourly': '0 * * * *',
-};
-
-export interface CronSchedule {
-  minutes: Set<number>;
-  hours: Set<number>;
-  daysOfMonth: Set<number>;
-  months: Set<number>;
-  daysOfWeek: Set<number>;
-}
-
-/**
- * Parses a single cron field (e.g. `"*"`, `"1,5,10"`, `"9-17"`, `"* /15"`).
- * Returns a Set of integer values that match.
- */
-function parseField(field: string, min: number, max: number): Set<number> {
-  const values = new Set<number>();
-
-  for (const part of field.split(',')) {
-    const stepParts = part.split('/');
-    const range = stepParts[0]!;
-    const step = stepParts[1] != null ? parseInt(stepParts[1], 10) : 1;
-
-    let start: number;
-    let end: number;
-
-    if (range === '*') {
-      start = min;
-      end = max;
-    } else if (range.includes('-')) {
-      const [lo, hi] = range.split('-');
-      start = parseInt(lo!, 10);
-      end = parseInt(hi!, 10);
-    } else {
-      start = parseInt(range, 10);
-      end = start;
-    }
-
-    for (let i = start; i <= end; i += step) {
-      values.add(i);
-    }
-  }
-
-  return values;
-}
-
-/** Parses a cron expression string into a CronSchedule. */
-export function parseCron(expression: string): CronSchedule {
-  const expanded = MACROS[expression.toLowerCase()] ?? expression;
-  const fields = expanded.trim().split(/\s+/);
-
-  if (fields.length !== 5) {
-    throw new Error(`invalid cron expression: expected 5 fields, got ${fields.length}`);
-  }
-
-  return {
-    minutes: parseField(fields[0]!, 0, 59),
-    hours: parseField(fields[1]!, 0, 23),
-    daysOfMonth: parseField(fields[2]!, 1, 31),
-    months: parseField(fields[3]!, 1, 12),
-    daysOfWeek: parseField(fields[4]!, 0, 6),
-  };
-}
-
-/**
- * Returns true if the current time falls within the active hours window.
- * When both start and end are null, the bird is always active.
- * Hours are evaluated in the bird's configured timezone.
- */
-export function isWithinActiveHours(
-  start: string | null,
-  end: string | null,
-  date: Date,
-  timezone?: string,
-): boolean {
-  if (start == null && end == null) return true;
-  return isWithinTimeRange(start ?? '00:00', end ?? '24:00', date, timezone || 'UTC');
-}
-
-/**
- * Returns the next Date (after `after`) that matches the cron schedule,
- * or null if no match is found within the search window (default: 366 days).
- */
-export function nextCronMatch(
-  schedule: CronSchedule,
-  after: Date,
-  timezone?: string,
-  maxMinutes = 527_040,
-): Date | null {
-  const candidate = new Date(after.getTime());
-  candidate.setSeconds(0, 0);
-  candidate.setTime(candidate.getTime() + 60_000);
-
-  for (let i = 0; i < maxMinutes; i++) {
-    if (matchesCron(schedule, candidate, timezone)) return candidate;
-    candidate.setTime(candidate.getTime() + 60_000);
-  }
-  return null;
-}
-
-/** Returns true if the given Date matches the cron schedule in the specified timezone. */
-export function matchesCron(schedule: CronSchedule, date: Date, timezone?: string): boolean {
-  const tz = timezone || 'UTC';
-  const parts = new Intl.DateTimeFormat('en-US', {
-    timeZone: tz,
-    hour: 'numeric',
-    minute: 'numeric',
-    day: 'numeric',
-    month: 'numeric',
-    weekday: 'short',
-    hour12: false,
-  }).formatToParts(date);
-
-  const get = (type: Intl.DateTimeFormatPartTypes): number =>
-    Number(parts.find((p) => p.type === type)?.value ?? 0);
-
-  const weekdayStr = parts.find((p) => p.type === 'weekday')?.value ?? '';
-  const weekdayMap: Record<string, number> = {
-    Sun: 0,
-    Mon: 1,
-    Tue: 2,
-    Wed: 3,
-    Thu: 4,
-    Fri: 5,
-    Sat: 6,
-  };
-
-  return (
-    schedule.minutes.has(get('minute')) &&
-    schedule.hours.has(get('hour')) &&
-    schedule.daysOfMonth.has(get('day')) &&
-    schedule.months.has(get('month')) &&
-    schedule.daysOfWeek.has(weekdayMap[weekdayStr] ?? 0)
-  );
-}

package/src/cron/scheduler.ts

@@ -1,242 +0,0 @@
-/** @fileoverview Cron scheduler: evaluates cron jobs every 60s and enqueues due jobs. */
-
-import type { Config } from '../core/types.ts';
-import type { Block } from '../channel/blocks.ts';
-import type { CronSchedule } from './parse.ts';
-import type { StreamEventCompletion } from '../provider/stream.ts';
-
-import { logger } from '../core/logger.ts';
-import { shortUid } from '../core/uid.ts';
-import {
-  SYSTEM_CRON_PREFIX,
-  getEnabledCronJobs,
-  updateCronJobStatus,
-  setCronJobEnabled,
-  ensureSystemCronJob,
-  hasPendingCronJob,
-  deleteOldMessages,
-  deleteOldCronRuns,
-  deleteOldJobs,
-  deleteOldLogs,
-  optimizeDatabase,
-} from '../db/index.ts';
-import { expireStaleSessions } from '../provider/session.ts';
-import { registerHandler, enqueue } from '../jobs.ts';
-import { broadcastSSE } from '../server/index.ts';
-import { spawnProvider } from '../provider/spawn.ts';
-import { redact } from '../core/redact.ts';
-import { parseCron, matchesCron, isWithinActiveHours } from './parse.ts';
-import { sessionCompleteBlocks, sessionErrorBlocks } from '../channel/blocks.ts';
-
-const TICK_INTERVAL_MS = 60_000;
-const MAX_SCHEDULE_ERRORS = 3;
-
-interface CronRunPayload {
-  cronJobUid: string;
-  prompt: string;
-  channelId: string | null;
-  agentId: string;
-}
-
-interface SystemCronPayload {
-  cronJobUid: string;
-  cronName: string;
-}
-
-export interface SchedulerDeps {
-  postToSlack?: (channel: string, text: string, opts?: { blocks?: Block[] }) => Promise<void>;
-}
-
-type SystemCronHandler = () => string | void;
-
-const systemHandlers = new Map<string, SystemCronHandler>();
-
-function registerSystemCronJobs(config: Config, retentionDays: number): void {
-  const cleanupName = `${SYSTEM_CRON_PREFIX}db_cleanup__`;
-  const optimizeName = `${SYSTEM_CRON_PREFIX}db_optimize__`;
-
-  systemHandlers.set(cleanupName, () => {
-    expireStaleSessions(config.sessions.ttlHours);
-    const msgs = deleteOldMessages(retentionDays);
-    const runs = deleteOldCronRuns(retentionDays);
-    const jobs = deleteOldJobs(retentionDays);
-    const logs = deleteOldLogs(retentionDays);
-    if (msgs > 0 || runs > 0 || jobs > 0 || logs > 0) {
-      const summary = `${msgs} messages, ${runs} flight logs, ${jobs} jobs, ${logs} logs older than ${retentionDays}d`;
-      logger.info(`system cleanup: ${summary}`);
-      return summary;
-    }
-    return 'nothing to clean';
-  });
-
-  systemHandlers.set(optimizeName, () => {
-    optimizeDatabase();
-    logger.debug('system optimize: database optimized');
-    return 'database optimized';
-  });
-
-  ensureSystemCronJob(cleanupName, '0 */6 * * *', 'Database cleanup');
-  ensureSystemCronJob(optimizeName, '0 3 * * *', 'Database optimization');
-  logger.info('system birds registered');
-}
-
-/** Registers the cron_run job handler and starts the scheduler tick loop. */
-export function startScheduler(config: Config, signal: AbortSignal, deps?: SchedulerDeps): void {
-  registerSystemCronJobs(config, config.database.retentionDays);
-
-  registerHandler('cron_run', async (raw) => {
-    const payload = raw as CronRunPayload;
-    const agent = config.agents.find((a) => a.id === payload.agentId);
-    if (!agent) {
-      throw new Error(`agent "${payload.agentId}" not found`);
-    }
-
-    const { events } = spawnProvider(
-      agent.provider,
-      { message: payload.prompt, agent, mcpConfigPath: config.browser.mcpConfigPath },
-      signal,
-    );
-
-    let result = '';
-    let completion: StreamEventCompletion | undefined;
-    for await (const event of events) {
-      if (event.type === 'text_delta') {
-        result += redact(event.delta);
-      } else if (event.type === 'completion') {
-        completion = event;
-      } else if (event.type === 'rate_limit') {
-        logger.debug(
-          `bird ${shortUid(payload.cronJobUid)} rate limit window resets ${new Date(event.resetsAt * 1000).toISOString()}`,
-        );
-      } else if (event.type === 'error') {
-        const safeError = redact(event.error);
-        if (payload.channelId && deps?.postToSlack) {
-          const blocks = sessionErrorBlocks(safeError, { birdName: agent.name });
-          await deps.postToSlack(payload.channelId, `Bird failed: ${safeError}`, { blocks });
-        }
-        throw new Error(safeError);
-      }
-    }
-
-    if (!result) {
-      logger.info(`bird ${shortUid(payload.cronJobUid)} completed (no output)`);
-      return 'completed (no output)';
-    }
-
-    if (payload.channelId && deps?.postToSlack) {
-      if (completion) {
-        const summary = result.length > 2800 ? result.slice(0, 2800) + '...' : result;
-        const blocks = sessionCompleteBlocks(completion, summary, agent.name);
-        const fallback = `Bird ${agent.name} completed: ${completion.numTurns} turns`;
-        await deps.postToSlack(payload.channelId, fallback, { blocks });
-      } else {
-        await deps.postToSlack(payload.channelId, result);
-      }
-      logger.info(`bird ${shortUid(payload.cronJobUid)} result posted to ${payload.channelId}`);
-    } else {
-      logger.info(`bird ${shortUid(payload.cronJobUid)} completed (${result.length} chars)`);
-    }
-
-    return result;
-  });
-
-  registerHandler('system_cron_run', (raw) => {
-    const payload = raw as SystemCronPayload;
-    const handler = systemHandlers.get(payload.cronName);
-    if (!handler) {
-      throw new Error(`no system handler for "${payload.cronName}"`);
-    }
-    const result = handler();
-    logger.info(`${payload.cronName}: ${result ?? 'done'}`);
-    return result ?? undefined;
-  });
-
-  const scheduleCache = new Map<string, CronSchedule>();
-  const scheduleErrors = new Map<string, number>();
-
-  const tick = () => {
-    if (signal.aborted) return;
-
-    const now = new Date();
-    const jobs = getEnabledCronJobs();
-
-    for (const job of jobs) {
-      let schedule = scheduleCache.get(job.uid);
-      if (!schedule) {
-        try {
-          schedule = parseCron(job.schedule);
-          scheduleCache.set(job.uid, schedule);
-          scheduleErrors.delete(job.uid);
-        } catch {
-          const count = (scheduleErrors.get(job.uid) ?? 0) + 1;
-          scheduleErrors.set(job.uid, count);
-          if (count >= MAX_SCHEDULE_ERRORS) {
-            logger.warn(
-              `bird ${shortUid(job.uid)}: invalid expression "${job.schedule}" (${count} consecutive failures), disabling`,
-            );
-            setCronJobEnabled(job.uid, false);
-            scheduleErrors.delete(job.uid);
-          } else {
-            logger.warn(
-              `bird ${shortUid(job.uid)}: invalid expression "${job.schedule}" (attempt ${count}/${MAX_SCHEDULE_ERRORS})`,
-            );
-          }
-          continue;
-        }
-      }
-
-      if (!matchesCron(schedule, now, job.timezone)) continue;
-
-      if (!isWithinActiveHours(job.active_hours_start, job.active_hours_end, now, job.timezone)) {
-        logger.debug(`bird ${shortUid(job.uid)} skipped: outside active hours`);
-        continue;
-      }
-
-      if (hasPendingCronJob(job.uid)) {
-        logger.debug(`bird ${shortUid(job.uid)} skipped: previous run still pending or running`);
-        continue;
-      }
-
-      const isSystem = job.name.startsWith(SYSTEM_CRON_PREFIX);
-
-      logger.info(`bird ${shortUid(job.uid)} triggered: "${job.schedule}"`);
-
-      if (isSystem) {
-        enqueue(
-          'system_cron_run',
-          { cronJobUid: job.uid, cronName: job.name } satisfies SystemCronPayload,
-          { maxAttempts: 3, timeout: 300, cronJobUid: job.uid },
-        );
-      } else {
-        enqueue(
-          'cron_run',
-          {
-            cronJobUid: job.uid,
-            prompt: job.prompt,
-            channelId: job.target_channel_id,
-            agentId: job.agent_id,
-          } satisfies CronRunPayload,
-          {
-            maxAttempts: config.birds.maxAttempts,
-            timeout: 600,
-            cronJobUid: job.uid,
-          },
-        );
-      }
-
-      updateCronJobStatus(job.uid, 'triggered', job.failure_count);
-      broadcastSSE('invalidate', { resource: 'birds', cronJobUid: job.uid });
-    }
-  };
-
-  tick();
-  const timer = setInterval(tick, TICK_INTERVAL_MS);
-
-  signal.addEventListener('abort', () => {
-    clearInterval(timer);
-    scheduleCache.clear();
-    scheduleErrors.clear();
-  });
-
-  logger.info('bird scheduler started (60s tick)');
-}

package/src/daemon.ts

@@ -1,169 +0,0 @@
-/** @fileoverview Main orchestrator process: starts all subsystems and handles graceful shutdown. */
-
-import { logger } from './core/logger.ts';
-import { BANNER } from './cli/banner.ts';
-import { loadConfig, loadDotEnv, hasSlackTokens } from './config.ts';
-import { openDatabase, closeDatabase, setSetting, resolveDbPath } from './db/index.ts';
-import { startWorker } from './jobs.ts';
-import { startScheduler } from './cron/scheduler.ts';
-import { createSlackChannel } from './channel/slack.ts';
-import { createWebServer } from './server/index.ts';
-import type { WebServerDeps } from './server/index.ts';
-import { startHealthChecks, getServiceHealth } from './server/health.ts';
-import type { Config } from './core/types.ts';
-import type { ChannelHandle } from './channel/types.ts';
-import { resolve } from 'node:path';
-
-const controller = new AbortController();
-
-const SHUTDOWN_TIMEOUT_MS = 5000;
-
-function setupShutdown(): void {
-  let shutting = false;
-
-  const shutdown = (signal: string) => {
-    if (shutting) {
-      logger.info(`received ${signal} again, forcing exit`);
-      process.exit(1);
-    }
-    shutting = true;
-    logger.info(`received ${signal}, shutting down...`);
-    controller.abort();
-
-    setTimeout(() => {
-      logger.warn('graceful shutdown timed out, forcing exit');
-      process.exit(1);
-    }, SHUTDOWN_TIMEOUT_MS).unref();
-  };
-
-  process.on('SIGINT', () => shutdown('SIGINT'));
-  process.on('SIGTERM', () => shutdown('SIGTERM'));
-}
-
-interface DaemonOptions {
-  flags: { verbose: boolean; config?: string; db?: string };
-}
-
-const stubDeps: WebServerDeps = {
-  slackConnected: () => false,
-  activeProcessCount: () => 0,
-  serviceHealth: () => ({ agent: { available: false }, browser: { connected: false } }),
-};
-
-export async function startDaemon(options: DaemonOptions): Promise<void> {
-  setupShutdown();
-  process.stderr.write(BANNER + '\n\n');
-
-  if (options.flags.verbose) {
-    logger.setLevel('debug');
-  }
-
-  const configPath = resolve(
-    options.flags.config ?? process.env['BROWSERBIRD_CONFIG'] ?? 'browserbird.json',
-  );
-  const envPath = resolve('.env');
-  const dbPath = resolveDbPath(options.flags.db);
-  openDatabase(dbPath);
-  startWorker(controller.signal);
-
-  loadDotEnv(envPath);
-  let currentConfig: Config = loadConfig(configPath);
-  let slackHandle: ChannelHandle | null = null;
-  let setupMode = true;
-
-  const getConfig = (): Config => currentConfig;
-  const getDeps = (): WebServerDeps => {
-    if (setupMode) return stubDeps;
-    return {
-      slackConnected: () => slackHandle?.isConnected() ?? false,
-      activeProcessCount: () => slackHandle?.activeCount() ?? 0,
-      serviceHealth: () => getServiceHealth(currentConfig),
-    };
-  };
-
-  const startFull = (config: Config) => {
-    currentConfig = config;
-    setupMode = false;
-
-    logger.info('connecting to slack...');
-    slackHandle = createSlackChannel(config, controller.signal);
-
-    logger.info('starting scheduler...');
-    startScheduler(config, controller.signal, {
-      postToSlack: (channel, text, opts) => slackHandle!.postMessage(channel, text, opts),
-    });
-
-    slackHandle.start().catch((err: unknown) => {
-      logger.error(`slack failed to start: ${err instanceof Error ? err.message : String(err)}`);
-    });
-
-    startHealthChecks(config, controller.signal);
-
-    logger.success('browserbird orchestrator started');
-    logger.info(`agents: ${config.agents.map((a) => a.id).join(', ')}`);
-    logger.info(`max concurrent sessions: ${config.sessions.maxConcurrent}`);
-    if (config.browser.enabled) {
-      logger.info(`browser mode: ${process.env['BROWSER_MODE'] ?? 'persistent'}`);
-    }
-  };
-
-  const onLaunch = async () => {
-    loadDotEnv(envPath);
-    const config = loadConfig(configPath);
-
-    if (!config.slack.botToken || !config.slack.appToken) {
-      throw new Error('Slack tokens are required to launch');
-    }
-
-    startFull(config);
-  };
-
-  const reloadConfig = (): void => {
-    loadDotEnv(envPath);
-    currentConfig = loadConfig(configPath);
-    logger.info('config reloaded');
-  };
-
-  if (hasSlackTokens(configPath)) {
-    if (!currentConfig.slack.botToken || !currentConfig.slack.appToken) {
-      throw new Error(
-        'slack tokens not resolvable (set SLACK_BOT_TOKEN/SLACK_APP_TOKEN or configure in browserbird.json)',
-      );
-    }
-
-    setSetting('onboarding_completed', 'true');
-    startFull(currentConfig);
-  } else {
-    setSetting('onboarding_completed', '');
-    logger.info('starting in setup mode (onboarding not completed)');
-  }
-
-  let webServer: Awaited<ReturnType<typeof createWebServer>> | null = null;
-  const webConfig = getConfig();
-  if (webConfig.web.enabled) {
-    logger.info(`starting web server on port ${webConfig.web.port}...`);
-    webServer = createWebServer(getConfig, controller.signal, getDeps, {
-      configPath,
-      onLaunch,
-      onConfigReload: reloadConfig,
-    });
-    await webServer.start();
-  }
-
-  if (setupMode) {
-    logger.info('waiting for onboarding to complete via web UI');
-  }
-
-  await new Promise<void>((resolvePromise) => {
-    controller.signal.addEventListener('abort', () => {
-      resolvePromise();
-    });
-  });
-
-  if (webServer) await webServer.stop();
-  if (slackHandle as ChannelHandle | null) {
-    await Promise.race([slackHandle!.stop(), new Promise<void>((r) => setTimeout(r, 3000))]);
-  }
-  closeDatabase();
-  logger.info('browserbird stopped');
-}

package/src/db/auth.ts

@@ -1,49 +0,0 @@
-/** @fileoverview User and settings persistence for the auth system. */
-
-import { getDb } from './core.ts';
-
-export interface UserRow {
-  id: number;
-  email: string;
-  password_hash: string;
-  token_key: string;
-  created_at: string;
-}
-
-export function getUserCount(): number {
-  const row = getDb().prepare('SELECT COUNT(*) as count FROM users').get() as unknown as {
-    count: number;
-  };
-  return row.count;
-}
-
-export function getUserByEmail(email: string): UserRow | undefined {
-  return getDb().prepare('SELECT * FROM users WHERE email = ?').get(email) as unknown as
-    | UserRow
-    | undefined;
-}
-
-export function getUserById(id: number): UserRow | undefined {
-  return getDb().prepare('SELECT * FROM users WHERE id = ?').get(id) as unknown as
-    | UserRow
-    | undefined;
-}
-
-export function createUser(email: string, passwordHash: string, tokenKey: string): UserRow {
-  getDb()
-    .prepare('INSERT INTO users (email, password_hash, token_key) VALUES (?, ?, ?)')
-    .run(email, passwordHash, tokenKey);
-
-  return getUserByEmail(email)!;
-}
-
-export function getSetting(key: string): string | undefined {
-  const row = getDb().prepare('SELECT value FROM settings WHERE key = ?').get(key) as unknown as
-    | { value: string }
-    | undefined;
-  return row?.value;
-}
-
-export function setSetting(key: string, value: string): void {
-  getDb().prepare('INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)').run(key, value);
-}