botinabox 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -6,6 +6,14 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [S
 
 ---
 
+## [0.5.2] — 2026-04-04
+
+### Added
+
+- **`authenticate()` method on Connector interface** — optional method for connectors that require OAuth or other auth flows. Accepts a `codeProvider` callback for interactive or programmatic authorization.
+- **Google connectors implement `authenticate()`** — `GoogleGmailConnector` and `GoogleCalendarConnector` now support self-authentication: generate consent URL, exchange code for tokens, persist via tokenSaver callback.
+- **`botinabox auth google` CLI** — native CLI command for Google OAuth setup: `botinabox auth google <account-email> --client-id=... --client-secret=...`. Stores tokens in the secrets table.
+
 ## [0.5.1] — 2026-04-04
 
 ### Fixed

package/dist/chunk-DSNJKNEW.js

@@ -0,0 +1,328 @@
+// 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 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;
+    this.client = await createOAuth2Client(config.oauth);
+    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,
+      async (t) => saveTokens(this.tokenSaver, config.account, t)
+    );
+    this.client.setCredentials(this.tokens);
+    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 {
+      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: "metadata",
+      metadataHeaders: ["From", "To", "Cc", "Bcc", "Subject", "Date"]
+    });
+    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 ?? "",
+      labels: msg.labelIds ?? [],
+      isRead: !(msg.labelIds ?? []).includes("UNREAD")
+    };
+  }
+};
+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,
+  loadTokens,
+  saveTokens,
+  refreshIfNeeded,
+  GoogleGmailConnector
+};

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function main(args: string[]): Promise<void>;
+
+export { main };

package/dist/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as readline from "readline";
+import * as fs from "fs";
+async function main(args) {
+  const [command, subcommand, ...rest] = args;
+  if (command === "auth" && subcommand === "google") {
+    await authGoogle(rest);
+  } else {
+    console.log("Usage:");
+    console.log("  botinabox auth google <account-email> [options]");
+    console.log("");
+    console.log("Options:");
+    console.log("  --client-id=<id>           Google OAuth client ID");
+    console.log("  --client-secret=<secret>   Google OAuth client secret");
+    console.log("  --credentials=<path>       Path to Google credentials JSON");
+    console.log("  --db=<path>                Path to SQLite database (default: ./data/lattice.db)");
+    console.log("  --scopes=<scopes>          Comma-separated OAuth scopes");
+    process.exit(1);
+  }
+}
+async function authGoogle(args) {
+  const flags = /* @__PURE__ */ new Map();
+  let account;
+  for (const arg of args) {
+    if (arg.startsWith("--")) {
+      const [key, ...valParts] = arg.slice(2).split("=");
+      flags.set(key, valParts.join("="));
+    } else if (!account) {
+      account = arg;
+    }
+  }
+  if (!account) {
+    console.error("Error: account email is required.");
+    console.error("  botinabox auth google <account-email> --client-id=... --client-secret=...");
+    process.exit(1);
+  }
+  let clientId = flags.get("client-id") ?? process.env.GOOGLE_CLIENT_ID;
+  let clientSecret = flags.get("client-secret") ?? process.env.GOOGLE_CLIENT_SECRET;
+  const credPath = flags.get("credentials");
+  if ((!clientId || !clientSecret) && credPath) {
+    if (fs.existsSync(credPath)) {
+      const creds = JSON.parse(fs.readFileSync(credPath, "utf-8"));
+      const installed = creds.installed ?? creds.web;
+      clientId = clientId ?? installed?.client_id;
+      clientSecret = clientSecret ?? installed?.client_secret;
+    }
+  }
+  if (!clientId || !clientSecret) {
+    console.error(
+      "Error: Google OAuth credentials required.\n  Set --client-id and --client-secret, or --credentials=path/to/credentials.json,\n  or GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables."
+    );
+    process.exit(1);
+  }
+  const defaultScopes = [
+    "https://www.googleapis.com/auth/gmail.readonly",
+    "https://www.googleapis.com/auth/gmail.send",
+    "https://www.googleapis.com/auth/calendar.readonly"
+  ];
+  const scopes = flags.has("scopes") ? flags.get("scopes").split(",") : defaultScopes;
+  const dbPath = flags.get("db") ?? process.env.DATABASE_PATH ?? "./data/lattice.db";
+  const { DataStore, defineCoreTables } = await import("./index.js");
+  const db = new DataStore({ dbPath });
+  defineCoreTables(db);
+  await db.init();
+  const tokenLoader = async (key) => {
+    const rows = await db.query("secrets", { where: { name: key } });
+    const row = rows.find((r) => r["deleted_at"] == null);
+    return row?.["value"] ?? null;
+  };
+  const tokenSaver = async (key, value) => {
+    const rows = await db.query("secrets", { where: { name: key } });
+    const existing = rows.find((r) => r["deleted_at"] == null);
+    if (existing) {
+      await db.update("secrets", { id: existing["id"] }, {
+        value,
+        type: "oauth2",
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else {
+      await db.insert("secrets", {
+        name: key,
+        type: "oauth2",
+        value,
+        description: `Google OAuth tokens for ${account}`
+      });
+    }
+  };
+  const { GoogleGmailConnector } = await import("./gmail-connector-2FVYTQJH.js");
+  const connector = new GoogleGmailConnector({ tokenLoader, tokenSaver });
+  connector.config = {
+    account,
+    oauth: { clientId, clientSecret, redirectUri: "urn:ietf:wg:oauth:2.0:oob" },
+    scopes
+  };
+  const codeProvider = async (authUrl) => {
+    console.log(`
+Authorize account: ${account}`);
+    console.log(`
+Open this URL in your browser:
+
+  ${authUrl}
+`);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question("Enter the authorization code: ", (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  };
+  const result = await connector.authenticate(codeProvider);
+  if (result.success) {
+    console.log(`
+Tokens saved for ${account}. Connector is ready.`);
+  } else {
+    console.error(`
+Authentication failed: ${result.error}`);
+    process.exit(1);
+  }
+  db.close();
+}
+export {
+  main
+};

package/dist/connector-B4Mj0P1b.d.ts

@@ -0,0 +1,79 @@
+/** 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;
+}
+interface AuthResult {
+    success: boolean;
+    account?: string;
+    /** URL the user must visit to authorize (for OAuth flows) */
+    authUrl?: 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>;
+    /**
+     * Run the authentication/authorization flow for this connector.
+     * For OAuth connectors, this generates the auth URL and exchanges the code for tokens.
+     *
+     * @param codeProvider - called with the auth URL; must return the authorization code.
+     *   For CLI flows, this prints the URL and reads from stdin.
+     *   For programmatic flows, the caller handles the redirect.
+     */
+    authenticate?(codeProvider: (authUrl: string) => Promise<string>): Promise<AuthResult>;
+}
+
+export type { AuthResult as A, ConnectorConfig as C, PushResult as P, SyncOptions as S, Connector as a, ConnectorMeta as b, SyncResult as c };

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

@@ -1,4 +1,4 @@
-import { C as ConnectorConfig, a as Connector, b as ConnectorMeta, S as SyncOptions, c as SyncResult, P as PushResult } from '../../connector-DDahQw-2.js';
+import { C as ConnectorConfig, a as Connector, b as ConnectorMeta, A as AuthResult, S as SyncOptions, c as SyncResult, P as PushResult } from '../../connector-B4Mj0P1b.js';
 
 /** Google connector types. */
 
@@ -137,6 +137,7 @@ declare class GoogleGmailConnector implements Connector<EmailRecord> {
         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;
@@ -178,6 +179,7 @@ declare class GoogleCalendarConnector implements Connector<CalendarEventRecord>
         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;

package/dist/connectors/google/index.js

@@ -1,296 +1,12 @@
-// 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 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;
-    this.client = await createOAuth2Client(config.oauth);
-    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,
-      async (t) => saveTokens(this.tokenSaver, config.account, t)
-    );
-    this.client.setCredentials(this.tokens);
-    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) };
-    }
-  }
-  // ── 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: "metadata",
-      metadataHeaders: ["From", "To", "Cc", "Bcc", "Subject", "Date"]
-    });
-    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 ?? "",
-      labels: msg.labelIds ?? [],
-      isRead: !(msg.labelIds ?? []).includes("UNREAD")
-    };
-  }
-};
-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);
-}
+import {
+  GoogleGmailConnector,
+  createOAuth2Client,
+  exchangeCode,
+  getAuthUrl,
+  loadTokens,
+  refreshIfNeeded,
+  saveTokens
+} from "../../chunk-DSNJKNEW.js";
 
 // src/connectors/google/calendar-connector.ts
 var GoogleCalendarConnector = class {
@@ -346,7 +62,31 @@ var GoogleCalendarConnector = class {
       );
       return { ok: true, account: primary?.id ?? this.config.account };
     } catch (err) {
-      return { ok: false, error: errorMessage2(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 {
+      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 ───────────────────────────────────────────────────────
@@ -376,7 +116,7 @@ var GoogleCalendarConnector = class {
           try {
             records.push(this.mapEvent(event, calendarId));
           } catch (err) {
-            errors.push({ id: event.id, error: errorMessage2(err) });
+            errors.push({ id: event.id, error: errorMessage(err) });
           }
           if (options?.limit && records.length >= options.limit) break;
         }
@@ -418,7 +158,7 @@ var GoogleCalendarConnector = class {
         try {
           records.push(this.mapEvent(event, calendarId));
         } catch (err) {
-          errors.push({ id: event.id, error: errorMessage2(err) });
+          errors.push({ id: event.id, error: errorMessage(err) });
         }
         if (records.length >= maxResults) break;
       }
@@ -472,7 +212,7 @@ var GoogleCalendarConnector = class {
     };
   }
 };
-function errorMessage2(err) {
+function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 export {

package/dist/gmail-connector-2FVYTQJH.js

@@ -0,0 +1,6 @@
+import {
+  GoogleGmailConnector
+} from "./chunk-DSNJKNEW.js";
+export {
+  GoogleGmailConnector
+};

package/dist/index.d.ts

@@ -2,8 +2,8 @@ import { C as ChannelAdapter, H as HealthStatus, I as InboundMessage } from './c
 export { A as Attachment, a as ChannelCapabilities, b as ChannelConfig, c as ChannelMeta, d as ChatType, F as FormattingMode, O as OutboundPayload, S as SendResult } from './channel-06G0vbIn.js';
 import { T as TokenUsage, L as LLMProvider, M as ModelInfo, R as ResolvedModel, C as ChatMessage } from './provider-qqJYv9nv.js';
 export { a as ChatParams, b as ChatResult, c as ContentBlock, d as ToolDefinition, e as ToolUse } from './provider-qqJYv9nv.js';
-import { C as ConnectorConfig } from './connector-DDahQw-2.js';
-export { a as Connector, b as ConnectorMeta, P as PushResult, S as SyncOptions, c as SyncResult } from './connector-DDahQw-2.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 * as better_sqlite3 from 'better-sqlite3';
 
 /** Execution adapter types — Story 1.5 / 3.4 / 3.5 */

package/package.json

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