botinabox 2.5.0 → 2.5.1

package/README.md

@@ -24,7 +24,7 @@ A modular TypeScript framework for building multi-agent bots with LLM orchestrat
 - **Event-driven hooks** -- Priority-ordered, filter-based event bus for decoupled communication.
 - **Budget controls** -- Per-agent and global cost tracking with warning thresholds and hard stops.
 - **Scheduling** -- Database-backed cron and one-time schedules.
-- **Connectors** -- Google Gmail and Calendar via OAuth2 and service account.
+- **Connectors** -- Google Gmail, Calendar, and Drive via OAuth2 and service account.
 - **Security** -- Input sanitization, field length enforcement, audit logging, HMAC webhook verification.
 
 ## Install
@@ -110,7 +110,7 @@ tasks.startPolling();
 | `botinabox/slack` | Slack channel adapter (`SlackAdapter`) |
 | `botinabox/discord` | Discord channel adapter (`DiscordAdapter`) |
 | `botinabox/webhook` | Webhook channel adapter with HMAC verification (`WebhookAdapter`) |
-| `botinabox/google` | Google connectors -- Gmail and Calendar via OAuth2 |
+| `botinabox/google` | Google connectors -- Gmail, Calendar, and Drive via OAuth2 |
 
 ## Architecture
 

package/bin/botinabox.mjs

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import('../dist/cli.js').then(m => m.main(process.argv.slice(2)));

package/dist/channels/slack/index.d.ts

@@ -1,5 +1,5 @@
 import { C as ChannelAdapter, c as ChannelMeta, a as ChannelCapabilities, I as InboundMessage, b as ChannelConfig, H as HealthStatus, O as OutboundPayload, S as SendResult } from '../../channel-06G0vbIn.js';
-import { H as HookBus, c as ChatPipeline } from '../../chat-pipeline-DuNX5WoL.js';
+import { H as HookBus, c as ChatPipeline } from '../../chat-pipeline-BWrtVqEP.js';
 import 'better-sqlite3';
 import '../../provider-DLGUfnNx.js';
 

package/dist/{chat-pipeline-DuNX5WoL.d.ts → chat-pipeline-BWrtVqEP.d.ts}

@@ -584,8 +584,6 @@ interface ChatPipelineConfig {
     model?: string;
     /** Enable LLM fallback routing (default: false) */
     llmRouting?: boolean;
-    /** Skip the ack layer — no fast response before task dispatch (default: false) */
-    skipAck?: boolean;
     /** TaskQueue instance — required for task dispatch */
     tasks: {
         create(task: Record<string, unknown>): Promise<string>;
@@ -610,7 +608,6 @@ declare class ChatPipeline {
     private readonly dedupWindowMs;
     private readonly tasks;
     private readonly wakeups;
-    private readonly skipAck;
     private readonly threadChannelMap;
     /** Last dispatch promise — exposed for testing. */
     lastDispatch: Promise<void>;

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

@@ -54,6 +54,29 @@ interface EmailRecord {
     labels: string[];
     isRead: boolean;
 }
+interface DriveOwner {
+    displayName: string;
+    emailAddress: string;
+}
+interface DriveFileRecord {
+    driveFileId: string;
+    account: string;
+    name: string;
+    mimeType: string;
+    webViewLink: string;
+    webContentLink?: string;
+    /** ISO 8601 */
+    modifiedTime: string;
+    /** ISO 8601 */
+    createdTime: string;
+    size?: number;
+    parents?: string[];
+    description?: string;
+    owners: DriveOwner[];
+    lastModifyingUser?: DriveOwner;
+    starred: boolean;
+    trashed: boolean;
+}
 interface CalendarAttendee {
     email: string;
     displayName?: string;
@@ -209,4 +232,47 @@ declare class GoogleCalendarConnector implements Connector<CalendarEventRecord>
     private mapEvent;
 }
 
-export { type CalendarAttendee, type CalendarConnectorOpts, type CalendarEventRecord, type EmailAddress, type EmailRecord, type GmailConnectorOpts, GoogleCalendarConnector, type GoogleConnectorConfig, GoogleGmailConnector, type GoogleOAuthConfig, type GoogleServiceAccountConfig, type GoogleTokens, createOAuth2Client, createServiceAccountClient, exchangeCode, getAuthUrl, loadTokens, refreshIfNeeded, saveTokens };
+/**
+ * Google Drive connector — pulls file metadata from Drive.
+ *
+ * Produces `DriveFileRecord` objects. Does NOT write to any database
+ * table; the consuming application decides how to store records.
+ *
+ * Supports incremental sync via Drive Changes API (startPageToken)
+ * and full sync via files.list with optional folder/MIME filters.
+ */
+
+interface DriveConnectorOpts {
+    /** 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>;
+}
+declare class GoogleDriveConnector implements Connector<DriveFileRecord> {
+    readonly id = "google-drive";
+    readonly meta: ConnectorMeta;
+    private tokenLoader?;
+    private tokenSaver?;
+    private client;
+    private config;
+    private tokens;
+    private drive;
+    constructor(opts?: DriveConnectorOpts);
+    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<DriveFileRecord>>;
+    /** Incremental sync using Drive Changes API. */
+    private syncIncremental;
+    /** Full sync using files.list. */
+    private syncFull;
+    private ensureConnected;
+    private mapFile;
+}
+
+export { type CalendarAttendee, type CalendarConnectorOpts, type CalendarEventRecord, type DriveConnectorOpts, type DriveFileRecord, type DriveOwner, type EmailAddress, type EmailRecord, type GmailConnectorOpts, GoogleCalendarConnector, type GoogleConnectorConfig, GoogleDriveConnector, GoogleGmailConnector, type GoogleOAuthConfig, type GoogleServiceAccountConfig, type GoogleTokens, createOAuth2Client, createServiceAccountClient, exchangeCode, getAuthUrl, loadTokens, refreshIfNeeded, saveTokens };

package/dist/connectors/google/index.js

@@ -235,8 +235,248 @@ var GoogleCalendarConnector = class {
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
+
+// src/connectors/google/drive-connector.ts
+var FILE_FIELDS = "id, name, mimeType, webViewLink, webContentLink, modifiedTime, createdTime, size, parents, description, owners, lastModifyingUser, starred, trashed";
+var GoogleDriveConnector = class {
+  id = "google-drive";
+  meta = {
+    displayName: "Google Drive",
+    provider: "google",
+    dataType: "document"
+  };
+  tokenLoader;
+  tokenSaver;
+  client = null;
+  config = null;
+  tokens = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  drive = 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/drive.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.drive = google.drive({ version: "v3", auth: this.client });
+  }
+  async disconnect() {
+    this.client = null;
+    this.drive = null;
+    this.tokens = null;
+    this.config = null;
+  }
+  async healthCheck() {
+    try {
+      this.ensureConnected();
+      const res = await this.drive.about.get({ fields: "user" });
+      return { ok: true, account: res.data.user?.emailAddress ?? this.config.account };
+    } catch (err) {
+      return { ok: false, error: errorMessage2(err) };
+    }
+  }
+  // ── Auth ───────────────────────────────────────────────────────
+  async authenticate(codeProvider) {
+    if (!this.config) {
+      return { success: false, error: "Call connect() first." };
+    }
+    try {
+      if (!this.config.oauth) {
+        return { success: false, error: "OAuth config required. 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/drive.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.drive = google.drive({ version: "v3", auth: this.client });
+      return { success: true, account: this.config.account };
+    } catch (err) {
+      return { success: false, error: errorMessage2(err) };
+    }
+  }
+  // ── Sync ───────────────────────────────────────────────────────
+  async sync(options) {
+    this.ensureConnected();
+    if (options?.cursor) {
+      return this.syncIncremental(options.cursor, options);
+    }
+    return this.syncFull(options);
+  }
+  /** Incremental sync using Drive Changes API. */
+  async syncIncremental(startPageToken, options) {
+    const records = [];
+    const errors = [];
+    let pageToken = startPageToken;
+    let newStartPageToken;
+    try {
+      do {
+        const res = await this.drive.changes.list({
+          pageToken,
+          fields: `nextPageToken, newStartPageToken, changes(fileId, removed, file(${FILE_FIELDS}))`,
+          pageSize: options?.limit ? Math.min(options.limit - records.length, 100) : 100
+        });
+        for (const change of res.data.changes ?? []) {
+          try {
+            if (change.removed || !change.file) {
+              if (change.fileId) {
+                records.push({
+                  driveFileId: change.fileId,
+                  account: this.config.account,
+                  name: "",
+                  mimeType: "",
+                  webViewLink: "",
+                  modifiedTime: (/* @__PURE__ */ new Date()).toISOString(),
+                  createdTime: "",
+                  owners: [],
+                  starred: false,
+                  trashed: true
+                });
+              }
+            } else {
+              records.push(this.mapFile(change.file));
+            }
+          } catch (err) {
+            errors.push({ id: change.fileId ?? "unknown", error: errorMessage2(err) });
+          }
+          if (options?.limit && records.length >= options.limit) break;
+        }
+        pageToken = res.data.nextPageToken ?? void 0;
+        newStartPageToken = res.data.newStartPageToken ?? void 0;
+      } while (pageToken && (!options?.limit || records.length < options.limit));
+    } catch (err) {
+      if (err?.code === 403 || err?.code === 404) {
+        return this.syncFull(options);
+      }
+      throw err;
+    }
+    return {
+      records,
+      cursor: newStartPageToken,
+      hasMore: !!pageToken,
+      errors
+    };
+  }
+  /** Full sync using files.list. */
+  async syncFull(options) {
+    const records = [];
+    const errors = [];
+    const maxResults = options?.limit ?? 500;
+    const queryParts = ["trashed = false"];
+    const folderId = options?.filters?.folderId;
+    if (folderId) {
+      queryParts.push(`'${folderId}' in parents`);
+    }
+    const mimeType = options?.filters?.mimeType;
+    if (mimeType) {
+      queryParts.push(`mimeType = '${mimeType}'`);
+    }
+    if (options?.since) {
+      queryParts.push(`modifiedTime > '${new Date(options.since).toISOString()}'`);
+    }
+    const q = queryParts.join(" and ");
+    let pageToken;
+    do {
+      const res = await this.drive.files.list({
+        q,
+        fields: `nextPageToken, files(${FILE_FIELDS})`,
+        orderBy: "modifiedTime desc",
+        pageSize: Math.min(maxResults - records.length, 100),
+        ...pageToken ? { pageToken } : {}
+      });
+      for (const file of res.data.files ?? []) {
+        try {
+          records.push(this.mapFile(file));
+        } catch (err) {
+          errors.push({ id: file.id, error: errorMessage2(err) });
+        }
+        if (records.length >= maxResults) break;
+      }
+      pageToken = res.data.nextPageToken ?? void 0;
+    } while (pageToken && records.length < maxResults);
+    const tokenRes = await this.drive.changes.getStartPageToken({});
+    const cursor = tokenRes.data.startPageToken ?? void 0;
+    return {
+      records,
+      cursor,
+      hasMore: !!pageToken,
+      errors
+    };
+  }
+  // ── Internals ─────────────────────────────────────────────────
+  ensureConnected() {
+    if (!this.drive || !this.config) {
+      throw new Error("GoogleDriveConnector is not connected. Call connect() first.");
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mapFile(file) {
+    const mapOwner = (o) => ({
+      displayName: o?.displayName ?? "",
+      emailAddress: o?.emailAddress ?? ""
+    });
+    return {
+      driveFileId: file.id,
+      account: this.config.account,
+      name: file.name ?? "(Untitled)",
+      mimeType: file.mimeType ?? "",
+      webViewLink: file.webViewLink ?? "",
+      webContentLink: file.webContentLink ?? void 0,
+      modifiedTime: file.modifiedTime ?? (/* @__PURE__ */ new Date()).toISOString(),
+      createdTime: file.createdTime ?? "",
+      size: file.size ? parseInt(file.size, 10) : void 0,
+      parents: file.parents ?? void 0,
+      description: file.description ?? void 0,
+      owners: (file.owners ?? []).map(mapOwner),
+      lastModifyingUser: file.lastModifyingUser ? mapOwner(file.lastModifyingUser) : void 0,
+      starred: file.starred ?? false,
+      trashed: file.trashed ?? false
+    };
+  }
+};
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 export {
   GoogleCalendarConnector,
+  GoogleDriveConnector,
   GoogleGmailConnector,
   createOAuth2Client,
   createServiceAccountClient,

package/dist/index.d.ts

@@ -4,8 +4,8 @@ import { T as TokenUsage, L as LLMProvider, M as ModelInfo, R as ResolvedModel,
 export { a as ChatParams, b as ChatResult, c as ContentBlock, d as ToolUse } from './provider-DLGUfnNx.js';
 import { C as ConnectorConfig } from './connector-B4Mj0P1b.js';
 export { A as AuthResult, a as Connector, b as ConnectorMeta, P as PushResult, S as SyncOptions, c as SyncResult } from './connector-B4Mj0P1b.js';
-import { C as ChatResponderConfig, D as DataStore, H as HookBus, M as MessageStore, a as ChatResponder, b as MessageInterpreter, E as Extractor } from './chat-pipeline-DuNX5WoL.js';
-export { c as ChatPipeline, d as ChatPipelineConfig, e as DataStoreError, f as EntityContextDef, g as EntityFileSpec, h as EntitySource, i as ExtractedFile, j as ExtractedMemory, k as ExtractedTask, l as ExtractedUserContext, F as Filter, m as HookHandler, n as HookOptions, o as HookRegistration, I as InterpretationResult, L as LLMCallFn, p as MessageInterpreterConfig, P as PkLookup, Q as QueryOptions, R as RelationDef, q as RoutingDecision, r as RoutingRule, s as Row, S as SeedItem, t as SqliteAdapter, u as StoreResult, v as StoredAttachment, T as TableDefinition, w as TableInfoRow, x as TriageRouter, y as TriageRouterConfig, U as Unsubscribe } from './chat-pipeline-DuNX5WoL.js';
+import { C as ChatResponderConfig, D as DataStore, H as HookBus, M as MessageStore, a as ChatResponder, b as MessageInterpreter, E as Extractor } from './chat-pipeline-BWrtVqEP.js';
+export { c as ChatPipeline, d as ChatPipelineConfig, e as DataStoreError, f as EntityContextDef, g as EntityFileSpec, h as EntitySource, i as ExtractedFile, j as ExtractedMemory, k as ExtractedTask, l as ExtractedUserContext, F as Filter, m as HookHandler, n as HookOptions, o as HookRegistration, I as InterpretationResult, L as LLMCallFn, p as MessageInterpreterConfig, P as PkLookup, Q as QueryOptions, R as RelationDef, q as RoutingDecision, r as RoutingRule, s as Row, S as SeedItem, t as SqliteAdapter, u as StoreResult, v as StoredAttachment, T as TableDefinition, w as TableInfoRow, x as TriageRouter, y as TriageRouterConfig, U as Unsubscribe } from './chat-pipeline-BWrtVqEP.js';
 import 'better-sqlite3';
 
 /** Execution adapter types — Story 1.5 / 3.4 / 3.5 */
@@ -1791,7 +1791,6 @@ declare class LoopDetector {
 
 interface FeedbackEntry {
     agentId: string;
-    userId?: string;
     taskId?: string;
     issue: string;
     rootCause?: string;
@@ -1806,7 +1805,6 @@ interface PlaybookEntry {
     rule: string;
     feedbackIds: string[];
     projectScoped: boolean;
-    clientId?: string;
     agentIds?: string[];
 }
 interface SkillEntry {
@@ -1841,7 +1839,6 @@ declare class LearningPipeline {
      */
     listFeedback(filter?: {
         agentId?: string;
-        userId?: string;
         severity?: string;
         repeatable?: boolean;
     }): Promise<Array<Record<string, unknown>>>;

package/dist/index.js

@@ -1662,7 +1662,6 @@ var ChatPipeline = class {
     this.messageFilter = config.messageFilter;
     this.capabilities = config.capabilities;
     this.dedupWindowMs = config.dedupWindowMs ?? DEFAULT_DEDUP_WINDOW_MS;
-    this.skipAck = config.skipAck ?? false;
     this.tasks = config.tasks;
     this.wakeups = config.wakeups;
     this.messageStore = new MessageStore(db, hooks);
@@ -1696,7 +1695,6 @@ var ChatPipeline = class {
   dedupWindowMs;
   tasks;
   wakeups;
-  skipAck;
   // In-memory thread → channel mapping for response routing
   // (before thread_task_map exists)
   threadChannelMap = /* @__PURE__ */ new Map();
@@ -1733,26 +1731,24 @@ var ChatPipeline = class {
         const dir = m.direction === "inbound" ? "User" : "Bot";
         return `${dir}: ${m.body?.slice(0, 200) ?? ""}`;
       }).join("\n");
-      if (!this.skipAck) {
-        const ackResponse = await this.responder.respond({
-          messageBody: msg.body,
-          threadId: threadTs,
-          channel: this.channel,
-          capabilities: this.capabilities,
-          additionalContext: historyContext ? `
+      const ackResponse = await this.responder.respond({
+        messageBody: msg.body,
+        threadId: threadTs,
+        channel: this.channel,
+        capabilities: this.capabilities,
+        additionalContext: historyContext ? `
 
 Recent conversation history:
 ${historyContext}` : void 0
-        });
-        await this.responder.sendResponse({
-          text: ackResponse,
-          channel: this.channel,
-          threadId: threadTs,
-          source: "responder",
-          skipFilter: true,
-          skipRedundancyCheck: true
-        });
-      }
+      });
+      await this.responder.sendResponse({
+        text: ackResponse,
+        channel: this.channel,
+        threadId: threadTs,
+        source: "responder",
+        skipFilter: true,
+        skipRedundancyCheck: true
+      });
       const dispatchPromise = this.interpretAndDispatch(messageId, msg, threadTs, channelId);
       this.lastDispatch = dispatchPromise;
       void dispatchPromise;
@@ -2970,7 +2966,6 @@ function defineCoreTables(db) {
     columns: {
       id: "TEXT PRIMARY KEY",
       agent_id: "TEXT NOT NULL",
-      user_id: "TEXT",
       task_id: "TEXT",
       issue: "TEXT NOT NULL",
       root_cause: "TEXT",
@@ -2983,8 +2978,7 @@ function defineCoreTables(db) {
     },
     tableConstraints: [
       "CREATE INDEX IF NOT EXISTS idx_feedback_agent ON feedback(agent_id, created_at)",
-      "CREATE INDEX IF NOT EXISTS idx_feedback_issue ON feedback(issue)",
-      "CREATE INDEX IF NOT EXISTS idx_feedback_user ON feedback(user_id)"
+      "CREATE INDEX IF NOT EXISTS idx_feedback_issue ON feedback(issue)"
     ]
   });
   db.define("playbooks", {
@@ -2994,7 +2988,6 @@ function defineCoreTables(db) {
       rule: "TEXT NOT NULL",
       feedback_ids: "TEXT NOT NULL DEFAULT '[]'",
       project_scoped: "INTEGER NOT NULL DEFAULT 1",
-      client_id: "TEXT",
       created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
       updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
       deleted_at: "TEXT"
@@ -3120,18 +3113,6 @@ var CORE_MIGRATIONS = [
   {
     version: "006_schedules_next_index",
     sql: `CREATE INDEX IF NOT EXISTS idx_schedules_next ON schedules(enabled, next_fire_at) WHERE deleted_at IS NULL`
-  },
-  {
-    version: "biab:2.5.0:feedback-user-id",
-    sql: `ALTER TABLE feedback ADD COLUMN user_id TEXT`
-  },
-  {
-    version: "biab:2.5.0:feedback-user-idx",
-    sql: `CREATE INDEX IF NOT EXISTS idx_feedback_user ON feedback(user_id)`
-  },
-  {
-    version: "biab:2.5.0:playbooks-client-id",
-    sql: `ALTER TABLE playbooks ADD COLUMN client_id TEXT`
   }
 ];
 
@@ -5951,7 +5932,6 @@ var LearningPipeline = class {
   async captureFeedback(entry) {
     const row = await this.db.insert("feedback", {
       agent_id: entry.agentId,
-      user_id: entry.userId,
       task_id: entry.taskId,
       issue: entry.issue,
       root_cause: entry.rootCause,
@@ -5965,7 +5945,6 @@ var LearningPipeline = class {
     await this.hooks.emit("learning.feedback_captured", {
       feedbackId,
       agentId: entry.agentId,
-      userId: entry.userId,
       issue: entry.issue,
       severity: entry.severity
     });
@@ -5980,7 +5959,6 @@ var LearningPipeline = class {
   async listFeedback(filter) {
     const where = {};
     if (filter?.agentId) where["agent_id"] = filter.agentId;
-    if (filter?.userId) where["user_id"] = filter.userId;
     if (filter?.severity) where["severity"] = filter.severity;
     if (filter?.repeatable !== void 0) where["repeatable"] = filter.repeatable ? 1 : 0;
     return this.db.query("feedback", Object.keys(where).length ? { where } : void 0);
@@ -6022,8 +6000,7 @@ var LearningPipeline = class {
       pattern: entry.pattern,
       rule: entry.rule,
       feedback_ids: JSON.stringify(entry.feedbackIds),
-      project_scoped: entry.projectScoped ? 1 : 0,
-      client_id: entry.clientId
+      project_scoped: entry.projectScoped ? 1 : 0
     });
     const playbookId = row["id"];
     if (entry.agentIds) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botinabox",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "description": "Bot in a Box — framework for building multi-agent bots",
   "type": "module",
   "main": "./dist/index.js",