botinabox 2.5.2 → 2.5.3

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;
-}

package/dist/connectors/google/calendar-connector.js

@@ -1,243 +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 { createOAuth2Client, createServiceAccountClient, getAuthUrl, exchangeCode, loadTokens, saveTokens, refreshIfNeeded, } from './oauth.js';
-// ── Connector ──────────────────────────────────────────────────────
-export class GoogleCalendarConnector {
-    id = 'google-calendar';
-    meta = {
-        displayName: 'Google Calendar',
-        provider: 'google',
-        dataType: 'calendar',
-    };
-    tokenLoader;
-    tokenSaver;
-    client = null;
-    config = null;
-    tokens = null;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    calendar = 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/calendar.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)
-                : undefined);
-            this.client.setCredentials(this.tokens);
-        }
-        else {
-            throw new Error('Either serviceAccount or oauth config is required');
-        }
-        const { google } = await import('googleapis');
-        this.calendar = google.calendar({ version: 'v3', auth: this.client });
-    }
-    async disconnect() {
-        this.client = null;
-        this.calendar = null;
-        this.tokens = null;
-        this.config = null;
-    }
-    async healthCheck() {
-        try {
-            this.ensureConnected();
-            const res = await this.calendar.calendarList.list({ maxResults: 1 });
-            const primary = (res.data.items ?? []).find(
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (c) => c.primary);
-            return { ok: true, account: primary?.id ?? this.config.account };
-        }
-        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/calendar.readonly',
-            ];
-            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.calendar = google.calendar({ version: 'v3', 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);
-        }
-        return this.syncFull(options);
-    }
-    /** Incremental sync using Calendar syncToken. */
-    async syncIncremental(syncToken, options) {
-        const calendarId = options?.filters?.calendarId ?? 'primary';
-        const records = [];
-        const errors = [];
-        let pageToken;
-        let nextSyncToken;
-        try {
-            do {
-                const res = await this.calendar.events.list({
-                    calendarId,
-                    syncToken,
-                    ...(pageToken ? { pageToken } : {}),
-                    maxResults: options?.limit ? Math.min(options.limit - records.length, 250) : 250,
-                });
-                for (const event of res.data.items ?? []) {
-                    try {
-                        records.push(this.mapEvent(event, calendarId));
-                    }
-                    catch (err) {
-                        errors.push({ id: event.id, error: errorMessage(err) });
-                    }
-                    if (options?.limit && records.length >= options.limit)
-                        break;
-                }
-                pageToken = res.data.nextPageToken ?? undefined;
-                nextSyncToken = res.data.nextSyncToken ?? undefined;
-            } while (pageToken && (!options?.limit || records.length < options.limit));
-        }
-        catch (err) {
-            // If syncToken is expired/invalid, fall back to full sync
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (err?.code === 410) {
-                return this.syncFull(options);
-            }
-            throw err;
-        }
-        return {
-            records,
-            cursor: nextSyncToken,
-            hasMore: !!pageToken,
-            errors,
-        };
-    }
-    /** Full sync using timeMin. */
-    async syncFull(options) {
-        const calendarId = options?.filters?.calendarId ?? 'primary';
-        const records = [];
-        const errors = [];
-        const maxResults = options?.limit ?? 250;
-        const timeMin = options?.since
-            ? new Date(options.since).toISOString()
-            : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(); // default: 30 days ago
-        let pageToken;
-        let nextSyncToken;
-        do {
-            const res = await this.calendar.events.list({
-                calendarId,
-                timeMin,
-                singleEvents: true,
-                orderBy: 'startTime',
-                maxResults: Math.min(maxResults - records.length, 250),
-                ...(pageToken ? { pageToken } : {}),
-            });
-            for (const event of res.data.items ?? []) {
-                try {
-                    records.push(this.mapEvent(event, calendarId));
-                }
-                catch (err) {
-                    errors.push({ id: event.id, error: errorMessage(err) });
-                }
-                if (records.length >= maxResults)
-                    break;
-            }
-            pageToken = res.data.nextPageToken ?? undefined;
-            nextSyncToken = res.data.nextSyncToken ?? undefined;
-        } while (pageToken && records.length < maxResults);
-        return {
-            records,
-            cursor: nextSyncToken,
-            hasMore: !!pageToken,
-            errors,
-        };
-    }
-    // ── Internals ─────────────────────────────────────────────────
-    ensureConnected() {
-        if (!this.calendar || !this.config) {
-            throw new Error('GoogleCalendarConnector is not connected. Call connect() first.');
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    mapEvent(event, calendarId) {
-        const start = event.start ?? {};
-        const end = event.end ?? {};
-        const allDay = !!start.date;
-        const startAt = allDay
-            ? new Date(start.date).toISOString()
-            : new Date(start.dateTime).toISOString();
-        const endAt = allDay
-            ? new Date(end.date).toISOString()
-            : new Date(end.dateTime).toISOString();
-        const attendees = (event.attendees ?? []).map(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (a) => ({
-            email: a.email,
-            displayName: a.displayName,
-            responseStatus: a.responseStatus,
-        }));
-        return {
-            googleEventId: event.id,
-            calendarId,
-            account: this.config.account,
-            title: event.summary ?? '(No title)',
-            description: event.description ?? undefined,
-            location: event.location ?? undefined,
-            startAt,
-            endAt,
-            allDay,
-            timezone: start.timeZone ?? undefined,
-            status: event.status ?? 'confirmed',
-            organizerEmail: event.organizer?.email ?? '',
-            attendees,
-            recurrence: event.recurrence ?? undefined,
-            htmlLink: event.htmlLink ?? undefined,
-        };
-    }
-}
-function errorMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}

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

@@ -1,42 +0,0 @@
-/**
- * Gmail connector — pulls email metadata and optionally sends mail.
- *
- * Produces `EmailRecord` objects. Does NOT write to any database table;
- * the consuming application decides how to store records.
- */
-import type { Connector, ConnectorMeta, AuthResult, SyncOptions, SyncResult, PushResult } from '../../shared/types/connector.js';
-import type { EmailRecord, GoogleConnectorConfig } from './types.js';
-export interface GmailConnectorOpts {
-    /** 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 GoogleGmailConnector implements Connector<EmailRecord> {
-    readonly id = "google-gmail";
-    readonly meta: ConnectorMeta;
-    private tokenLoader?;
-    private tokenSaver?;
-    private client;
-    private config;
-    private tokens;
-    private gmail;
-    constructor(opts?: GmailConnectorOpts);
-    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<EmailRecord>>;
-    /** Incremental sync using Gmail history API. */
-    private syncIncremental;
-    /** Full sync — list messages and fetch each one. */
-    private syncFull;
-    push(payload: EmailRecord): Promise<PushResult>;
-    private ensureConnected;
-    /** Fetch a single message by ID and parse into an EmailRecord. */
-    private fetchMessage;
-}