botinabox 2.4.2 → 2.5.0

package/dist/connectors/google/oauth.js

@@ -1,112 +0,0 @@
-/**
- * Google OAuth2 helpers.
- *
- * Uses dynamic `import('googleapis')` so the package is only required
- * at runtime by consumers who actually use the Google connectors.
- */
-// ── Lazy googleapis import ─────────────────────────────────────────
-let _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;
-}
-// ── Public helpers ─────────────────────────────────────────────────
-/**
- * Create a Google OAuth2 client from app credentials.
- */
-export async function createOAuth2Client(config) {
-    const google = await getGoogle();
-    return new google.auth.OAuth2(config.clientId, config.clientSecret, config.redirectUri);
-}
-/**
- * Generate the consent screen URL for the given scopes.
- */
-export function getAuthUrl(client, scopes) {
-    return client.generateAuthUrl({
-        access_type: 'offline',
-        prompt: 'consent',
-        scope: scopes,
-    });
-}
-/**
- * Exchange an authorization code for tokens.
- */
-export async function exchangeCode(client, code) {
-    const { tokens } = await client.getToken(code);
-    return tokens;
-}
-// ── Service account auth ──────────────────────────────────────────
-/**
- * Create an authenticated client using a service account with
- * domain-wide delegation (impersonation). No browser flow needed.
- */
-export 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();
-}
-// ── Token persistence ──────────────────────────────────────────────
-/**
- * Load persisted tokens via a generic getter callback.
- *
- * @param getter  Reads a string value by key (e.g. SecretStore.get)
- * @param accountKey  Unique key prefix for this account
- */
-export async function loadTokens(getter, accountKey) {
-    const raw = await getter(`google_tokens:${accountKey}`);
-    if (!raw)
-        return null;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Persist tokens via a generic setter callback.
- *
- * @param setter  Writes a string value by key (e.g. SecretStore.set)
- * @param accountKey  Unique key prefix for this account
- * @param tokens  Tokens to persist
- */
-export async function saveTokens(setter, accountKey, tokens) {
-    await setter(`google_tokens:${accountKey}`, JSON.stringify(tokens));
-}
-/**
- * Refresh the access token if it has expired (or is about to within 60 s).
- *
- * If the token was refreshed and a `saver` callback is provided, the new
- * tokens are persisted automatically.
- */
-export async function refreshIfNeeded(client, tokens, saver) {
-    const buffer = 60_000; // 60 seconds
-    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 ?? undefined,
-        token_type: credentials.token_type ?? 'Bearer',
-    };
-    if (saver) {
-        await saver(refreshed);
-    }
-    return refreshed;
-}

package/dist/connectors/google/types.d.ts

@@ -1,78 +0,0 @@
-/** Google connector types. */
-import type { ConnectorConfig } from '../../shared/types/connector.js';
-export interface GoogleOAuthConfig {
-    clientId: string;
-    clientSecret: string;
-    redirectUri: string;
-}
-export interface GoogleTokens {
-    access_token: string;
-    refresh_token?: string;
-    expiry_date?: number;
-    token_type: string;
-}
-export interface GoogleServiceAccountConfig {
-    /** Path to service account key JSON file */
-    keyFile?: string;
-    /** Inline service account credentials (alternative to keyFile) */
-    credentials?: {
-        client_email: string;
-        private_key: string;
-        project_id?: string;
-    };
-    /** Email of the user to impersonate via domain-wide delegation */
-    subject: string;
-}
-export interface GoogleConnectorConfig extends ConnectorConfig {
-    /** Google account email */
-    account: string;
-    /** OAuth2 user auth (requires browser flow) */
-    oauth?: GoogleOAuthConfig;
-    /** Service account auth (headless, for cloud deployments) */
-    serviceAccount?: GoogleServiceAccountConfig;
-    scopes?: string[];
-}
-export interface EmailAddress {
-    name?: string;
-    email: string;
-}
-export interface EmailRecord {
-    gmailId: string;
-    threadId: string;
-    account: string;
-    subject: string;
-    from: EmailAddress;
-    to: EmailAddress[];
-    cc: EmailAddress[];
-    bcc: EmailAddress[];
-    /** ISO 8601 timestamp */
-    date: string;
-    snippet: string;
-    body?: string;
-    labels: string[];
-    isRead: boolean;
-}
-export interface CalendarAttendee {
-    email: string;
-    displayName?: string;
-    responseStatus?: string;
-}
-export interface CalendarEventRecord {
-    googleEventId: string;
-    calendarId: string;
-    account: string;
-    title: string;
-    description?: string;
-    location?: string;
-    /** ISO 8601 timestamp */
-    startAt: string;
-    /** ISO 8601 timestamp */
-    endAt: string;
-    allDay: boolean;
-    timezone?: string;
-    status: string;
-    organizerEmail: string;
-    attendees: CalendarAttendee[];
-    recurrence?: string[];
-    htmlLink?: string;
-}

package/dist/connectors/google/types.js

@@ -1,2 +0,0 @@
-/** Google connector types. */
-export {};

package/dist/core/chat/auto-discovery.d.ts

@@ -1,16 +0,0 @@
-/**
- * Auto-discovery for channel adapters.
- * Scans @botinabox/* packages for botinabox.type === 'channel'.
- * Story 4.1
- */
-import type { ChannelAdapter } from "./types.js";
-type Importer = (packageName: string) => Promise<unknown>;
-/**
- * Scans nodeModulesPath/@botinabox/{pkg}/package.json for each package in the scope.
- * If pkg.botinabox?.type === 'channel', dynamically imports the package
- * and returns the discovered ChannelAdapter instances.
- *
- * The optional importer parameter allows injection for testing.
- */
-export declare function discoverChannels(nodeModulesPath: string, importer?: Importer): Promise<ChannelAdapter[]>;
-export {};

package/dist/core/chat/auto-discovery.js

@@ -1,54 +0,0 @@
-/**
- * Auto-discovery for channel adapters.
- * Scans @botinabox/* packages for botinabox.type === 'channel'.
- * Story 4.1
- */
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-/**
- * Scans nodeModulesPath/@botinabox/{pkg}/package.json for each package in the scope.
- * If pkg.botinabox?.type === 'channel', dynamically imports the package
- * and returns the discovered ChannelAdapter instances.
- *
- * The optional importer parameter allows injection for testing.
- */
-export async function discoverChannels(nodeModulesPath, importer = (name) => import(name)) {
-    const scopeDir = join(nodeModulesPath, "@botinabox");
-    let entries;
-    try {
-        entries = await readdir(scopeDir);
-    }
-    catch {
-        // No @botinabox scope directory — gracefully return empty
-        return [];
-    }
-    const adapters = [];
-    for (const entry of entries) {
-        const pkgPath = join(scopeDir, entry, "package.json");
-        let pkg;
-        try {
-            const raw = await readFile(pkgPath, "utf8");
-            pkg = JSON.parse(raw);
-        }
-        catch {
-            continue;
-        }
-        const botinabox = pkg.botinabox;
-        if (botinabox?.type !== "channel") {
-            continue;
-        }
-        const packageName = pkg.name;
-        if (!packageName) {
-            continue;
-        }
-        try {
-            const mod = await importer(packageName);
-            const adapter = "default" in mod && mod.default ? mod.default : mod;
-            adapters.push(adapter);
-        }
-        catch {
-            // Failed to import — skip silently
-        }
-    }
-    return adapters;
-}

package/dist/core/chat/channel-registry.d.ts

@@ -1,45 +0,0 @@
-/**
- * ChannelRegistry — manages channel adapter lifecycle.
- * Story 4.1
- */
-import type { ChannelAdapter, HealthStatus } from "./types.js";
-export declare class ChannelRegistryError extends Error {
-    constructor(message: string);
-}
-export declare class ChannelRegistry {
-    private readonly adapters;
-    private started;
-    /**
-     * Register a channel adapter.
-     * Throws if an adapter with the same id is already registered.
-     * If registry is already started, immediately connects the adapter.
-     */
-    register(adapter: ChannelAdapter, config?: unknown): void;
-    /**
-     * Unregister a channel adapter.
-     * Disconnects the adapter if it exists.
-     */
-    unregister(id: string): Promise<void>;
-    /**
-     * Reconfigure an adapter: disconnect, update config, reconnect.
-     */
-    reconfigure(id: string, config: unknown): Promise<void>;
-    /**
-     * Run health checks on all registered adapters.
-     */
-    healthCheck(): Promise<Record<string, HealthStatus>>;
-    /** Check if an adapter is registered. */
-    has(id: string): boolean;
-    /** Get an adapter by ID. */
-    get(id: string): ChannelAdapter | undefined;
-    /** List all registered adapters. */
-    list(): ChannelAdapter[];
-    /**
-     * Start: connect all registered adapters and mark registry as started.
-     */
-    start(): Promise<void>;
-    /**
-     * Stop: disconnect all registered adapters.
-     */
-    stop(): Promise<void>;
-}

package/dist/core/chat/channel-registry.js

@@ -1,96 +0,0 @@
-/**
- * ChannelRegistry — manages channel adapter lifecycle.
- * Story 4.1
- */
-export class ChannelRegistryError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ChannelRegistryError";
-    }
-}
-export class ChannelRegistry {
-    adapters = new Map();
-    started = false;
-    /**
-     * Register a channel adapter.
-     * Throws if an adapter with the same id is already registered.
-     * If registry is already started, immediately connects the adapter.
-     */
-    register(adapter, config) {
-        if (this.adapters.has(adapter.id)) {
-            throw new ChannelRegistryError(`Channel adapter already registered: ${adapter.id}`);
-        }
-        this.adapters.set(adapter.id, { adapter, config });
-        if (this.started) {
-            void adapter.connect((config ?? {}));
-        }
-    }
-    /**
-     * Unregister a channel adapter.
-     * Disconnects the adapter if it exists.
-     */
-    async unregister(id) {
-        const entry = this.adapters.get(id);
-        if (!entry)
-            return;
-        await entry.adapter.disconnect();
-        this.adapters.delete(id);
-    }
-    /**
-     * Reconfigure an adapter: disconnect, update config, reconnect.
-     */
-    async reconfigure(id, config) {
-        const entry = this.adapters.get(id);
-        if (!entry) {
-            throw new ChannelRegistryError(`Channel adapter not found: ${id}`);
-        }
-        await entry.adapter.disconnect();
-        entry.config = config;
-        await entry.adapter.connect((config ?? {}));
-    }
-    /**
-     * Run health checks on all registered adapters.
-     */
-    async healthCheck() {
-        const results = {};
-        for (const [id, entry] of this.adapters) {
-            try {
-                results[id] = await entry.adapter.healthCheck();
-            }
-            catch (err) {
-                results[id] = { ok: false, error: String(err) };
-            }
-        }
-        return results;
-    }
-    /** Check if an adapter is registered. */
-    has(id) {
-        return this.adapters.has(id);
-    }
-    /** Get an adapter by ID. */
-    get(id) {
-        return this.adapters.get(id)?.adapter;
-    }
-    /** List all registered adapters. */
-    list() {
-        return Array.from(this.adapters.values()).map((e) => e.adapter);
-    }
-    /**
-     * Start: connect all registered adapters and mark registry as started.
-     */
-    async start() {
-        this.started = true;
-        for (const entry of this.adapters.values()) {
-            await entry.adapter.connect((entry.config ?? {}));
-        }
-    }
-    /**
-     * Stop: disconnect all registered adapters.
-     */
-    async stop() {
-        for (const entry of this.adapters.values()) {
-            await entry.adapter.disconnect();
-        }
-        this.started = false;
-    }
-}

package/dist/core/chat/chat-pipeline.d.ts

@@ -1,113 +0,0 @@
-/**
- * ChatPipeline — configurable 6-layer chat orchestration.
- * Story 7.4
- *
- * Replaces duplicated handler code across apps with a single configurable
- * pipeline. Apps provide: system prompt, routing rules, LLM call function,
- * and optional message filter. Everything else is framework-level.
- *
- * Layers:
- *   1. Dedup + Storage (MessageStore)
- *   2. Fast Response (ChatResponder)
- *   3. Interpretation (MessageInterpreter)
- *   4. Post-Interpretation Response
- *   5. Task Dispatch (TriageRouter)
- *   6. Task Execution Response
- */
-import type { DataStore } from '../data/data-store.js';
-import type { HookBus } from '../hooks/hook-bus.js';
-import type { InboundMessage } from './types.js';
-import { MessageStore } from './message-store.js';
-import { ChatResponder } from './chat-responder.js';
-import type { ChatResponderConfig } from './chat-responder.js';
-import { MessageInterpreter } from './message-interpreter.js';
-import type { Extractor } from './message-interpreter.js';
-import { TriageRouter } from './triage-router.js';
-import type { RoutingRule } from './triage-router.js';
-export interface ChatPipelineConfig {
-    /** LLM call function for chat responses and interpretation */
-    llmCall: ChatResponderConfig['llmCall'];
-    /** System prompt for the conversational responder */
-    systemPrompt: string;
-    /** Agent routing rules for task dispatch */
-    routingRules: RoutingRule[];
-    /** Default agent when no rule matches */
-    fallbackAgent: string;
-    /** Optional message filter — return false to ignore a message */
-    messageFilter?: (msg: InboundMessage) => boolean;
-    /** Optional capabilities description for the responder */
-    capabilities?: string;
-    /** Channel this pipeline handles (default: 'slack') */
-    channel?: string;
-    /** Custom extractors for MessageInterpreter */
-    extractors?: Extractor[];
-    /** Dedup window in ms (default: 300_000 = 5 min) */
-    dedupWindowMs?: number;
-    /** Model for fast responses (default: 'fast') */
-    model?: string;
-    /** Enable LLM fallback routing (default: false) */
-    llmRouting?: boolean;
-    /** TaskQueue instance — required for task dispatch */
-    tasks: {
-        create(task: Record<string, unknown>): Promise<string>;
-        update(id: string, changes: Record<string, unknown>): Promise<void>;
-        get(id: string): Promise<Record<string, unknown> | undefined>;
-    };
-    /** WakeupQueue instance — required for agent waking */
-    wakeups: {
-        enqueue(agentId: string, source: string, context?: Record<string, unknown>): Promise<string>;
-    };
-}
-export declare class ChatPipeline {
-    private db;
-    private hooks;
-    readonly messageStore: MessageStore;
-    readonly responder: ChatResponder;
-    readonly interpreter: MessageInterpreter;
-    readonly router: TriageRouter;
-    private readonly channel;
-    private readonly messageFilter?;
-    private readonly capabilities?;
-    private readonly dedupWindowMs;
-    private readonly tasks;
-    private readonly wakeups;
-    private readonly threadChannelMap;
-    /** Last dispatch promise — exposed for testing. */
-    lastDispatch: Promise<void>;
-    constructor(db: DataStore, hooks: HookBus, config: ChatPipelineConfig);
-    /**
-     * Resolve the Slack channel ID for a thread (for response delivery).
-     */
-    resolveChannel(threadId: string, taskId?: string): Promise<string | undefined>;
-    /**
-     * Register the 6-layer pipeline on the HookBus.
-     */
-    private registerHandlers;
-    /**
-     * Check and record message dedup (SHA256 hash, configurable window).
-     */
-    private isDuplicate;
-    /**
-     * Async interpretation + task dispatch (Layers 3-5).
-     *
-     * ALWAYS creates a task programmatically — task creation does not depend
-     * on LLM classification. Interpretation enriches but never gates dispatch.
-     */
-    private interpretAndDispatch;
-    /**
-     * Programmatic task creation — guaranteed, no LLM dependency.
-     */
-    private guaranteedTaskDispatch;
-    /**
-     * Route and dispatch extracted tasks.
-     */
-    private dispatchTasks;
-    /**
-     * Resolve Slack channel ID from thread_task_map or in-memory fallback.
-     */
-    private resolveChannelId;
-    /**
-     * Build human-readable interpretation summary.
-     */
-    private buildSummary;
-}