@owloops/browserbird 1.0.1 → 1.0.3

package/src/channel/commands.ts

@@ -1,216 +0,0 @@
-/** @fileoverview Slash command handler for `/bird` commands in Slack. */
-
-import type { WebClient } from '@slack/web-api';
-import type { Config } from '../core/types.ts';
-import type { ChannelClient } from './types.ts';
-
-import * as db from '../db/index.ts';
-import { enqueue } from '../jobs.ts';
-import { logger } from '../core/logger.ts';
-import {
-  birdListBlocks,
-  birdFlyBlocks,
-  birdLogsBlocks,
-  birdCreateModal,
-  statusBlocks,
-} from './blocks.ts';
-
-export interface SlashCommandBody {
-  command: string;
-  text: string;
-  trigger_id: string;
-  user_id: string;
-  channel_id: string;
-  team_id: string;
-}
-
-export interface StatusProvider {
-  slackConnected: () => boolean;
-  activeCount: () => number;
-}
-
-const startTime = Date.now();
-
-function formatUptime(): string {
-  const ms = Date.now() - startTime;
-  const hours = Math.floor(ms / 3_600_000);
-  const minutes = Math.floor((ms % 3_600_000) / 60_000);
-  if (hours === 0) return `${minutes}m`;
-  return `${hours}h ${minutes}m`;
-}
-
-export async function handleSlashCommand(
-  body: SlashCommandBody,
-  webClient: WebClient,
-  channelClient: ChannelClient,
-  config: Config,
-  status: StatusProvider,
-): Promise<void> {
-  const parts = body.text.trim().split(/\s+/);
-  const subcommand = parts[0] ?? 'help';
-
-  async function say(message: { text: string; blocks?: unknown[] }): Promise<void> {
-    await webClient.chat.postMessage({
-      channel: body.channel_id,
-      text: message.text,
-      ...(message.blocks ? { blocks: message.blocks } : {}),
-    });
-  }
-
-  function findBird(nameOrUid: string): db.CronJobRow | undefined {
-    const byUid = db.resolveByUid<db.CronJobRow>('cron_jobs', nameOrUid);
-    if (byUid && 'row' in byUid) return byUid.row;
-    const result = db.listCronJobs(1, 100, false);
-    return result.items.find((b) => b.name === nameOrUid);
-  }
-
-  switch (subcommand) {
-    case 'list': {
-      const result = db.listCronJobs(1, 20, false);
-      const birds = result.items.map((b) => ({
-        uid: b.uid,
-        name: b.name,
-        schedule: b.schedule,
-        enabled: b.enabled === 1,
-        lastStatus: b.last_status,
-        agentId: b.agent_id,
-      }));
-      const blocks = birdListBlocks(birds);
-      await say({
-        text: `${birds.length} bird${birds.length === 1 ? '' : 's'} configured`,
-        blocks,
-      });
-      break;
-    }
-
-    case 'fly': {
-      const birdName = parts.slice(1).join(' ');
-      if (!birdName) {
-        await say({ text: 'Usage: `/bird fly <name or id>`' });
-        return;
-      }
-
-      const bird = findBird(birdName);
-      if (!bird) {
-        await say({ text: `Bird not found: \`${birdName}\`` });
-        return;
-      }
-
-      enqueue(
-        'cron_run',
-        {
-          cronJobUid: bird.uid,
-          prompt: bird.prompt,
-          channelId: bird.target_channel_id,
-          agentId: bird.agent_id,
-        },
-        { maxAttempts: config.birds.maxAttempts, timeout: 600, cronJobUid: bird.uid },
-      );
-
-      const blocks = birdFlyBlocks(bird.name, body.user_id);
-      await say({ text: `${bird.name} is taking flight...`, blocks });
-      logger.info(`/bird fly: ${bird.name} triggered by ${body.user_id}`);
-      break;
-    }
-
-    case 'enable':
-    case 'disable': {
-      const birdName = parts.slice(1).join(' ');
-      if (!birdName) {
-        await say({ text: `Usage: \`/bird ${subcommand} <name or id>\`` });
-        return;
-      }
-
-      const bird = findBird(birdName);
-      if (!bird) {
-        await say({ text: `Bird not found: \`${birdName}\`` });
-        return;
-      }
-
-      const enabling = subcommand === 'enable';
-      const alreadyInState = (bird.enabled === 1) === enabling;
-      if (alreadyInState) {
-        await say({ text: `*${bird.name}* is already ${subcommand}d.` });
-        return;
-      }
-
-      db.setCronJobEnabled(bird.uid, enabling);
-      await say({ text: `*${bird.name}* ${subcommand}d.` });
-      logger.info(`/bird ${subcommand}: ${bird.name} by ${body.user_id}`);
-      break;
-    }
-
-    case 'logs': {
-      const birdName = parts.slice(1).join(' ');
-      if (!birdName) {
-        await say({ text: 'Usage: `/bird logs <name or id>`' });
-        return;
-      }
-
-      const bird = findBird(birdName);
-      if (!bird) {
-        await say({ text: `Bird not found: \`${birdName}\`` });
-        return;
-      }
-
-      const flights = db.listFlights(1, 5, { birdUid: bird.uid });
-      const mapped = flights.items.map((f) => {
-        const durationMs =
-          f.finished_at && f.started_at
-            ? new Date(f.finished_at).getTime() - new Date(f.started_at).getTime()
-            : undefined;
-        return {
-          uid: f.uid,
-          status: f.status,
-          startedAt: f.started_at,
-          durationMs,
-          error: f.error ?? undefined,
-        };
-      });
-
-      const blocks = birdLogsBlocks(bird.name, mapped);
-      const text = `${flights.totalItems} flight${flights.totalItems === 1 ? '' : 's'} for ${bird.name}`;
-      await say({ text, blocks });
-      break;
-    }
-
-    case 'create': {
-      if (!channelClient.openModal) {
-        await say({ text: 'Modals are not supported by this adapter.' });
-        return;
-      }
-
-      const modal = birdCreateModal();
-      await channelClient.openModal(body.trigger_id, modal);
-      break;
-    }
-
-    case 'status': {
-      const cronJobs = db.listCronJobs(1, 1, false);
-      const blocks = statusBlocks({
-        slackConnected: status.slackConnected(),
-        activeCount: status.activeCount(),
-        maxConcurrent: config.sessions.maxConcurrent,
-        birdCount: cronJobs.totalItems,
-        uptime: formatUptime(),
-      });
-      await say({ text: 'BrowserBird status', blocks });
-      break;
-    }
-
-    default:
-      await say({
-        text: [
-          '*Usage:* `/bird <command>`',
-          '',
-          '`/bird list` - Show all configured birds',
-          '`/bird fly <name>` - Trigger a bird immediately',
-          '`/bird logs <name>` - Show recent flights',
-          '`/bird enable <name>` - Enable a bird',
-          '`/bird disable <name>` - Disable a bird',
-          '`/bird create` - Create a new bird (opens form)',
-          '`/bird status` - Show daemon status',
-        ].join('\n'),
-      });
-  }
-}

package/src/channel/handler.ts

@@ -1,272 +0,0 @@
-/** @fileoverview Core orchestration: session resolution, spawn, stream-to-channel. */
-
-import type { Config } from '../core/types.ts';
-import type { CoalesceDispatch } from './coalesce.ts';
-import type { StreamEvent, StreamEventCompletion, ToolImage } from '../provider/stream.ts';
-import type { ChannelClient } from './types.ts';
-
-import { resolveSession } from '../provider/session.ts';
-import { spawnProvider } from '../provider/spawn.ts';
-import * as db from '../db/index.ts';
-import { logger } from '../core/logger.ts';
-import { redact } from '../core/redact.ts';
-import { broadcastSSE } from '../server/index.ts';
-import { sessionErrorBlocks, busyBlocks, noAgentBlocks, completionFooterBlocks } from './blocks.ts';
-
-interface SessionLock {
-  processing: boolean;
-  queue: CoalesceDispatch[];
-  killCurrent: (() => void) | null;
-}
-
-export interface Handler {
-  handle(dispatch: CoalesceDispatch): Promise<void>;
-  activeCount(): number;
-  killAll(): void;
-}
-
-export function createHandler(
-  client: ChannelClient,
-  config: Config,
-  signal: AbortSignal,
-  getTeamId: () => string,
-): Handler {
-  const locks = new Map<string, SessionLock>();
-  let activeSpawns = 0;
-
-  function getLock(key: string): SessionLock {
-    let lock = locks.get(key);
-    if (!lock) {
-      lock = { processing: false, queue: [], killCurrent: null };
-      locks.set(key, lock);
-    }
-    return lock;
-  }
-
-  function formatPrompt(messages: CoalesceDispatch['messages']): string {
-    if (messages.length === 1) {
-      return messages[0]!.text;
-    }
-    return messages
-      .map((m) => {
-        const time = new Date(Number(m.timestamp) * 1000).toISOString().slice(11, 19);
-        return `[${time}] @${m.userId}: ${m.text}`;
-      })
-      .join('\n');
-  }
-
-  async function streamToChannel(
-    events: AsyncIterable<StreamEvent>,
-    channelId: string,
-    threadTs: string,
-    sessionUid: string,
-    teamId: string,
-    userId: string,
-    meta: { birdName?: string },
-  ): Promise<void> {
-    const streamer = client.startStream({ channelId, threadTs, teamId, userId });
-    let fullText = '';
-    let completion: StreamEventCompletion | undefined;
-    let hasError = false;
-
-    for await (const event of events) {
-      if (signal.aborted) break;
-      logger.debug(`stream event: ${event.type}`);
-
-      switch (event.type) {
-        case 'init':
-          db.updateSessionProviderId(sessionUid, event.sessionId);
-          break;
-
-        case 'text_delta': {
-          const safe = redact(event.delta);
-          fullText += safe;
-          await streamer.append({ markdown_text: safe });
-          break;
-        }
-
-        case 'tool_images':
-          await uploadImages(event.images, channelId, threadTs);
-          break;
-
-        case 'completion':
-          completion = event;
-          logger.info(
-            `completion [${event.subtype}]: ${event.tokensIn}in/${event.tokensOut}out, $${event.costUsd.toFixed(4)}, ${event.numTurns} turns`,
-          );
-          db.logMessage(
-            channelId,
-            threadTs,
-            'bot',
-            'out',
-            fullText,
-            event.tokensIn,
-            event.tokensOut,
-          );
-          break;
-
-        case 'rate_limit':
-          logger.debug(`rate limit window resets ${new Date(event.resetsAt * 1000).toISOString()}`);
-          break;
-
-        case 'error': {
-          hasError = true;
-          const safeError = redact(event.error);
-          logger.error(`agent error: ${safeError}`);
-          db.insertLog('error', 'spawn', safeError, channelId);
-          await streamer.append({ markdown_text: `\n\nError: ${safeError}` });
-          break;
-        }
-      }
-    }
-
-    const footerBlocks = completion
-      ? completionFooterBlocks(completion, hasError, meta.birdName, userId)
-      : undefined;
-
-    await streamer.stop(footerBlocks ? { blocks: footerBlocks } : {});
-  }
-
-  async function uploadImages(
-    images: ToolImage[],
-    channelId: string,
-    threadTs: string,
-  ): Promise<void> {
-    for (let i = 0; i < images.length; i++) {
-      const img = images[i]!;
-      const content = Buffer.from(img.data, 'base64');
-      const ext = img.mediaType === 'image/jpeg' ? 'jpg' : 'png';
-      const filename = `screenshot-${i + 1}.${ext}`;
-      try {
-        await client.uploadFile(channelId, threadTs, content, filename, `Screenshot ${i + 1}`);
-      } catch (err) {
-        logger.warn(`image upload failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-  }
-
-  async function handle(dispatch: CoalesceDispatch): Promise<void> {
-    const { channelId, threadTs, messages } = dispatch;
-    const key = `${channelId}:${threadTs}`;
-    const lock = getLock(key);
-
-    if (lock.processing) {
-      lock.queue.push(dispatch);
-      try {
-        await client.postEphemeral(
-          channelId,
-          threadTs,
-          messages[messages.length - 1]!.userId,
-          "Got it, I'll get to this after my current response.",
-        );
-      } catch {
-        /* postEphemeral may fail if user left channel */
-      }
-      return;
-    }
-
-    if (activeSpawns >= config.sessions.maxConcurrent) {
-      const blocks = busyBlocks(activeSpawns, config.sessions.maxConcurrent);
-      await client.postMessage(
-        channelId,
-        threadTs,
-        'Too many active sessions. Try again shortly.',
-        { blocks },
-      );
-      logger.warn('max concurrent sessions reached');
-      return;
-    }
-
-    lock.processing = true;
-    activeSpawns++;
-
-    let sessionUid: string | undefined;
-    try {
-      const resolved = resolveSession(channelId, threadTs, config);
-      if (!resolved) {
-        const blocks = noAgentBlocks(channelId);
-        await client.postMessage(channelId, threadTs, 'No agent configured for this channel.', {
-          blocks,
-        });
-        return;
-      }
-
-      const { session, agent, isNew } = resolved;
-      sessionUid = session.uid;
-
-      for (const msg of messages) {
-        db.logMessage(channelId, threadTs, msg.userId, 'in', msg.text);
-      }
-      db.touchSession(session.uid, messages.length + 1);
-      broadcastSSE('invalidate', { resource: 'sessions' });
-
-      const prompt = formatPrompt(messages);
-      const lastMessage = messages[messages.length - 1]!;
-      const userId = lastMessage.userId;
-
-      const existingSessionId = isNew ? undefined : session.provider_session_id || undefined;
-      const { events, kill } = spawnProvider(
-        agent.provider,
-        {
-          message: prompt,
-          sessionId: existingSessionId,
-          agent,
-          mcpConfigPath: config.browser.mcpConfigPath,
-        },
-        signal,
-      );
-
-      lock.killCurrent = kill;
-
-      client.setStatus?.(channelId, threadTs, 'is thinking...').catch(() => {});
-
-      if (isNew) {
-        const title = prompt.length > 60 ? prompt.slice(0, 57) + '...' : prompt;
-        client.setTitle?.(channelId, threadTs, title).catch(() => {});
-      }
-
-      await streamToChannel(events, channelId, threadTs, session.uid, getTeamId(), userId, {
-        birdName: agent.name,
-      });
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      logger.error(`handler error: ${errMsg}`);
-      db.insertLog('error', 'handler', errMsg, channelId);
-      try {
-        const blocks = sessionErrorBlocks(errMsg, { sessionUid });
-        await client.postMessage(channelId, threadTs, `Something went wrong: ${errMsg}`, {
-          blocks,
-        });
-      } catch {
-        /* channel may no longer be accessible */
-      }
-    } finally {
-      activeSpawns--;
-      lock.processing = false;
-      lock.killCurrent = null;
-
-      const next = lock.queue.shift();
-      if (next) {
-        handle(next).catch((err: unknown) => {
-          logger.error(`dispatch error: ${err instanceof Error ? err.message : String(err)}`);
-        });
-      } else if (lock.queue.length === 0) {
-        locks.delete(key);
-      }
-    }
-  }
-
-  function activeCount(): number {
-    return activeSpawns;
-  }
-
-  function killAll(): void {
-    for (const lock of locks.values()) {
-      lock.killCurrent?.();
-      lock.queue.length = 0;
-    }
-    locks.clear();
-  }
-
-  return { handle, activeCount, killAll };
-}