@owloops/browserbird 1.0.2 → 1.0.3

package/src/channel/slack.ts

@@ -1,573 +0,0 @@
-/** @fileoverview Slack adapter: SocketModeClient + WebClient, streaming, and assistant APIs. */
-
-import type { Config, SlackConfig } from '../core/types.ts';
-import type {
-  ChannelClient,
-  ChannelHandle,
-  MessageOptions,
-  StreamHandle,
-  StreamStartOptions,
-} from './types.ts';
-import type { ModalView } from './blocks.ts';
-import type { SlashCommandBody } from './commands.ts';
-
-import type { Handler } from './handler.ts';
-
-import { SocketModeClient } from '@slack/socket-mode';
-import { WebClient, LogLevel } from '@slack/web-api';
-import { createCoalescer } from './coalesce.ts';
-import { createHandler } from './handler.ts';
-import { handleSlashCommand } from './commands.ts';
-import { logger } from '../core/logger.ts';
-import { isWithinTimeRange } from '../core/utils.ts';
-
-class SlackChannelClient implements ChannelClient {
-  private readonly web: WebClient;
-
-  constructor(web: WebClient) {
-    this.web = web;
-  }
-
-  async postMessage(
-    channelId: string,
-    threadTs: string,
-    text: string,
-    opts?: MessageOptions,
-  ): Promise<string> {
-    const result = await this.web.chat.postMessage({
-      channel: channelId,
-      thread_ts: threadTs,
-      text,
-      ...(opts?.blocks ? { blocks: opts.blocks } : {}),
-    });
-    return result.ts ?? '';
-  }
-
-  async postEphemeral(
-    channelId: string,
-    threadTs: string,
-    userId: string,
-    text: string,
-    opts?: MessageOptions,
-  ): Promise<void> {
-    await this.web.chat.postEphemeral({
-      channel: channelId,
-      thread_ts: threadTs,
-      user: userId,
-      text,
-      ...(opts?.blocks ? { blocks: opts.blocks } : {}),
-    });
-  }
-
-  async openModal(triggerId: string, view: ModalView): Promise<void> {
-    await this.web.views.open({ trigger_id: triggerId, view });
-  }
-
-  async uploadFile(
-    channelId: string,
-    threadTs: string,
-    content: Buffer,
-    filename: string,
-    title: string,
-  ): Promise<void> {
-    const upload = await this.web.files.getUploadURLExternal({
-      filename,
-      length: content.byteLength,
-    });
-    if (!upload.upload_url || !upload.file_id) return;
-    await fetch(upload.upload_url, { method: 'POST', body: new Uint8Array(content) });
-    await this.web.files.completeUploadExternal({
-      files: [{ id: upload.file_id, title }],
-      channel_id: channelId,
-      thread_ts: threadTs,
-    });
-  }
-
-  startStream(opts: StreamStartOptions): StreamHandle {
-    return this.web.chatStream({
-      channel: opts.channelId,
-      thread_ts: opts.threadTs,
-      recipient_team_id: opts.teamId,
-      recipient_user_id: opts.userId,
-      task_display_mode: 'timeline',
-      buffer_size: 128,
-    });
-  }
-
-  async setStatus(channelId: string, threadTs: string, status: string): Promise<void> {
-    await this.web.assistant.threads.setStatus({
-      channel_id: channelId,
-      thread_ts: threadTs,
-      status,
-    });
-  }
-
-  async setTitle(channelId: string, threadTs: string, title: string): Promise<void> {
-    await this.web.assistant.threads.setTitle({
-      channel_id: channelId,
-      thread_ts: threadTs,
-      title,
-    });
-  }
-
-  async setSuggestedPrompts(
-    channelId: string,
-    threadTs: string,
-    prompts: Array<{ title: string; message: string }>,
-  ): Promise<void> {
-    await this.web.assistant.threads.setSuggestedPrompts({
-      channel_id: channelId,
-      thread_ts: threadTs,
-      prompts,
-    });
-  }
-}
-
-const IGNORED_SUBTYPES = new Set([
-  'bot_message',
-  'message_changed',
-  'message_deleted',
-  'message_replied',
-  'channel_join',
-  'channel_leave',
-  'channel_topic',
-  'channel_purpose',
-  'channel_name',
-  'channel_archive',
-  'channel_unarchive',
-  'file_share',
-  'pinned_item',
-  'unpinned_item',
-]);
-
-const DEDUP_TTL_MS = 30_000;
-const DEDUP_CLEANUP_MS = 60_000;
-
-function logDispatchError(err: unknown): void {
-  logger.error(`dispatch error: ${err instanceof Error ? err.message : String(err)}`);
-}
-
-interface SocketModeEvent {
-  ack: (response?: unknown) => Promise<void>;
-  envelope_id: string;
-  body: Record<string, unknown>;
-  event?: Record<string, unknown>;
-  retry_num?: number;
-  retry_reason?: string;
-}
-
-export function createSlackChannel(config: Config, signal: AbortSignal): ChannelHandle {
-  const recentEvents = new Map<string, number>();
-  let botUserId = '';
-  let teamId = '';
-
-  const socketClient = new SocketModeClient({
-    appToken: config.slack.appToken,
-    logLevel: LogLevel.WARN,
-    clientPingTimeout: 15_000,
-    serverPingTimeout: 60_000,
-  });
-
-  const webClient = new WebClient(config.slack.botToken);
-  const channelClient = new SlackChannelClient(webClient);
-  const handler = createHandler(channelClient, config, signal, () => teamId);
-  const coalescer = createCoalescer(config.slack.coalesce, (dispatch) => {
-    handler.handle(dispatch).catch(logDispatchError);
-  });
-
-  const dedupTimer = setInterval(() => {
-    const cutoff = Date.now() - DEDUP_TTL_MS;
-    for (const [key, ts] of recentEvents) {
-      if (ts < cutoff) recentEvents.delete(key);
-    }
-  }, DEDUP_CLEANUP_MS);
-
-  signal.addEventListener('abort', () => {
-    clearInterval(dedupTimer);
-  });
-
-  function isDuplicate(body: Record<string, unknown>): boolean {
-    const eventId = body['event_id'] as string | undefined;
-    if (!eventId) return false;
-    if (recentEvents.has(eventId)) return true;
-    recentEvents.set(eventId, Date.now());
-    return false;
-  }
-
-  socketClient.on('message', async ({ ack, body, event }: SocketModeEvent) => {
-    await ack();
-    if (!event) return;
-    if (event['user'] === botUserId) return;
-
-    const text = event['text'] as string | undefined;
-    if (!text) return;
-
-    const subtype = event['subtype'] as string | undefined;
-    if (subtype && IGNORED_SUBTYPES.has(subtype)) return;
-    if (event['bot_id']) return;
-    if (isDuplicate(body)) return;
-
-    const channelType = event['channel_type'] as string | undefined;
-    const isDm = channelType === 'im';
-
-    if (!isDm && config.slack.requireMention) return;
-
-    const channelId = event['channel'] as string;
-    if (!isChannelAllowed(channelId, config.slack.channels)) return;
-    if (!isDm && isQuietHours(config.slack.quietHours)) return;
-
-    const threadTs = (event['thread_ts'] as string | undefined) ?? (event['ts'] as string);
-    const userId = (event['user'] as string) ?? 'unknown';
-    const messageTs = event['ts'] as string;
-    const cleanText = stripMention(text);
-
-    if (!cleanText.trim()) return;
-
-    if (isDm && config.slack.coalesce.bypassDms) {
-      handler
-        .handle({
-          channelId,
-          threadTs,
-          messages: [{ userId, text: cleanText, timestamp: messageTs }],
-        })
-        .catch(logDispatchError);
-    } else {
-      coalescer.push(channelId, threadTs, userId, cleanText, messageTs);
-    }
-  });
-
-  if (config.slack.requireMention) {
-    socketClient.on('app_mention', async ({ ack, body, event }: SocketModeEvent) => {
-      await ack();
-      if (!event) return;
-      if (isDuplicate(body)) return;
-
-      const channelId = event['channel'] as string;
-      if (!isChannelAllowed(channelId, config.slack.channels)) return;
-      if (isQuietHours(config.slack.quietHours)) return;
-
-      const messageTs = event['ts'] as string | undefined;
-      if (!messageTs) return;
-
-      const threadTs = (event['thread_ts'] as string | undefined) ?? messageTs;
-      const userId = (event['user'] as string) ?? 'unknown';
-      const text = stripMention((event['text'] as string) ?? '');
-
-      if (!text.trim()) return;
-
-      coalescer.push(channelId, threadTs, userId, text, messageTs);
-    });
-  }
-
-  socketClient.on('assistant_thread_started', async ({ ack, event }: SocketModeEvent) => {
-    await ack();
-    if (!event) return;
-    const threadInfo = event['assistant_thread'] as Record<string, unknown> | undefined;
-    if (!threadInfo) return;
-
-    const channelId = threadInfo['channel_id'] as string | undefined;
-    const threadTs = threadInfo['thread_ts'] as string | undefined;
-    if (!channelId || !threadTs) return;
-
-    channelClient
-      .setSuggestedPrompts(channelId, threadTs, [
-        { title: 'Browse a website', message: 'Browse https://example.com and summarize it' },
-        { title: 'Run a command', message: 'List files in the current directory' },
-        { title: 'Help me code', message: 'Help me write a function that...' },
-      ])
-      .catch(() => {});
-  });
-
-  socketClient.on('assistant_thread_context_changed', async ({ ack }: SocketModeEvent) => {
-    await ack();
-  });
-
-  let connected = false;
-  const statusProvider = {
-    slackConnected: () => connected,
-    activeCount: () => handler.activeCount(),
-  };
-
-  socketClient.on('slash_commands', async ({ ack, body }: SocketModeEvent) => {
-    await ack();
-    const commandBody = body as unknown as SlashCommandBody;
-    if (commandBody.command !== '/bird') return;
-
-    try {
-      await handleSlashCommand(commandBody, webClient, channelClient, config, statusProvider);
-    } catch (err) {
-      logger.error(`/bird command error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  });
-
-  socketClient.on('interactive', async ({ ack, body }: SocketModeEvent) => {
-    await ack();
-    const interactionType = body['type'] as string | undefined;
-
-    if (interactionType === 'view_submission') {
-      const view = body['view'] as Record<string, unknown> | undefined;
-      if (view?.['callback_id'] === 'bird_create') {
-        await handleBirdCreateSubmission(view, webClient, config.timezone);
-      }
-    }
-
-    if (interactionType === 'block_actions') {
-      const actionsArr = body['actions'] as Array<Record<string, unknown>> | undefined;
-      const channel = (body['channel'] as Record<string, unknown> | undefined)?.['id'] as
-        | string
-        | undefined;
-      const user = (body['user'] as Record<string, unknown> | undefined)?.['id'] as
-        | string
-        | undefined;
-      if (!actionsArr || !channel) return;
-
-      for (const action of actionsArr) {
-        if (action['action_id'] !== 'session_error_overflow') continue;
-        const selected = (action['selected_option'] as Record<string, unknown> | undefined)?.[
-          'value'
-        ] as string | undefined;
-        if (!selected) continue;
-
-        if (selected.startsWith('retry:')) {
-          const sessionUid = selected.slice('retry:'.length);
-          if (!sessionUid) continue;
-          await handleSessionRetry(sessionUid, channel, user ?? 'unknown', config, handler);
-        }
-      }
-    }
-  });
-
-  const MAX_CONSECUTIVE_FAILURES = 5;
-
-  socketClient.on('connected', () => {
-    connected = true;
-    logger.success('slack connected');
-  });
-
-  socketClient.on('reconnecting', () => {
-    connected = false;
-    logger.info('slack reconnecting...');
-  });
-
-  socketClient.on('disconnected', () => {
-    connected = false;
-    logger.warn('slack disconnected');
-  });
-
-  socketClient.on('close' as string, () => {
-    const failures = (socketClient as unknown as Record<string, unknown>)[
-      'numOfConsecutiveReconnectionFailures'
-    ] as number | undefined;
-    if (failures != null && failures > MAX_CONSECUTIVE_FAILURES) {
-      (socketClient as unknown as Record<string, number>)['numOfConsecutiveReconnectionFailures'] =
-        1;
-      logger.info('reset reconnection back-off counter');
-    }
-  });
-
-  async function resolveChannelNames(): Promise<void> {
-    const namesToResolve = new Set<string>();
-
-    function collectNames(channels: string[]): void {
-      for (const ch of channels) {
-        if (ch !== '*' && !ch.startsWith('C') && !ch.startsWith('D') && !ch.startsWith('G')) {
-          namesToResolve.add(ch);
-        }
-      }
-    }
-
-    collectNames(config.slack.channels);
-    for (const agent of config.agents) {
-      collectNames(agent.channels);
-    }
-    if (namesToResolve.size === 0) return;
-
-    const nameToId = new Map<string, string>();
-    try {
-      let cursor: string | undefined;
-      do {
-        const result = await webClient.conversations.list({
-          types: 'public_channel,private_channel',
-          limit: 200,
-          exclude_archived: true,
-          cursor,
-        });
-        for (const ch of result.channels ?? []) {
-          if (ch.name && ch.id && namesToResolve.has(ch.name)) {
-            nameToId.set(ch.name, ch.id);
-          }
-        }
-        cursor = result.response_metadata?.next_cursor || undefined;
-      } while (cursor);
-    } catch (err) {
-      logger.warn(
-        `failed to resolve channel names: ${err instanceof Error ? err.message : String(err)}`,
-      );
-      return;
-    }
-
-    function resolveList(channels: string[], label: string): string[] {
-      return channels.map((ch) => {
-        const resolved = nameToId.get(ch);
-        if (resolved) {
-          logger.info(`${label}: resolved channel "${ch}" -> ${resolved}`);
-          return resolved;
-        }
-        if (namesToResolve.has(ch)) {
-          logger.warn(`${label}: channel "${ch}" not found in workspace`);
-        }
-        return ch;
-      });
-    }
-
-    config.slack.channels = resolveList(config.slack.channels, 'slack');
-    for (const agent of config.agents) {
-      agent.channels = resolveList(agent.channels, `agent "${agent.id}"`);
-    }
-  }
-
-  async function start(): Promise<void> {
-    const authResult = await webClient.auth.test();
-    botUserId = (authResult.user_id as string) ?? '';
-    teamId = (authResult.team_id as string) ?? '';
-    logger.info(`authenticated as ${authResult.user} (team: ${teamId})`);
-
-    await resolveChannelNames();
-
-    await socketClient.start();
-    connected = true;
-  }
-
-  async function stop(): Promise<void> {
-    connected = false;
-    coalescer.destroy();
-    handler.killAll();
-    clearInterval(dedupTimer);
-    await socketClient.disconnect();
-    logger.info('slack stopped');
-  }
-
-  function isConnected(): boolean {
-    return connected;
-  }
-
-  async function postMessage(channel: string, text: string, opts?: MessageOptions): Promise<void> {
-    await webClient.chat.postMessage({
-      channel,
-      text,
-      ...(opts?.blocks ? { blocks: opts.blocks } : {}),
-    });
-  }
-
-  return { start, stop, isConnected, activeCount: () => handler.activeCount(), postMessage };
-}
-
-async function handleBirdCreateSubmission(
-  view: Record<string, unknown>,
-  webClient: WebClient,
-  defaultTimezone: string,
-): Promise<void> {
-  try {
-    const values = view['state'] as Record<string, unknown> | undefined;
-    const stateValues = (values?.['values'] ?? {}) as Record<
-      string,
-      Record<string, Record<string, unknown>>
-    >;
-
-    const name = (stateValues['bird_name']?.['name_input']?.['value'] as string | undefined) ?? '';
-    const schedule = (
-      stateValues['bird_schedule']?.['schedule_select']?.['selected_option'] as
-        | Record<string, unknown>
-        | undefined
-    )?.['value'] as string | undefined;
-    const prompt =
-      (stateValues['bird_prompt']?.['prompt_input']?.['value'] as string | undefined) ?? '';
-    const channelId =
-      (stateValues['bird_channel']?.['channel_select']?.['selected_conversation'] as
-        | string
-        | undefined) ?? '';
-    const enabledValue = (
-      stateValues['bird_enabled']?.['enabled_radio']?.['selected_option'] as
-        | Record<string, unknown>
-        | undefined
-    )?.['value'] as string | undefined;
-
-    if (!name || !schedule || !prompt) {
-      logger.warn('bird_create submission missing required fields');
-      return;
-    }
-
-    const { createCronJob, setCronJobEnabled } = await import('../db/index.ts');
-    const bird = createCronJob(
-      name,
-      schedule,
-      prompt,
-      channelId || undefined,
-      'default',
-      defaultTimezone,
-    );
-    if (enabledValue !== 'enabled') {
-      setCronJobEnabled(bird.uid, false);
-    }
-
-    await webClient.chat.postMessage({
-      channel: channelId || 'general',
-      text: `Bird *${name}* created. Schedule: \`${schedule}\``,
-    });
-
-    logger.info(`bird created via modal: ${name}`);
-  } catch (err) {
-    logger.error(
-      `bird_create submission error: ${err instanceof Error ? err.message : String(err)}`,
-    );
-  }
-}
-
-async function handleSessionRetry(
-  sessionUid: string,
-  channelId: string,
-  userId: string,
-  config: Config,
-  handler: Handler,
-): Promise<void> {
-  try {
-    const { getSession, getLastInboundMessage } = await import('../db/index.ts');
-    const session = getSession(sessionUid);
-    if (!session) {
-      logger.warn(`retry: session ${sessionUid} not found`);
-      return;
-    }
-
-    const lastMsg = getLastInboundMessage(session.channel_id, session.thread_id);
-    if (!lastMsg) {
-      logger.warn(`retry: no inbound message for session ${sessionUid}`);
-      return;
-    }
-
-    handler
-      .handle({
-        channelId: session.channel_id,
-        threadTs: session.thread_id ?? lastMsg.timestamp,
-        messages: [{ userId, text: lastMsg.content, timestamp: lastMsg.timestamp }],
-      })
-      .catch(logDispatchError);
-
-    logger.info(`retry: session ${sessionUid} re-dispatched by ${userId}`);
-  } catch (err) {
-    logger.error(`retry error: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-
-function isChannelAllowed(channelId: string, channels: string[]): boolean {
-  if (channels.includes('*')) return true;
-  return channels.includes(channelId);
-}
-
-function isQuietHours(quietHours: SlackConfig['quietHours']): boolean {
-  if (!quietHours.enabled) return false;
-  return isWithinTimeRange(quietHours.start, quietHours.end, new Date(), quietHours.timezone);
-}
-
-function stripMention(text: string): string {
-  return text.replace(/^\s*<@[A-Z0-9]+>\s*/i, '').trim();
-}

package/src/channel/types.ts

@@ -1,59 +0,0 @@
-/** @fileoverview Platform-agnostic channel client interface. */
-
-import type { Block, ModalView } from './blocks.ts';
-
-export interface MessageOptions {
-  blocks?: Block[];
-}
-
-export interface StreamHandle {
-  append(args: { markdown_text?: string }): Promise<unknown>;
-  stop(args?: { blocks?: Block[] }): Promise<unknown>;
-}
-
-export interface StreamStartOptions {
-  channelId: string;
-  threadTs: string;
-  teamId: string;
-  userId: string;
-}
-
-export interface ChannelClient {
-  postMessage(
-    channelId: string,
-    threadTs: string,
-    text: string,
-    opts?: MessageOptions,
-  ): Promise<string>;
-  postEphemeral(
-    channelId: string,
-    threadTs: string,
-    userId: string,
-    text: string,
-    opts?: MessageOptions,
-  ): Promise<void>;
-  uploadFile(
-    channelId: string,
-    threadTs: string,
-    content: Buffer,
-    filename: string,
-    title: string,
-  ): Promise<void>;
-  startStream(opts: StreamStartOptions): StreamHandle;
-  openModal?(triggerId: string, view: ModalView): Promise<void>;
-  setStatus?(channelId: string, threadTs: string, status: string): Promise<void>;
-  setTitle?(channelId: string, threadTs: string, title: string): Promise<void>;
-  setSuggestedPrompts?(
-    channelId: string,
-    threadTs: string,
-    prompts: Array<{ title: string; message: string }>,
-  ): Promise<void>;
-}
-
-export interface ChannelHandle {
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  isConnected(): boolean;
-  activeCount(): number;
-  postMessage(channel: string, text: string, opts?: MessageOptions): Promise<void>;
-}

package/src/cli/banner.ts

@@ -1,10 +0,0 @@
-/** @fileoverview ASCII banner displayed on daemon startup and in help text. */
-
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-export const VERSION: string = (require('../../package.json') as { version: string }).version;
-
-const BIRD = ['   .__.', '   ( ^>', '   / )\\', '  <_/_/', '   " "'].join('\n');
-
-export const BANNER = BIRD;