botinabox 2.4.2 → 2.5.0

package/dist/chunk-UACT2WXX.js

@@ -1,381 +0,0 @@
-// src/connectors/google/oauth.ts
-var _google;
-async function getGoogle() {
-  if (!_google) {
-    try {
-      const mod = await import("googleapis");
-      _google = mod.google;
-    } catch {
-      throw new Error(
-        "googleapis is required for Google connectors. Install it: npm install googleapis"
-      );
-    }
-  }
-  return _google;
-}
-async function createOAuth2Client(config) {
-  const google = await getGoogle();
-  return new google.auth.OAuth2(
-    config.clientId,
-    config.clientSecret,
-    config.redirectUri
-  );
-}
-function getAuthUrl(client, scopes) {
-  return client.generateAuthUrl({
-    access_type: "offline",
-    prompt: "consent",
-    scope: scopes
-  });
-}
-async function exchangeCode(client, code) {
-  const { tokens } = await client.getToken(code);
-  return tokens;
-}
-async function createServiceAccountClient(config, scopes) {
-  const google = await getGoogle();
-  const auth = new google.auth.GoogleAuth({
-    ...config.keyFile ? { keyFile: config.keyFile } : {},
-    ...config.credentials ? { credentials: config.credentials } : {},
-    scopes,
-    clientOptions: { subject: config.subject }
-  });
-  return auth.getClient();
-}
-async function loadTokens(getter, accountKey) {
-  const raw = await getter(`google_tokens:${accountKey}`);
-  if (!raw) return null;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function saveTokens(setter, accountKey, tokens) {
-  await setter(`google_tokens:${accountKey}`, JSON.stringify(tokens));
-}
-async function refreshIfNeeded(client, tokens, saver) {
-  const buffer = 6e4;
-  const isExpired = tokens.expiry_date != null && Date.now() >= tokens.expiry_date - buffer;
-  if (!isExpired) return tokens;
-  client.setCredentials(tokens);
-  const { credentials } = await client.refreshAccessToken();
-  const refreshed = {
-    access_token: credentials.access_token,
-    refresh_token: credentials.refresh_token ?? tokens.refresh_token,
-    expiry_date: credentials.expiry_date ?? void 0,
-    token_type: credentials.token_type ?? "Bearer"
-  };
-  if (saver) {
-    await saver(refreshed);
-  }
-  return refreshed;
-}
-
-// src/connectors/google/gmail-connector.ts
-var GoogleGmailConnector = class {
-  id = "google-gmail";
-  meta = {
-    displayName: "Google Gmail",
-    provider: "google",
-    dataType: "email"
-  };
-  tokenLoader;
-  tokenSaver;
-  client = null;
-  config = null;
-  tokens = null;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  gmail = null;
-  constructor(opts = {}) {
-    this.tokenLoader = opts.tokenLoader;
-    this.tokenSaver = opts.tokenSaver;
-  }
-  // ── Lifecycle ──────────────────────────────────────────────────
-  async connect(config) {
-    this.config = config;
-    const scopes = config.scopes ?? [
-      "https://www.googleapis.com/auth/gmail.readonly"
-    ];
-    if (config.serviceAccount) {
-      this.client = await createServiceAccountClient(config.serviceAccount, scopes);
-    } else if (config.oauth) {
-      this.client = await createOAuth2Client(config.oauth);
-      if (!this.tokenLoader) {
-        throw new Error("tokenLoader required for OAuth2 flow");
-      }
-      this.tokens = await loadTokens(this.tokenLoader, config.account);
-      if (!this.tokens) {
-        throw new Error(
-          `No stored tokens for account ${config.account}. Complete the OAuth flow first.`
-        );
-      }
-      this.tokens = await refreshIfNeeded(
-        this.client,
-        this.tokens,
-        this.tokenSaver ? async (t) => saveTokens(this.tokenSaver, config.account, t) : void 0
-      );
-      this.client.setCredentials(this.tokens);
-    } else {
-      throw new Error("Either serviceAccount or oauth config is required");
-    }
-    const { google } = await import("googleapis");
-    this.gmail = google.gmail({ version: "v1", auth: this.client });
-  }
-  async disconnect() {
-    this.client = null;
-    this.gmail = null;
-    this.tokens = null;
-    this.config = null;
-  }
-  async healthCheck() {
-    try {
-      this.ensureConnected();
-      const res = await this.gmail.users.getProfile({ userId: "me" });
-      return { ok: true, account: res.data.emailAddress };
-    } catch (err) {
-      return { ok: false, error: errorMessage(err) };
-    }
-  }
-  // ── Auth ───────────────────────────────────────────────────────
-  async authenticate(codeProvider) {
-    if (!this.config) {
-      return { success: false, error: "Call connect() first to set config, or pass config and call authenticate() before connect()." };
-    }
-    try {
-      if (!this.config.oauth) {
-        return { success: false, error: "OAuth config required for browser-based authenticate(). Use serviceAccount for headless auth." };
-      }
-      if (!this.tokenSaver) {
-        return { success: false, error: "tokenSaver required for authenticate() flow." };
-      }
-      const client = await createOAuth2Client(this.config.oauth);
-      const scopes = this.config.scopes ?? [
-        "https://www.googleapis.com/auth/gmail.readonly",
-        "https://www.googleapis.com/auth/gmail.send"
-      ];
-      const authUrl = getAuthUrl(client, scopes);
-      const code = await codeProvider(authUrl);
-      const tokens = await exchangeCode(client, code);
-      await saveTokens(this.tokenSaver, this.config.account, tokens);
-      this.tokens = tokens;
-      this.client = client;
-      this.client.setCredentials(tokens);
-      const { google } = await import("googleapis");
-      this.gmail = google.gmail({ version: "v1", auth: this.client });
-      return { success: true, account: this.config.account };
-    } catch (err) {
-      return { success: false, error: errorMessage(err) };
-    }
-  }
-  // ── Sync ───────────────────────────────────────────────────────
-  async sync(options) {
-    this.ensureConnected();
-    if (options?.cursor) {
-      return this.syncIncremental(options.cursor, options.limit);
-    }
-    return this.syncFull(options);
-  }
-  /** Incremental sync using Gmail history API. */
-  async syncIncremental(startHistoryId, limit) {
-    const records = [];
-    const errors = [];
-    const seenIds = /* @__PURE__ */ new Set();
-    let pageToken;
-    let latestHistoryId = startHistoryId;
-    do {
-      const res = await this.gmail.users.history.list({
-        userId: "me",
-        startHistoryId,
-        historyTypes: ["messageAdded"],
-        ...pageToken ? { pageToken } : {}
-      });
-      latestHistoryId = res.data.historyId ?? latestHistoryId;
-      const histories = res.data.history ?? [];
-      for (const h of histories) {
-        for (const added of h.messagesAdded ?? []) {
-          const msgId = added.message?.id;
-          if (!msgId || seenIds.has(msgId)) continue;
-          seenIds.add(msgId);
-          try {
-            const record = await this.fetchMessage(msgId);
-            records.push(record);
-          } catch (err) {
-            errors.push({ id: msgId, error: errorMessage(err) });
-          }
-          if (limit && records.length >= limit) {
-            return { records, cursor: latestHistoryId, hasMore: true, errors };
-          }
-        }
-      }
-      pageToken = res.data.nextPageToken ?? void 0;
-    } while (pageToken);
-    return { records, cursor: latestHistoryId, hasMore: false, errors };
-  }
-  /** Full sync — list messages and fetch each one. */
-  async syncFull(options) {
-    const records = [];
-    const errors = [];
-    const maxResults = options?.limit ?? 100;
-    let query = "";
-    if (options?.since) {
-      const epoch = Math.floor(new Date(options.since).getTime() / 1e3);
-      query = `after:${epoch}`;
-    }
-    if (options?.filters?.q) {
-      query = query ? `${query} ${options.filters.q}` : String(options.filters.q);
-    }
-    let pageToken;
-    let collected = 0;
-    do {
-      const res = await this.gmail.users.messages.list({
-        userId: "me",
-        maxResults: Math.min(maxResults - collected, 100),
-        ...query ? { q: query } : {},
-        ...pageToken ? { pageToken } : {}
-      });
-      const messages = res.data.messages ?? [];
-      for (const msg of messages) {
-        try {
-          const record = await this.fetchMessage(msg.id);
-          records.push(record);
-        } catch (err) {
-          errors.push({ id: msg.id, error: errorMessage(err) });
-        }
-        collected++;
-        if (collected >= maxResults) break;
-      }
-      pageToken = res.data.nextPageToken ?? void 0;
-    } while (pageToken && collected < maxResults);
-    const profile = await this.gmail.users.getProfile({ userId: "me" });
-    const cursor = profile.data.historyId ?? void 0;
-    return {
-      records,
-      cursor,
-      hasMore: !!pageToken,
-      errors
-    };
-  }
-  // ── Push (send email) ─────────────────────────────────────────
-  async push(payload) {
-    this.ensureConnected();
-    try {
-      const toHeader = payload.to.map(formatAddress).join(", ");
-      const ccHeader = payload.cc.length ? `Cc: ${payload.cc.map(formatAddress).join(", ")}\r
-` : "";
-      const bccHeader = payload.bcc.length ? `Bcc: ${payload.bcc.map(formatAddress).join(", ")}\r
-` : "";
-      const mime = [
-        `To: ${toHeader}\r
-`,
-        ccHeader,
-        bccHeader,
-        `Subject: ${payload.subject}\r
-`,
-        `Content-Type: text/plain; charset="UTF-8"\r
-`,
-        `\r
-`,
-        payload.body ?? ""
-      ].join("");
-      const encoded = Buffer.from(mime).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-      const res = await this.gmail.users.messages.send({
-        userId: "me",
-        requestBody: { raw: encoded }
-      });
-      return { success: true, externalId: res.data.id };
-    } catch (err) {
-      return { success: false, error: errorMessage(err) };
-    }
-  }
-  // ── Internals ─────────────────────────────────────────────────
-  ensureConnected() {
-    if (!this.gmail || !this.config) {
-      throw new Error("GoogleGmailConnector is not connected. Call connect() first.");
-    }
-  }
-  /** Fetch a single message by ID and parse into an EmailRecord. */
-  async fetchMessage(messageId) {
-    const res = await this.gmail.users.messages.get({
-      userId: "me",
-      id: messageId,
-      format: "full"
-    });
-    const msg = res.data;
-    const headers = msg.payload?.headers ?? [];
-    const getHeader = (name) => headers.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value ?? "";
-    return {
-      gmailId: msg.id,
-      threadId: msg.threadId,
-      account: this.config.account,
-      subject: getHeader("Subject"),
-      from: parseAddress(getHeader("From")),
-      to: parseAddressList(getHeader("To")),
-      cc: parseAddressList(getHeader("Cc")),
-      bcc: parseAddressList(getHeader("Bcc")),
-      date: new Date(getHeader("Date")).toISOString(),
-      snippet: msg.snippet ?? "",
-      body: extractPlainTextBody(msg.payload),
-      labels: msg.labelIds ?? [],
-      isRead: !(msg.labelIds ?? []).includes("UNREAD")
-    };
-  }
-};
-function extractPlainTextBody(payload) {
-  if (!payload) return void 0;
-  if (payload.mimeType === "text/plain" && payload.body?.data) {
-    return decodeBase64Url(payload.body.data);
-  }
-  if (payload.parts) {
-    for (const part of payload.parts) {
-      if (part.mimeType === "text/plain" && part.body?.data) {
-        return decodeBase64Url(part.body.data);
-      }
-    }
-    for (const part of payload.parts) {
-      if (part.mimeType?.startsWith("multipart/")) {
-        const result = extractPlainTextBody(part);
-        if (result) return result;
-      }
-    }
-  }
-  return void 0;
-}
-function decodeBase64Url(data) {
-  const base64 = data.replace(/-/g, "+").replace(/_/g, "/");
-  return Buffer.from(base64, "base64").toString("utf-8");
-}
-function parseAddress(raw) {
-  const match = raw.match(/^(.+?)\s*<([^>]+)>$/);
-  if (match) {
-    return { name: match[1].replace(/^["']|["']$/g, "").trim(), email: match[2] };
-  }
-  return { email: raw.trim() };
-}
-function parseAddressList(raw) {
-  if (!raw.trim()) return [];
-  const results = [];
-  const parts = raw.split(/,(?=(?:[^<]*<[^>]*>)*[^>]*$)/);
-  for (const part of parts) {
-    const trimmed = part.trim();
-    if (trimmed) results.push(parseAddress(trimmed));
-  }
-  return results;
-}
-function formatAddress(addr) {
-  return addr.name ? `${addr.name} <${addr.email}>` : addr.email;
-}
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
-export {
-  createOAuth2Client,
-  getAuthUrl,
-  exchangeCode,
-  createServiceAccountClient,
-  loadTokens,
-  saveTokens,
-  refreshIfNeeded,
-  GoogleGmailConnector
-};

package/dist/cli/templates/config.yml.d.ts

@@ -1,7 +0,0 @@
-export interface ConfigTemplateOptions {
-    name: string;
-    channel?: string;
-    provider?: string;
-    typescript?: boolean;
-}
-export declare function configYmlTemplate(opts: ConfigTemplateOptions): string;

package/dist/cli/templates/config.yml.js

@@ -1,61 +0,0 @@
-export function configYmlTemplate(opts) {
-    const { name, channel = 'slack', provider = 'anthropic' } = opts;
-    const channelSection = channel === 'slack'
-        ? `  slack:
-    enabled: true
-    token: \${SLACK_BOT_TOKEN}
-    appToken: \${SLACK_APP_TOKEN}
-    signingSecret: \${SLACK_SIGNING_SECRET}`
-        : channel === 'discord'
-            ? `  discord:
-    enabled: true
-    token: \${DISCORD_BOT_TOKEN}`
-            : `  ${channel}:
-    enabled: true`;
-    const providerSection = provider === 'anthropic'
-        ? `  anthropic:
-    enabled: true
-    apiKey: \${ANTHROPIC_API_KEY}`
-        : provider === 'openai'
-            ? `  openai:
-    enabled: true
-    apiKey: \${OPENAI_API_KEY}`
-            : `  ${provider}:
-    enabled: true`;
-    return `name: ${name}
-version: "1.0.0"
-
-data:
-  path: ./data/bot.db
-  walMode: true
-
-channels:
-${channelSection}
-
-providers:
-${providerSection}
-
-agents: []
-
-models:
-  default: claude-3-5-sonnet-20241022
-  aliases: {}
-  routing: {}
-  fallbackChain: []
-
-entities: {}
-
-security: {}
-
-render:
-  outputDir: ./generated
-  watchIntervalMs: 1000
-
-updates:
-  policy: notify
-  checkIntervalMs: 3600000
-
-budget:
-  warnPercent: 80
-`;
-}

package/dist/cli/templates/env.d.ts

@@ -1 +0,0 @@
-export declare function envTemplate(channel?: string, provider?: string): string;

package/dist/cli/templates/env.js

@@ -1,30 +0,0 @@
-export function envTemplate(channel, provider) {
-    const lines = [
-        '# Bot environment variables',
-        '# Copy this file to .env and fill in the values',
-        '',
-    ];
-    if (provider === 'anthropic' || !provider) {
-        lines.push('ANTHROPIC_API_KEY=your_anthropic_api_key_here');
-    }
-    else if (provider === 'openai') {
-        lines.push('OPENAI_API_KEY=your_openai_api_key_here');
-    }
-    else {
-        lines.push(`${provider.toUpperCase()}_API_KEY=your_api_key_here`);
-    }
-    lines.push('');
-    if (channel === 'slack' || !channel) {
-        lines.push('SLACK_BOT_TOKEN=xoxb-your-slack-bot-token');
-        lines.push('SLACK_APP_TOKEN=xapp-your-slack-app-token');
-        lines.push('SLACK_SIGNING_SECRET=your_slack_signing_secret');
-    }
-    else if (channel === 'discord') {
-        lines.push('DISCORD_BOT_TOKEN=your_discord_bot_token');
-    }
-    else {
-        lines.push(`${channel.toUpperCase()}_TOKEN=your_token_here`);
-    }
-    lines.push('');
-    return lines.join('\n');
-}

package/dist/cli/templates/index.ts.d.ts

@@ -1,2 +0,0 @@
-export declare function indexTsTemplate(name: string): string;
-export declare function indexJsTemplate(name: string): string;

package/dist/cli/templates/index.ts.js

@@ -1,30 +0,0 @@
-export function indexTsTemplate(name) {
-    return `import { DataStore } from 'botinabox';
-import { readFileSync } from 'fs';
-
-// Load config
-const config = JSON.parse(readFileSync('./config.yml', 'utf-8'));
-
-async function main(): Promise<void> {
-  console.log('Starting ${name}...');
-  // Initialize your bot here
-}
-
-main().catch(console.error);
-`;
-}
-export function indexJsTemplate(name) {
-    return `import { DataStore } from 'botinabox';
-import { readFileSync } from 'fs';
-
-// Load config
-const config = JSON.parse(readFileSync('./config.yml', 'utf-8'));
-
-async function main() {
-  console.log('Starting ${name}...');
-  // Initialize your bot here
-}
-
-main().catch(console.error);
-`;
-}

package/dist/cli/templates/package.json.d.ts

@@ -1,5 +0,0 @@
-export interface PackageJsonTemplateOptions {
-    name: string;
-    typescript?: boolean;
-}
-export declare function packageJsonTemplate(opts: PackageJsonTemplateOptions): string;

package/dist/cli/templates/package.json.js

@@ -1,28 +0,0 @@
-export function packageJsonTemplate(opts) {
-    const { name, typescript = false } = opts;
-    const scripts = typescript
-        ? {
-            build: 'tsc',
-            start: 'node dist/index.js',
-            dev: 'ts-node src/index.ts',
-        }
-        : {
-            start: 'node index.js',
-        };
-    const devDeps = typescript
-        ? {
-            typescript: '^5.7.2',
-            '@types/node': '^22.10.0',
-        }
-        : {};
-    return JSON.stringify({
-        name,
-        version: '0.1.0',
-        type: 'module',
-        scripts,
-        dependencies: {
-            'botinabox': 'latest',
-        },
-        devDependencies: devDeps,
-    }, null, 2);
-}

package/dist/connector-DDahQw-2.d.ts

@@ -1,63 +0,0 @@
-/** Connector types — generic external service integrations. */
-interface ConnectorMeta {
-    displayName: string;
-    /** Provider identifier, e.g. "google", "trello", "jira", "salesforce" */
-    provider: string;
-    /** Data type this connector handles, e.g. "email", "calendar", "board", "crm" */
-    dataType: string;
-}
-interface SyncOptions {
-    /** Only sync records after this ISO 8601 timestamp */
-    since?: string;
-    /** Provider-specific incremental sync token */
-    cursor?: string;
-    /** Maximum number of records to fetch */
-    limit?: number;
-    /** Provider-specific query filters */
-    filters?: Record<string, unknown>;
-}
-interface SyncResult<T = Record<string, unknown>> {
-    /** Typed records produced by the connector — consumer decides where to store */
-    records: T[];
-    /** Next incremental sync token (persist for future calls) */
-    cursor?: string;
-    /** Whether more records are available (pagination) */
-    hasMore: boolean;
-    /** Errors encountered during sync (non-fatal per-record failures) */
-    errors: Array<{
-        id?: string;
-        error: string;
-    }>;
-}
-interface PushResult {
-    success: boolean;
-    externalId?: string;
-    error?: string;
-}
-type ConnectorConfig = Record<string, unknown>;
-/**
- * Generic connector interface for external service integrations.
- *
- * Connectors pull and optionally push data to/from external services
- * (Gmail, Calendar, Trello, Jira, Salesforce, etc.). They produce
- * typed records — the consuming application decides where to store them.
- *
- * @typeParam T - The record type this connector produces/consumes.
- */
-interface Connector<T = Record<string, unknown>> {
-    readonly id: string;
-    readonly meta: ConnectorMeta;
-    connect(config: ConnectorConfig): Promise<void>;
-    disconnect(): Promise<void>;
-    healthCheck(): Promise<{
-        ok: boolean;
-        account?: string;
-        error?: string;
-    }>;
-    /** Pull records from external source */
-    sync(options?: SyncOptions): Promise<SyncResult<T>>;
-    /** Push a record to external source (optional) */
-    push?(payload: T): Promise<PushResult>;
-}
-
-export type { ConnectorConfig as C, PushResult as P, SyncOptions as S, Connector as a, ConnectorMeta as b, SyncResult as c };

package/dist/connectors/google/calendar-connector.d.ts

@@ -1,40 +0,0 @@
-/**
- * Google Calendar connector — pulls calendar events.
- *
- * Produces `CalendarEventRecord` objects. Does NOT write to any database
- * table; the consuming application decides how to store records.
- */
-import type { Connector, ConnectorMeta, AuthResult, SyncOptions, SyncResult } from '../../shared/types/connector.js';
-import type { CalendarEventRecord, GoogleConnectorConfig } from './types.js';
-export interface CalendarConnectorOpts {
-    /** Load persisted tokens for a given account key (OAuth2 flow only). */
-    tokenLoader?: (key: string) => Promise<string | null>;
-    /** Persist tokens for a given account key (OAuth2 flow only). */
-    tokenSaver?: (key: string, value: string) => Promise<void>;
-}
-export declare class GoogleCalendarConnector implements Connector<CalendarEventRecord> {
-    readonly id = "google-calendar";
-    readonly meta: ConnectorMeta;
-    private tokenLoader?;
-    private tokenSaver?;
-    private client;
-    private config;
-    private tokens;
-    private calendar;
-    constructor(opts?: CalendarConnectorOpts);
-    connect(config: GoogleConnectorConfig): Promise<void>;
-    disconnect(): Promise<void>;
-    healthCheck(): Promise<{
-        ok: boolean;
-        account?: string;
-        error?: string;
-    }>;
-    authenticate(codeProvider: (authUrl: string) => Promise<string>): Promise<AuthResult>;
-    sync(options?: SyncOptions): Promise<SyncResult<CalendarEventRecord>>;
-    /** Incremental sync using Calendar syncToken. */
-    private syncIncremental;
-    /** Full sync using timeMin. */
-    private syncFull;
-    private ensureConnected;
-    private mapEvent;
-}