@hasna/connectors 1.3.24 → 1.3.26

package/bin/index.js

@@ -1909,7 +1909,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.3.24",
+    version: "1.3.26",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -2052,7 +2052,7 @@ var CONNECTOR_NAME_RE, OPERATION_NAME_RE;
 var init_connector = __esm(() => {
   init_errors();
   CONNECTOR_NAME_RE = /^[a-z0-9-]+$/;
-  OPERATION_NAME_RE = /^[a-z0-9:_-]+$/;
+  OPERATION_NAME_RE = /^[A-Za-z0-9:._-]+$/;
 });
 
 // src/core/registry.ts
@@ -6913,6 +6913,733 @@ Commands:
   });
 });
 
+// src/core/connectors/gmail.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { basename, join as join2 } from "path";
+async function modifyMessage(profile, messageId, addLabelIds, removeLabelIds) {
+  return requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/modify`, {}, {
+    method: "POST",
+    body: {
+      addLabelIds: addLabelIds ?? [],
+      removeLabelIds: removeLabelIds ?? []
+    }
+  });
+}
+async function replyToMessage(profile, messageId, input) {
+  const original = await requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}`, { format: "full" });
+  const headers = headersToObject(original.payload?.headers ?? []);
+  const subject = normalizeReplySubject(headers.Subject ?? headers.subject ?? "");
+  const to = headers.From ?? headers.from ?? "";
+  const messageIdHeader = headers["Message-ID"] ?? headers["Message-Id"] ?? headers["message-id"] ?? "";
+  const references = [headers.References ?? headers.references, messageIdHeader].filter(Boolean).join(" ");
+  const raw = buildRawEmail({
+    to,
+    cc: normalizeStringArray(input.cc),
+    bcc: normalizeStringArray(input.bcc),
+    subject,
+    body: input.body,
+    isHtml: Boolean(input.html ?? input.isHtml),
+    inReplyTo: messageIdHeader,
+    references
+  });
+  return requestJson(profile, "/users/me/messages/send", {}, {
+    method: "POST",
+    body: {
+      raw: Buffer.from(raw).toString("base64url"),
+      threadId: original.threadId
+    }
+  });
+}
+async function downloadAttachments(profile, input) {
+  const messageId = getMessageId(input);
+  const outputDir = input.dir ?? input.outputDir ?? join2(configDirs()[0], "attachments", messageId);
+  mkdirSync(outputDir, { recursive: true });
+  const attachments = input.attachmentId && input.filename ? [{
+    attachmentId: input.attachmentId,
+    filename: input.filename,
+    mimeType: input.mimeType ?? "application/octet-stream",
+    size: 0
+  }] : collectAttachments((await requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}`, { format: "full" })).payload);
+  const downloaded = [];
+  for (const attachment of attachments) {
+    const data = await requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachment.attachmentId)}`, {});
+    const filename = safeFilename(attachment.filename);
+    const path = join2(outputDir, filename);
+    const buffer = Buffer.from(data.data, "base64url");
+    writeFileSync(path, buffer);
+    downloaded.push({
+      filename,
+      path,
+      size: buffer.length,
+      mimeType: attachment.mimeType
+    });
+  }
+  return downloaded;
+}
+async function requestJson(profile, path, params, options = {}) {
+  const token = await getValidAccessToken(profile);
+  const url = new URL(`${GMAIL_API_BASE}${path}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null && value !== "")
+      url.searchParams.append(key, String(value));
+  }
+  const response = await fetch(url, {
+    method: options.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      ...options.body ? { "Content-Type": "application/json" } : {}
+    },
+    body: options.body ? JSON.stringify(options.body) : undefined
+  });
+  const text = await response.text();
+  const data = text ? JSON.parse(text) : {};
+  if (!response.ok) {
+    const error = data;
+    throw new Error(`Gmail request failed (${response.status}): ${error.error?.message ?? response.statusText}`);
+  }
+  return data;
+}
+async function getValidAccessToken(profile) {
+  if (process.env.GMAIL_ACCESS_TOKEN)
+    return process.env.GMAIL_ACCESS_TOKEN;
+  const tokens = loadTokens(profile);
+  if (!tokens?.accessToken && !tokens?.refreshToken) {
+    throw new Error(`Gmail profile "${profile}" is not authenticated. Run: connectors auth gmail`);
+  }
+  if (tokens.accessToken && (!tokens.expiresAt || Date.now() < tokens.expiresAt - REFRESH_BUFFER_MS))
+    return tokens.accessToken;
+  if (!tokens.refreshToken)
+    return tokens.accessToken ?? "";
+  return (await refreshAccessToken(profile, tokens)).accessToken ?? "";
+}
+async function refreshAccessToken(profile, currentTokens) {
+  const credentials = loadCredentials(profile);
+  if (!credentials.clientId || !credentials.clientSecret)
+    throw new Error("Gmail OAuth credentials are not configured. Run: connectors auth gmail");
+  if (!currentTokens.refreshToken)
+    throw new Error(`Gmail profile "${profile}" has no refresh token. Run: connectors auth gmail`);
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: credentials.clientId,
+      client_secret: credentials.clientSecret,
+      refresh_token: currentTokens.refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok || !data.access_token)
+    throw new Error(`Gmail token refresh failed: ${data.error_description || data.error || response.statusText}`);
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: currentTokens.refreshToken,
+    expiresAt: Date.now() + (data.expires_in ?? 3600) * 1000,
+    tokenType: data.token_type ?? currentTokens.tokenType,
+    scope: data.scope ?? currentTokens.scope
+  };
+  saveTokens(profile, tokens);
+  return tokens;
+}
+function listProfiles() {
+  const profiles = new Set;
+  for (const baseDir of configDirs()) {
+    const profilesDir = join2(baseDir, "profiles");
+    if (!existsSync2(profilesDir))
+      continue;
+    for (const entry of readdirSync(profilesDir, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        profiles.add(entry.name);
+      if (entry.isFile() && entry.name.endsWith(".json"))
+        profiles.add(basename(entry.name, ".json"));
+    }
+  }
+  return Array.from(profiles).sort((a, b) => a.localeCompare(b));
+}
+function loadCredentials(profile) {
+  const envClientId = process.env.GMAIL_CLIENT_ID ?? process.env.GOOGLE_CLIENT_ID;
+  const envClientSecret = process.env.GMAIL_CLIENT_SECRET ?? process.env.GOOGLE_CLIENT_SECRET;
+  if (envClientId && envClientSecret)
+    return { clientId: envClientId, clientSecret: envClientSecret };
+  for (const baseDir of configDirs()) {
+    const credentials = {
+      ...readJson(join2(baseDir, "credentials.json")),
+      ...readJson(join2(baseDir, "profiles", profile, "config.json"))
+    };
+    if (credentials.clientId || credentials.clientSecret)
+      return credentials;
+  }
+  return {};
+}
+function loadTokens(profile) {
+  for (const baseDir of configDirs()) {
+    const fromProfile = readJson(join2(baseDir, "profiles", profile, "tokens.json"));
+    if (fromProfile)
+      return fromProfile;
+    const flat = readJson(join2(baseDir, "profiles", `${profile}.json`));
+    if (flat)
+      return flat.tokens ?? (flat.accessToken || flat.refreshToken ? flat : null);
+  }
+  return null;
+}
+function saveTokens(profile, tokens) {
+  const baseDir = configDirs().find((dir) => existsSync2(dir)) ?? configDirs()[0];
+  const profileDir = join2(baseDir, "profiles", profile);
+  mkdirSync(profileDir, { recursive: true });
+  writeFileSync(join2(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+function configDirs() {
+  const explicit = process.env.HASNA_GMAIL_CONNECTOR_DIR ?? process.env.GMAIL_CONNECTOR_DIR;
+  if (explicit)
+    return [explicit];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join2(homedir(), ".hasna", "connectors");
+  return [join2(baseDir, "connect-gmail"), join2(baseDir, "gmail")];
+}
+function readJson(path) {
+  if (!existsSync2(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function getMessageId(input) {
+  const id = input.messageId ?? (input.args?.[0] != null ? String(input.args[0]) : undefined);
+  if (!id)
+    throw new Error("Gmail messageId is required");
+  return id;
+}
+function headersToObject(headers) {
+  const out = {};
+  for (const header of headers)
+    out[header.name] = header.value;
+  return out;
+}
+function extractBody(message, preferHtml = false) {
+  if (!message.payload)
+    return "";
+  const targetType = preferHtml ? "text/html" : "text/plain";
+  const parts = [];
+  collectTextParts(message.payload, parts);
+  return parts.find((part) => part.mimeType === targetType)?.data ?? parts.find((part) => part.mimeType.startsWith("text/"))?.data ?? "";
+}
+function collectTextParts(part, results) {
+  const mimeType = (part.mimeType ?? "").split(";")[0].trim().toLowerCase();
+  if (part.body?.data && mimeType.startsWith("text/")) {
+    results.push({ mimeType, data: Buffer.from(part.body.data, "base64url").toString("utf8") });
+  }
+  for (const child of part.parts ?? [])
+    collectTextParts(child, results);
+}
+function collectAttachments(part, attachments = []) {
+  if (!part)
+    return attachments;
+  if (part.body?.attachmentId && part.filename) {
+    attachments.push({
+      attachmentId: part.body.attachmentId,
+      filename: part.filename,
+      mimeType: part.mimeType ?? "application/octet-stream",
+      size: part.body.size ?? 0,
+      partId: part.partId
+    });
+  }
+  for (const child of part.parts ?? [])
+    collectAttachments(child, attachments);
+  return attachments;
+}
+function normalizeStringArray(value) {
+  if (!value)
+    return [];
+  return Array.isArray(value) ? value : value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function normalizeReplySubject(subject) {
+  return subject.toLowerCase().startsWith("re:") ? subject : `Re: ${subject}`;
+}
+function buildRawEmail(input) {
+  const headers = [
+    `To: ${input.to}`,
+    input.cc.length ? `Cc: ${input.cc.join(", ")}` : "",
+    input.bcc.length ? `Bcc: ${input.bcc.join(", ")}` : "",
+    `Subject: ${input.subject}`,
+    input.inReplyTo ? `In-Reply-To: ${input.inReplyTo}` : "",
+    input.references ? `References: ${input.references}` : "",
+    "MIME-Version: 1.0",
+    `Content-Type: ${input.isHtml ? "text/html" : "text/plain"}; charset=UTF-8`
+  ].filter(Boolean);
+  return `${headers.join(`\r
+`)}\r
+\r
+${input.body}`;
+}
+function safeFilename(filename) {
+  return basename(filename.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ")).replace(/[\/\\]/g, "_");
+}
+var GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1", TOKEN_URL = "https://oauth2.googleapis.com/token", REFRESH_BUFFER_MS, listMessagesSchema, messageIdSchema, readMessageSchema, attachmentListSchema, attachmentDownloadSchema, historyListSchema, replySchema, gmailConnector;
+var init_gmail = __esm(() => {
+  init_zod();
+  init_connector();
+  REFRESH_BUFFER_MS = 5 * 60 * 1000;
+  listMessagesSchema = exports_external.object({
+    max: exports_external.coerce.number().int().positive().max(500).optional(),
+    maxResults: exports_external.coerce.number().int().positive().max(500).optional(),
+    pageToken: exports_external.string().optional(),
+    query: exports_external.string().optional(),
+    q: exports_external.string().optional(),
+    label: exports_external.string().optional(),
+    labelIds: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+    includeSpamTrash: exports_external.boolean().optional()
+  });
+  messageIdSchema = exports_external.object({
+    args: exports_external.array(exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()])).optional(),
+    messageId: exports_external.string().optional()
+  });
+  readMessageSchema = messageIdSchema.extend({
+    body: exports_external.boolean().optional(),
+    html: exports_external.boolean().optional(),
+    format: exports_external.enum(["full", "metadata", "minimal", "raw"]).optional()
+  });
+  attachmentListSchema = messageIdSchema;
+  attachmentDownloadSchema = messageIdSchema.extend({
+    attachmentId: exports_external.string().optional(),
+    filename: exports_external.string().optional(),
+    mimeType: exports_external.string().optional(),
+    dir: exports_external.string().optional(),
+    outputDir: exports_external.string().optional()
+  });
+  historyListSchema = exports_external.object({
+    startHistoryId: exports_external.string(),
+    historyTypes: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+    labelId: exports_external.string().optional(),
+    maxResults: exports_external.coerce.number().int().positive().max(500).optional(),
+    pageToken: exports_external.string().optional()
+  });
+  replySchema = messageIdSchema.extend({
+    body: exports_external.string(),
+    html: exports_external.boolean().optional(),
+    isHtml: exports_external.boolean().optional(),
+    cc: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+    bcc: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional()
+  });
+  gmailConnector = defineConnector({
+    meta: {
+      name: "gmail",
+      displayName: "Gmail",
+      description: "Profile-aware Gmail mailbox operations for sync, labels, attachments, history, and replies.",
+      category: "communication",
+      tags: ["google", "gmail", "email", "mailbox"]
+    },
+    auth: {
+      type: "oauth2",
+      supportsProfiles: true,
+      fields: [
+        { key: "clientId", env: "GMAIL_CLIENT_ID", label: "OAuth client ID" },
+        { key: "clientSecret", env: "GMAIL_CLIENT_SECRET", label: "OAuth client secret", secret: true }
+      ]
+    },
+    createContext: ({ profile }) => ({ profile: profile || "default" }),
+    operations: {
+      "profiles.list": {
+        summary: "List configured Gmail profiles.",
+        execute: () => ({ profiles: listProfiles() })
+      },
+      "profile.get": {
+        summary: "Get the authenticated Gmail profile.",
+        execute: async ({ context }) => requestJson(context.profile, "/users/me/profile", {})
+      },
+      "messages.list": {
+        summary: "List Gmail messages.",
+        inputSchema: listMessagesSchema,
+        execute: async ({ context }, input) => {
+          const labelIds = normalizeStringArray(input.labelIds ?? input.label);
+          return requestJson(context.profile, "/users/me/messages", {
+            maxResults: input.maxResults ?? input.max ?? 50,
+            pageToken: input.pageToken,
+            q: input.q ?? input.query,
+            labelIds: labelIds.length > 0 ? labelIds.join(",") : undefined,
+            includeSpamTrash: input.includeSpamTrash
+          });
+        }
+      },
+      "messages.read": {
+        summary: "Read a Gmail message with optional extracted body.",
+        inputSchema: readMessageSchema,
+        execute: async ({ context }, input) => {
+          const messageId = getMessageId(input);
+          const message = await requestJson(context.profile, `/users/me/messages/${encodeURIComponent(messageId)}`, { format: input.format ?? "full" });
+          const headers = headersToObject(message.payload?.headers ?? []);
+          return {
+            ...message,
+            from: headers.From ?? headers.from ?? "",
+            to: headers.To ?? headers.to ?? "",
+            cc: headers.Cc ?? headers.cc ?? "",
+            subject: headers.Subject ?? headers.subject ?? "",
+            date: headers.Date ?? headers.date ?? "",
+            body: input.body ? extractBody(message, Boolean(input.html)) : undefined,
+            size: message.sizeEstimate
+          };
+        }
+      },
+      "messages.getRaw": {
+        summary: "Read raw base64url Gmail message content.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => {
+          const messageId = getMessageId(input);
+          return requestJson(context.profile, `/users/me/messages/${encodeURIComponent(messageId)}`, { format: "raw" });
+        }
+      },
+      "messages.mark-read": {
+        summary: "Mark a message as read.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => modifyMessage(context.profile, getMessageId(input), undefined, ["UNREAD"])
+      },
+      "messages.mark-unread": {
+        summary: "Mark a message as unread.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => modifyMessage(context.profile, getMessageId(input), ["UNREAD"], undefined)
+      },
+      "messages.archive": {
+        summary: "Archive a message by removing the INBOX label.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => modifyMessage(context.profile, getMessageId(input), undefined, ["INBOX"])
+      },
+      "messages.star": {
+        summary: "Star a message.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => modifyMessage(context.profile, getMessageId(input), ["STARRED"], undefined)
+      },
+      "messages.reply": {
+        summary: "Reply to a Gmail message in the same thread.",
+        inputSchema: replySchema,
+        execute: async ({ context }, input) => replyToMessage(context.profile, getMessageId(input), input)
+      },
+      "attachments.list": {
+        summary: "List Gmail message attachments.",
+        inputSchema: attachmentListSchema,
+        execute: async ({ context }, input) => {
+          const message = await requestJson(context.profile, `/users/me/messages/${encodeURIComponent(getMessageId(input))}`, { format: "full" });
+          return collectAttachments(message.payload);
+        }
+      },
+      "attachments.download": {
+        summary: "Download one or all Gmail message attachments to disk.",
+        inputSchema: attachmentDownloadSchema,
+        execute: async ({ context }, input) => downloadAttachments(context.profile, input)
+      },
+      "labels.list": {
+        summary: "List Gmail labels.",
+        execute: async ({ context }) => requestJson(context.profile, "/users/me/labels", {})
+      },
+      "history.list": {
+        summary: "List Gmail mailbox history from a history id.",
+        inputSchema: historyListSchema,
+        execute: async ({ context }, input) => requestJson(context.profile, "/users/me/history", {
+          startHistoryId: input.startHistoryId,
+          historyTypes: normalizeStringArray(input.historyTypes).join(",") || undefined,
+          labelId: input.labelId,
+          maxResults: input.maxResults,
+          pageToken: input.pageToken
+        })
+      }
+    }
+  });
+});
+
+// src/core/connectors/googledrive.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join3 } from "path";
+async function requestJson2(profile, path, params) {
+  const response = await request(profile, path, params);
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}
+async function requestBinary(profile, path, params) {
+  return (await request(profile, path, params)).arrayBuffer();
+}
+async function request(profile, path, params) {
+  const token = await getValidAccessToken2(profile);
+  const url = new URL(`${DRIVE_API_BASE}${path}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null && value !== "")
+      url.searchParams.set(key, String(value));
+  }
+  const response = await fetch(url, { headers: { Authorization: `Bearer ${token}`, Accept: "application/json" } });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Google Drive request failed (${response.status}): ${extractGoogleError(body) || response.statusText}`);
+  }
+  return response;
+}
+async function getValidAccessToken2(profile) {
+  if (process.env.GOOGLE_ACCESS_TOKEN)
+    return process.env.GOOGLE_ACCESS_TOKEN;
+  const tokens = loadTokens2(profile);
+  if (!tokens?.accessToken && !tokens?.refreshToken) {
+    throw new Error(`Google Drive profile "${profile}" is not authenticated. Run: connectors auth googledrive`);
+  }
+  if (tokens.accessToken && (!tokens.expiresAt || Date.now() < tokens.expiresAt - REFRESH_BUFFER_MS2))
+    return tokens.accessToken;
+  if (!tokens.refreshToken)
+    return tokens.accessToken ?? "";
+  return (await refreshAccessToken2(profile, tokens)).accessToken ?? "";
+}
+async function refreshAccessToken2(profile, currentTokens) {
+  const credentials = loadCredentials2(profile);
+  if (!credentials.clientId || !credentials.clientSecret)
+    throw new Error("Google Drive OAuth credentials are not configured. Run: connectors auth googledrive");
+  if (!currentTokens.refreshToken)
+    throw new Error(`Google Drive profile "${profile}" has no refresh token. Run: connectors auth googledrive`);
+  const response = await fetch(TOKEN_URL2, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: credentials.clientId,
+      client_secret: credentials.clientSecret,
+      refresh_token: currentTokens.refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok || !data.access_token)
+    throw new Error(`Google Drive token refresh failed: ${data.error_description || data.error || response.statusText}`);
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: currentTokens.refreshToken,
+    expiresAt: Date.now() + (data.expires_in ?? 3600) * 1000,
+    tokenType: data.token_type ?? currentTokens.tokenType,
+    scope: data.scope ?? currentTokens.scope
+  };
+  saveTokens2(profile, tokens);
+  return tokens;
+}
+function listProfiles2() {
+  const profiles = new Set;
+  for (const baseDir of configDirs2()) {
+    const profilesDir = join3(baseDir, "profiles");
+    if (!existsSync3(profilesDir))
+      continue;
+    for (const entry of readdirSync2(profilesDir, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        profiles.add(entry.name);
+      if (entry.isFile() && entry.name.endsWith(".json"))
+        profiles.add(basename2(entry.name, ".json"));
+    }
+  }
+  return Array.from(profiles).sort((a, b) => a.localeCompare(b));
+}
+function loadCredentials2(profile) {
+  const envClientId = process.env.GOOGLE_CLIENT_ID;
+  const envClientSecret = process.env.GOOGLE_CLIENT_SECRET;
+  if (envClientId && envClientSecret)
+    return { clientId: envClientId, clientSecret: envClientSecret };
+  for (const baseDir of configDirs2()) {
+    const credentials = {
+      ...readJson2(join3(baseDir, "credentials.json")),
+      ...readJson2(join3(baseDir, "profiles", profile, "config.json"))
+    };
+    if (credentials.clientId || credentials.clientSecret)
+      return credentials;
+  }
+  return {};
+}
+function loadTokens2(profile) {
+  for (const baseDir of configDirs2()) {
+    const fromProfile = readJson2(join3(baseDir, "profiles", profile, "tokens.json"));
+    if (fromProfile)
+      return fromProfile;
+    const flat = readJson2(join3(baseDir, "profiles", `${profile}.json`));
+    if (flat)
+      return flat.tokens ?? (flat.accessToken || flat.refreshToken ? flat : null);
+  }
+  return null;
+}
+function saveTokens2(profile, tokens) {
+  const baseDir = configDirs2().find((dir) => existsSync3(dir)) ?? configDirs2()[0];
+  const profileDir = join3(baseDir, "profiles", profile);
+  mkdirSync2(profileDir, { recursive: true });
+  writeFileSync2(join3(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+function configDirs2() {
+  const explicit = process.env.HASNA_GOOGLE_DRIVE_CONNECTOR_DIR ?? process.env.GOOGLE_DRIVE_CONNECTOR_DIR;
+  if (explicit)
+    return [explicit];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join3(homedir2(), ".hasna", "connectors");
+  return [join3(baseDir, "connect-googledrive"), join3(baseDir, "googledrive")];
+}
+function readJson2(path) {
+  if (!existsSync3(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function defaultExportMimeType(googleMimeType) {
+  if (googleMimeType.endsWith(".document"))
+    return DEFAULT_EXPORT_FORMATS.document;
+  if (googleMimeType.endsWith(".spreadsheet"))
+    return DEFAULT_EXPORT_FORMATS.spreadsheet;
+  if (googleMimeType.endsWith(".presentation"))
+    return DEFAULT_EXPORT_FORMATS.presentation;
+  if (googleMimeType.endsWith(".drawing"))
+    return DEFAULT_EXPORT_FORMATS.drawing;
+  throw new Error(`Cannot export Google Workspace file type: ${googleMimeType}`);
+}
+function extensionForMimeType(mimeType) {
+  return EXPORT_EXTENSIONS[mimeType] ?? "";
+}
+function extractGoogleError(body) {
+  if (!body)
+    return "";
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.error?.message ?? body;
+  } catch {
+    return body;
+  }
+}
+var DRIVE_API_BASE = "https://www.googleapis.com/drive/v3", TOKEN_URL2 = "https://oauth2.googleapis.com/token", REFRESH_BUFFER_MS2, DEFAULT_FILE_FIELDS, DEFAULT_EXPORT_FORMATS, EXPORT_EXTENSIONS, listFilesSchema, listDrivesSchema, fileIdSchema, downloadSchema, googleDriveConnector;
+var init_googledrive = __esm(() => {
+  init_zod();
+  init_connector();
+  REFRESH_BUFFER_MS2 = 5 * 60 * 1000;
+  DEFAULT_FILE_FIELDS = [
+    "id",
+    "name",
+    "mimeType",
+    "parents",
+    "version",
+    "md5Checksum",
+    "size",
+    "modifiedTime",
+    "createdTime",
+    "trashed",
+    "webViewLink",
+    "webContentLink"
+  ].join(",");
+  DEFAULT_EXPORT_FORMATS = {
+    document: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    spreadsheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    presentation: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    drawing: "image/png"
+  };
+  EXPORT_EXTENSIONS = {
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+    "application/pdf": ".pdf",
+    "text/plain": ".txt",
+    "text/csv": ".csv",
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/svg+xml": ".svg"
+  };
+  listFilesSchema = exports_external.object({
+    pageSize: exports_external.coerce.number().int().positive().max(1000).optional(),
+    pageToken: exports_external.string().optional(),
+    q: exports_external.string().optional(),
+    fields: exports_external.string().optional(),
+    orderBy: exports_external.string().optional(),
+    corpora: exports_external.enum(["user", "drive", "allDrives"]).optional(),
+    driveId: exports_external.string().optional(),
+    supportsAllDrives: exports_external.boolean().optional(),
+    includeItemsFromAllDrives: exports_external.boolean().optional()
+  });
+  listDrivesSchema = exports_external.object({
+    pageSize: exports_external.coerce.number().int().positive().max(100).optional(),
+    pageToken: exports_external.string().optional(),
+    q: exports_external.string().optional()
+  });
+  fileIdSchema = exports_external.object({
+    fileId: exports_external.string(),
+    fields: exports_external.string().optional()
+  });
+  downloadSchema = exports_external.object({
+    fileId: exports_external.string(),
+    file: exports_external.object({
+      id: exports_external.string(),
+      name: exports_external.string(),
+      mimeType: exports_external.string()
+    }).optional(),
+    exportMimeType: exports_external.string().optional()
+  });
+  googleDriveConnector = defineConnector({
+    meta: {
+      name: "googledrive",
+      displayName: "Google Drive",
+      description: "Profile-aware Google Drive discovery and file download operations.",
+      category: "storage",
+      tags: ["google", "drive", "files", "storage"]
+    },
+    auth: {
+      type: "oauth2",
+      supportsProfiles: true,
+      fields: [
+        { key: "clientId", env: "GOOGLE_CLIENT_ID", label: "OAuth client ID" },
+        { key: "clientSecret", env: "GOOGLE_CLIENT_SECRET", label: "OAuth client secret", secret: true }
+      ]
+    },
+    createContext: ({ profile }) => ({ profile: profile || "default" }),
+    operations: {
+      "profiles.list": {
+        summary: "List configured Google Drive profiles.",
+        execute: () => ({ profiles: listProfiles2() })
+      },
+      "files.list": {
+        summary: "List Google Drive files.",
+        inputSchema: listFilesSchema,
+        execute: async ({ context }, input) => requestJson2(context.profile, "/files", {
+          pageSize: input.pageSize ?? 1000,
+          pageToken: input.pageToken,
+          q: input.q,
+          fields: input.fields ?? `nextPageToken,files(${DEFAULT_FILE_FIELDS})`,
+          orderBy: input.orderBy ?? "modifiedTime desc",
+          corpora: input.corpora,
+          driveId: input.driveId,
+          supportsAllDrives: input.supportsAllDrives ?? true,
+          includeItemsFromAllDrives: input.includeItemsFromAllDrives ?? false
+        })
+      },
+      "files.get": {
+        summary: "Get Google Drive file metadata.",
+        inputSchema: fileIdSchema,
+        execute: async ({ context }, input) => requestJson2(context.profile, `/files/${encodeURIComponent(input.fileId)}`, {
+          fields: input.fields ?? DEFAULT_FILE_FIELDS,
+          supportsAllDrives: true
+        })
+      },
+      "files.download": {
+        summary: "Download or export a Google Drive file as base64 content.",
+        inputSchema: downloadSchema,
+        execute: async ({ context }, input) => {
+          const file = input.file ?? await requestJson2(context.profile, `/files/${encodeURIComponent(input.fileId)}`, { fields: DEFAULT_FILE_FIELDS, supportsAllDrives: true });
+          const exportMimeType = file.mimeType.startsWith("application/vnd.google-apps.") ? input.exportMimeType ?? defaultExportMimeType(file.mimeType) : undefined;
+          const data = await requestBinary(context.profile, exportMimeType ? `/files/${encodeURIComponent(file.id)}/export` : `/files/${encodeURIComponent(file.id)}`, exportMimeType ? { mimeType: exportMimeType, supportsAllDrives: true } : { alt: "media", supportsAllDrives: true });
+          const mimeType = exportMimeType ?? file.mimeType ?? "application/octet-stream";
+          return {
+            dataBase64: Buffer.from(data).toString("base64"),
+            filename: exportMimeType ? `${file.name}${extensionForMimeType(exportMimeType)}` : file.name,
+            mimeType
+          };
+        }
+      },
+      "drives.list": {
+        summary: "List Google shared drives.",
+        inputSchema: listDrivesSchema,
+        execute: async ({ context }, input) => requestJson2(context.profile, "/drives", {
+          pageSize: input.pageSize ?? 100,
+          pageToken: input.pageToken,
+          q: input.q
+        })
+      }
+    }
+  });
+});
+
 // node_modules/@hasna/cloud/dist/index.js
 var exports_dist = {};
 __export(exports_dist, {
@@ -6986,27 +7713,27 @@ __export(exports_dist, {
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import {
-  existsSync as existsSync2,
-  mkdirSync,
-  readdirSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
   copyFileSync
 } from "fs";
-import { homedir } from "os";
-import { join as join2, relative } from "path";
-import { existsSync as existsSync22, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join22 } from "path";
-import { readdirSync as readdirSync2, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
+import { join as join4, relative } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir22 } from "os";
+import { join as join22 } from "path";
+import { readdirSync as readdirSync22, existsSync as existsSync32 } from "fs";
+import { join as join32 } from "path";
+import { homedir as homedir32 } from "os";
 import { hostname } from "os";
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
-import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join42 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync32 } from "fs";
 import { join as join5 } from "path";
 import { join as join6, dirname as dirname2 } from "path";
-import { existsSync as existsSync6, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync6, writeFileSync as writeFileSync22, unlinkSync, mkdirSync as mkdirSync32 } from "fs";
 import { homedir as homedir5, platform } from "os";
 function __accessProp2(key) {
   return this[key];
@@ -7889,33 +8616,33 @@ function custom2(check, _params = {}, fatal) {
   return ZodAny2.create();
 }
 function getDataDir(serviceName) {
-  const dir = join2(HASNA_DIR, serviceName);
-  mkdirSync(dir, { recursive: true });
+  const dir = join4(HASNA_DIR, serviceName);
+  mkdirSync3(dir, { recursive: true });
   return dir;
 }
 function getDbPath(serviceName) {
   const dir = getDataDir(serviceName);
-  return join2(dir, `${serviceName}.db`);
+  return join4(dir, `${serviceName}.db`);
 }
 function migrateDotfile(serviceName) {
-  const legacyDir = join2(homedir(), `.${serviceName}`);
-  const newDir = join2(HASNA_DIR, serviceName);
-  if (!existsSync2(legacyDir))
+  const legacyDir = join4(homedir3(), `.${serviceName}`);
+  const newDir = join4(HASNA_DIR, serviceName);
+  if (!existsSync4(legacyDir))
     return [];
-  if (existsSync2(newDir))
+  if (existsSync4(newDir))
     return [];
-  mkdirSync(newDir, { recursive: true });
+  mkdirSync3(newDir, { recursive: true });
   const migrated = [];
   copyDirRecursive(legacyDir, newDir, legacyDir, migrated);
   return migrated;
 }
 function copyDirRecursive(src, dest, root, migrated) {
-  const entries = readdirSync(src, { withFileTypes: true });
+  const entries = readdirSync3(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join2(src, entry.name);
-    const destPath = join2(dest, entry.name);
+    const srcPath = join4(src, entry.name);
+    const destPath = join4(dest, entry.name);
     if (entry.isDirectory()) {
-      mkdirSync(destPath, { recursive: true });
+      mkdirSync3(destPath, { recursive: true });
       copyDirRecursive(srcPath, destPath, root, migrated);
     } else {
       copyFileSync(srcPath, destPath);
@@ -7924,10 +8651,10 @@ function copyDirRecursive(src, dest, root, migrated) {
   }
 }
 function hasLegacyDotfile(serviceName) {
-  return existsSync2(join2(homedir(), `.${serviceName}`));
+  return existsSync4(join4(homedir3(), `.${serviceName}`));
 }
 function getHasnaDir() {
-  mkdirSync(HASNA_DIR, { recursive: true });
+  mkdirSync3(HASNA_DIR, { recursive: true });
   return HASNA_DIR;
 }
 function getConfigDir() {
@@ -7941,15 +8668,15 @@ function getCloudConfig() {
     return CloudConfigSchema.parse({});
   }
   try {
-    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const raw = readFileSync3(CONFIG_PATH, "utf-8");
     return CloudConfigSchema.parse(JSON.parse(raw));
   } catch {
     return CloudConfigSchema.parse({});
   }
 }
 function saveCloudConfig(config) {
-  mkdirSync2(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+  mkdirSync22(CONFIG_DIR, { recursive: true });
+  writeFileSync3(CONFIG_PATH, JSON.stringify(config, null, 2) + `
 `, "utf-8");
 }
 function getConnectionString(dbName) {
@@ -7979,11 +8706,11 @@ function isSyncExcludedTable(table) {
   return SYNC_EXCLUDED_TABLE_PATTERNS.some((p) => p.test(table));
 }
 function discoverServices() {
-  const dataDir = join3(homedir3(), ".hasna");
-  if (!existsSync3(dataDir))
+  const dataDir = join32(homedir32(), ".hasna");
+  if (!existsSync32(dataDir))
     return [];
   try {
-    const entries = readdirSync2(dataDir, { withFileTypes: true });
+    const entries = readdirSync22(dataDir, { withFileTypes: true });
     return entries.filter((e) => {
       if (!e.isDirectory())
         return false;
@@ -8001,24 +8728,24 @@ function discoverSyncableServices() {
   return local.filter((s) => pgSet.has(s));
 }
 function getServiceDbPath(service) {
-  const dataDir = join3(homedir3(), ".hasna", service);
-  if (!existsSync3(dataDir))
+  const dataDir = join32(homedir32(), ".hasna", service);
+  if (!existsSync32(dataDir))
     return null;
   const candidates = [
-    join3(dataDir, `${service}.db`),
-    join3(dataDir, "data.db"),
-    join3(dataDir, "database.db")
+    join32(dataDir, `${service}.db`),
+    join32(dataDir, "data.db"),
+    join32(dataDir, "database.db")
   ];
   try {
-    const files = readdirSync2(dataDir);
+    const files = readdirSync22(dataDir);
     for (const f of files) {
       if (f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm")) {
-        candidates.push(join3(dataDir, f));
+        candidates.push(join32(dataDir, f));
       }
     }
   } catch {}
   for (const p of candidates) {
-    if (existsSync3(p))
+    if (existsSync32(p))
       return p;
   }
   return null;
@@ -8325,9 +9052,9 @@ async function syncTransfer(source, target, options, _direction) {
           const batch = rows.slice(offset, offset + batchSize);
           try {
             if (isAsyncAdapter(target)) {
-              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
+              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch);
             } else {
-              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
+              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch);
             }
             result.rowsWritten += batch.length;
           } catch (err) {
@@ -8374,7 +9101,7 @@ async function syncTransfer(source, target, options, _direction) {
   }
   return results;
 }
-async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
+async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch) {
   if (batch.length === 0)
     return;
   const colList = columns.map((c) => `"${c}"`).join(", ");
@@ -8384,22 +9111,20 @@ async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, ba
   }).join(", ");
   const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
-  const whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
-    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
   const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
   await target.run(sql, ...params);
 }
-function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch) {
   if (batch.length === 0)
     return;
   const colList = columns.map((c) => `"${c}"`).join(", ");
   const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
   const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
-  const whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
-    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
   const params = batch.flatMap((row) => columns.map((c) => coerceForSqlite(row[c])));
   target.run(sql, ...params);
 }
@@ -8939,10 +9664,10 @@ function resetAllSyncMeta(db) {
 }
 function getAutoSyncConfig() {
   try {
-    if (!existsSync4(AUTO_SYNC_CONFIG_PATH)) {
+    if (!existsSync42(AUTO_SYNC_CONFIG_PATH)) {
       return { ...DEFAULT_AUTO_SYNC_CONFIG };
     }
-    const raw = JSON.parse(readFileSync2(AUTO_SYNC_CONFIG_PATH, "utf-8"));
+    const raw = JSON.parse(readFileSync22(AUTO_SYNC_CONFIG_PATH, "utf-8"));
     return {
       auto_sync_on_start: typeof raw.auto_sync_on_start === "boolean" ? raw.auto_sync_on_start : DEFAULT_AUTO_SYNC_CONFIG.auto_sync_on_start,
       auto_sync_on_stop: typeof raw.auto_sync_on_stop === "boolean" ? raw.auto_sync_on_stop : DEFAULT_AUTO_SYNC_CONFIG.auto_sync_on_stop
@@ -9057,7 +9782,7 @@ function discoverSyncableServices2() {
   const hasnaDir = getHasnaDir();
   const services = [];
   try {
-    const entries = readdirSync3(hasnaDir, { withFileTypes: true });
+    const entries = readdirSync32(hasnaDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -9227,11 +9952,11 @@ function createLaunchdPlist(intervalMinutes) {
 async function registerLaunchd(intervalMinutes) {
   const plistPath = getLaunchdPlistPath();
   const plistDir = dirname2(plistPath);
-  mkdirSync3(plistDir, { recursive: true });
+  mkdirSync32(plistDir, { recursive: true });
   try {
     await Bun.spawn(["launchctl", "unload", plistPath]).exited;
   } catch {}
-  writeFileSync2(plistPath, createLaunchdPlist(intervalMinutes));
+  writeFileSync22(plistPath, createLaunchdPlist(intervalMinutes));
   await Bun.spawn(["launchctl", "load", plistPath]).exited;
 }
 async function removeLaunchd() {
@@ -9278,9 +10003,9 @@ WantedBy=timers.target
 }
 async function registerSystemd(intervalMinutes) {
   const dir = getSystemdDir();
-  mkdirSync3(dir, { recursive: true });
-  writeFileSync2(join6(dir, `${SERVICE_NAME}.service`), createSystemdService());
-  writeFileSync2(join6(dir, `${SERVICE_NAME}.timer`), createSystemdTimer(intervalMinutes));
+  mkdirSync32(dir, { recursive: true });
+  writeFileSync22(join6(dir, `${SERVICE_NAME}.service`), createSystemdService());
+  writeFileSync22(join6(dir, `${SERVICE_NAME}.timer`), createSystemdTimer(intervalMinutes));
   await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
   await Bun.spawn(["systemctl", "--user", "enable", "--now", `${SERVICE_NAME}.timer`]).exited;
 }
@@ -9303,7 +10028,7 @@ async function registerSyncSchedule(intervalMinutes) {
   if (intervalMinutes <= 0) {
     throw new Error("Interval must be a positive number of minutes.");
   }
-  mkdirSync3(CONFIG_DIR2, { recursive: true });
+  mkdirSync32(CONFIG_DIR2, { recursive: true });
   if (platform() === "darwin") {
     await registerLaunchd(intervalMinutes);
   } else {
@@ -9469,7 +10194,7 @@ async function ensureAllPgDatabases() {
   }
   return results;
 }
-function registerCloudTools(server, serviceName, opts = {}) {
+function registerCloudTools(server, serviceName) {
   server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
     const config = getCloudConfig();
     const lines = [
@@ -9502,13 +10227,8 @@ function registerCloudTools(server, serviceName, opts = {}) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(opts.dbPath ?? getDbPath(serviceName));
+    const local = new SqliteAdapter(getDbPath(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
-    if (opts.migrations?.length) {
-      for (const sql of opts.migrations) {
-        await cloud.run(sql);
-      }
-    }
     const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
     const results = await syncPush(local, cloud, { tables: tableList });
     local.close();
@@ -9530,7 +10250,7 @@ function registerCloudTools(server, serviceName, opts = {}) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(opts.dbPath ?? getDbPath(serviceName));
+    const local = new SqliteAdapter(getDbPath(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tableList;
     if (tablesStr) {
@@ -17882,7 +18602,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
     init_external2();
   });
   init_dotfile = __esm2(() => {
-    HASNA_DIR = join2(homedir(), ".hasna");
+    HASNA_DIR = join4(homedir3(), ".hasna");
   });
   exports_config = {};
   __export2(exports_config, {
@@ -17913,7 +18633,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
         schedule_minutes: exports_external2.number().default(0)
       }).default({})
     });
-    CONFIG_DIR = join22(homedir2(), ".hasna", "cloud");
+    CONFIG_DIR = join22(homedir22(), ".hasna", "cloud");
     CONFIG_PATH = join22(CONFIG_DIR, "config.json");
   });
   exports_discover = {};
@@ -17978,7 +18698,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   init_adapter();
   init_config();
   init_discover();
-  AUTO_SYNC_CONFIG_PATH = join4(homedir4(), ".hasna", "cloud", "config.json");
+  AUTO_SYNC_CONFIG_PATH = join42(homedir4(), ".hasna", "cloud", "config.json");
   DEFAULT_AUTO_SYNC_CONFIG = {
     auto_sync_on_start: true,
     auto_sync_on_stop: true
@@ -18190,12 +18910,12 @@ var init_database = __esm(() => {
 // src/core/connectors/imessage.ts
 import {
   existsSync as existsSync9,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync3,
-  readdirSync as readdirSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync5,
   rmSync,
   statSync as statSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { join as join9 } from "path";
 function buildRootHelp(specs) {
@@ -18253,15 +18973,15 @@ function getCurrentProfile() {
     return "default";
   }
   try {
-    return readFileSync3(currentProfileFile, "utf-8").trim() || "default";
+    return readFileSync4(currentProfileFile, "utf-8").trim() || "default";
   } catch {
     return "default";
   }
 }
 function setCurrentProfile(profile) {
   const configDir = getConfigDir2();
-  mkdirSync6(configDir, { recursive: true });
-  writeFileSync3(join9(configDir, "current_profile"), profile);
+  mkdirSync5(configDir, { recursive: true });
+  writeFileSync4(join9(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
   return join9(getProfilesDir(), `${profile}.json`);
@@ -18271,7 +18991,7 @@ function getDirectoryProfilePath(profile) {
 }
 function loadJsonFile(path) {
   try {
-    return JSON.parse(readFileSync3(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return {};
   }
@@ -18296,8 +19016,8 @@ function loadProfile(profile = getCurrentProfile()) {
 }
 function writeProfile(profile, config) {
   const profilesDir = getProfilesDir();
-  mkdirSync6(profilesDir, { recursive: true });
-  writeFileSync3(getFlatProfilePath(profile), JSON.stringify(config, null, 2) + `
+  mkdirSync5(profilesDir, { recursive: true });
+  writeFileSync4(getFlatProfilePath(profile), JSON.stringify(config, null, 2) + `
 `);
 }
 function profileExists(profile) {
@@ -18306,14 +19026,14 @@ function profileExists(profile) {
   }
   return existsSync9(getFlatProfilePath(profile)) || existsSync9(join9(getProfilesDir(), profile));
 }
-function listProfiles() {
+function listProfiles3() {
   const profilesDir = getProfilesDir();
   const seen = new Set(["default"]);
   if (!existsSync9(profilesDir)) {
     return [...seen];
   }
   try {
-    for (const entry of readdirSync6(profilesDir)) {
+    for (const entry of readdirSync5(profilesDir)) {
       const fullPath = join9(profilesDir, entry);
       const stat = statSync2(fullPath);
       if (stat.isDirectory()) {
@@ -18635,7 +19355,7 @@ async function sendMessage(context, input) {
     direction: "outbound"
   });
 }
-async function replyToMessage(context, input) {
+async function replyToMessage2(context, input) {
   const payload = await bridgeRequest(context, "/messages/reply", {
     method: "POST",
     body: {
@@ -18749,7 +19469,7 @@ async function runProfileCommand2(args, context) {
   switch (subcommand) {
     case "list": {
       const current = getCurrentProfile();
-      const profiles = listProfiles();
+      const profiles = listProfiles3();
       return successOutput({ current, profiles }, context.format, () => profiles.map((profile) => `${profile}${profile === current ? " (active)" : ""}`).join(`
 `));
     }
@@ -18923,7 +19643,7 @@ async function runMessageCommand(args, context) {
       if (!conversationId || !text) {
         return failure2("Usage: connect-imessage message reply --conversation <id> --text <text>");
       }
-      return successOutput(await replyToMessage(resolved, {
+      return successOutput(await replyToMessage2(resolved, {
         conversationId,
         text,
         replyToMessageId: asString2(options.replyTo),
@@ -19201,7 +19921,7 @@ var init_imessage = __esm(() => {
         summary: "Reply to an existing conversation through the bridge",
         inputSchema: messageReplyInputSchema,
         async execute({ context }, input) {
-          return replyToMessage(context, input);
+          return replyToMessage2(context, input);
         }
       }
     },
@@ -20145,10 +20865,14 @@ var INTERNAL_CONNECTOR_DEFINITIONS, INTERNAL_CONNECTOR_REGISTRY;
 var init_builtins = __esm(() => {
   init_registry();
   init_github();
+  init_gmail();
+  init_googledrive();
   init_imessage();
   init_stripe();
   INTERNAL_CONNECTOR_DEFINITIONS = [
+    gmailConnector,
     githubConnector,
+    googleDriveConnector,
     imessageConnector,
     stripeConnector
   ];
@@ -28183,7 +28907,7 @@ __export(exports_installer, {
   getConnectorDocs: () => getConnectorDocs,
   connectorExists: () => connectorExists
 });
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync7, statSync as statSync3, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync6, statSync as statSync3, rmSync as rmSync2 } from "fs";
 import { join as join12, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function resolveConnectorsDir() {
@@ -28232,7 +28956,7 @@ function getLegacyInstalledConnectors(targetDir) {
   if (!existsSync12(connectorsDir)) {
     return [];
   }
-  return readdirSync7(connectorsDir).filter((entry) => {
+  return readdirSync6(connectorsDir).filter((entry) => {
     const fullPath = join12(connectorsDir, entry);
     return entry.startsWith("connect-") && statSync3(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
@@ -28262,7 +28986,7 @@ export type EnabledConnectorName = typeof enabledConnectors[number];
 }
 function writeEnablementManifest(targetDir, connectors18) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  mkdirSync7(connectorsDir, { recursive: true });
+  mkdirSync6(connectorsDir, { recursive: true });
   const manifest = {
     version: 1,
     mode: "internal",
@@ -28408,10 +29132,10 @@ var init_installer = __esm(() => {
 // src/lib/lock.ts
 import { openSync, closeSync, unlinkSync as unlinkSync2, existsSync as existsSync13, statSync as statSync5 } from "fs";
 import { join as join14 } from "path";
-import { mkdirSync as mkdirSync8 } from "fs";
+import { mkdirSync as mkdirSync7 } from "fs";
 function lockPath(connector) {
   const dir = join14(getConnectorsHome(), `connect-${connector}`);
-  mkdirSync8(dir, { recursive: true });
+  mkdirSync7(dir, { recursive: true });
   return join14(dir, ".write.lock");
 }
 function isStale(path) {
@@ -28472,7 +29196,7 @@ var init_lock = __esm(() => {
 });
 
 // src/server/auth.ts
-import { existsSync as existsSync14, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync9, readdirSync as readdirSync9, rmSync as rmSync3, statSync as statSync6 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, readdirSync as readdirSync8, rmSync as rmSync3, statSync as statSync6 } from "fs";
 import { randomBytes } from "crypto";
 import { join as join15 } from "path";
 function getAuthType(name) {
@@ -28524,7 +29248,7 @@ function loadProfileConfig(name) {
   }
   return { ...flatConfig, ...dirConfig };
 }
-function loadTokens(name) {
+function loadTokens3(name) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile2(name);
   const tokensFile = join15(configDir, "profiles", profile, "tokens.json");
@@ -28547,28 +29271,49 @@ function loadTokens(name) {
   }
   return null;
 }
+function isStoredOAuthEnvVarSet(variable, oauthConfig, tokens, profileConfig) {
+  if (variable.endsWith("_CLIENT_ID")) {
+    return Boolean(oauthConfig.clientId || profileConfig.clientId);
+  }
+  if (variable.endsWith("_CLIENT_SECRET")) {
+    return Boolean(oauthConfig.clientSecret || profileConfig.clientSecret);
+  }
+  if (variable.endsWith("_ACCESS_TOKEN")) {
+    return Boolean(tokens?.accessToken || profileConfig.accessToken);
+  }
+  if (variable.endsWith("_REFRESH_TOKEN")) {
+    return Boolean(tokens?.refreshToken || profileConfig.refreshToken);
+  }
+  if (variable.endsWith("_TOKEN_EXPIRES_AT")) {
+    return Boolean(tokens?.expiresAt || profileConfig.expiresAt);
+  }
+  return false;
+}
 function getAuthStatus(name) {
   const authType = getAuthType(name);
   const docs = getConnectorDocs(name);
+  const oauthConfig = authType === "oauth" ? getOAuthConfig(name) : {};
+  const tokens = authType === "oauth" ? loadTokens3(name) : null;
+  const profileConfig = authType === "oauth" ? loadProfileConfig(name) : {};
   const envVars = (docs?.envVars || []).map((v) => ({
     variable: v.variable,
     description: v.description,
-    set: !!process.env[v.variable]
+    set: !!process.env[v.variable] || authType === "oauth" && isStoredOAuthEnvVarSet(v.variable, oauthConfig, tokens, profileConfig)
   }));
   const envVarTotalCount = envVars.length;
   const envVarSetCount = envVars.filter((v) => v.set).length;
   if (authType === "oauth") {
-    const tokens = loadTokens(name);
-    const config2 = loadProfileConfig(name);
-    const hasTokens = !!tokens?.accessToken || !!config2.accessToken;
-    const hasRefreshToken = !!tokens?.refreshToken || !!config2.refreshToken;
-    const tokenExpiry = tokens?.expiresAt || config2.expiresAt;
+    const hasTokens = !!tokens?.accessToken || !!profileConfig.accessToken;
+    const hasRefreshToken = !!tokens?.refreshToken || !!profileConfig.refreshToken;
+    const tokenExpiry = tokens?.expiresAt || profileConfig.expiresAt;
+    const hasOAuthCredentials = Boolean(oauthConfig.clientId && oauthConfig.clientSecret);
     const hasEnvVar2 = envVars.some((v) => v.set);
     return {
       type: "oauth",
-      configured: hasTokens || hasRefreshToken || hasEnvVar2,
+      configured: hasTokens || hasRefreshToken || hasOAuthCredentials || hasEnvVar2,
       tokenExpiry,
       hasRefreshToken,
+      hasOAuthCredentials,
       envVars,
       envVarSetCount,
       envVarTotalCount
@@ -28598,7 +29343,7 @@ function _saveApiKey(name, key, field) {
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
     const credentialsFile = join15(configDir, "credentials.json");
-    mkdirSync9(configDir, { recursive: true });
+    mkdirSync8(configDir, { recursive: true });
     let creds = {};
     if (existsSync14(credentialsFile)) {
       try {
@@ -28632,7 +29377,7 @@ function _saveApiKey(name, key, field) {
     writeFileSync6(configFile, JSON.stringify(config, null, 2));
     return;
   }
-  mkdirSync9(profileDir, { recursive: true });
+  mkdirSync8(profileDir, { recursive: true });
   writeFileSync6(join15(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
 }
 function guessKeyField(name) {
@@ -28734,7 +29479,7 @@ function saveOAuthTokens(name, tokens) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile2(name);
   const profileDir = join15(configDir, "profiles", profile);
-  mkdirSync9(profileDir, { recursive: true });
+  mkdirSync8(profileDir, { recursive: true });
   const tokensFile = join15(profileDir, "tokens.json");
   writeFileSync6(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
@@ -28743,7 +29488,7 @@ async function refreshOAuthToken(name) {
 }
 async function _refreshOAuthToken(name) {
   const oauthConfig = getOAuthConfig(name);
-  const currentTokens = loadTokens(name);
+  const currentTokens = loadTokens3(name);
   if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
     throw new Error("OAuth credentials not configured for " + name);
   }
@@ -28776,14 +29521,14 @@ async function _refreshOAuthToken(name) {
   saveOAuthTokens(name, tokens);
   return tokens;
 }
-function listProfiles2(name) {
+function listProfiles4(name) {
   const configDir = getConnectorConfigDir(name);
   const profilesDir = join15(configDir, "profiles");
   if (!existsSync14(profilesDir))
     return ["default"];
   const seen = new Set;
   try {
-    const entries = readdirSync9(profilesDir);
+    const entries = readdirSync8(profilesDir);
     for (const entry of entries) {
       const fullPath = join15(profilesDir, entry);
       const stat = statSync6(fullPath);
@@ -28799,7 +29544,7 @@ function listProfiles2(name) {
 }
 function switchProfile(name, profile) {
   const configDir = getConnectorConfigDir(name);
-  mkdirSync9(configDir, { recursive: true });
+  mkdirSync8(configDir, { recursive: true });
   writeFileSync6(join15(configDir, "current_profile"), profile);
 }
 function deleteProfile2(name, profile) {
@@ -29079,7 +29824,7 @@ var init_rate = __esm(() => {
 });
 
 // src/lib/llm.ts
-import { existsSync as existsSync15, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync10 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync9 } from "fs";
 import { join as join16 } from "path";
 function getLlmConfigPath() {
   return join16(getConnectorsHome(), "llm.json");
@@ -29096,7 +29841,7 @@ function getLlmConfig() {
 }
 function saveLlmConfig(config) {
   const dir = getConnectorsHome();
-  mkdirSync10(dir, { recursive: true });
+  mkdirSync9(dir, { recursive: true });
   writeFileSync7(getLlmConfigPath(), JSON.stringify(config, null, 2));
 }
 function setLlmStrip(enabled) {
@@ -29480,7 +30225,7 @@ var init_scheduler = __esm(() => {
 });
 
 // src/lib/workflow-runner.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as nodeSpawn } from "child_process";
 async function runStep(step, previousOutput) {
   return new Promise((resolve) => {
     const args = [...step.args ?? []];
@@ -29488,7 +30233,7 @@ async function runStep(step, previousOutput) {
       args.push("--input", previousOutput.trim().slice(0, 4096));
     }
     const cmdArgs = ["run", step.connector, step.command, ...args, "--format", "json"];
-    const proc = spawn2("connectors", cmdArgs, { shell: false });
+    const proc = spawnImpl("connectors", cmdArgs, { shell: false });
     let output = "";
     proc.stdout.on("data", (d) => {
       output += d.toString();
@@ -29528,15 +30273,17 @@ async function runWorkflow(workflow) {
     final_output: results[results.length - 1]?.output ?? ""
   };
 }
+var spawnImpl;
 var init_workflow_runner = __esm(() => {
   init_strip();
+  spawnImpl = nodeSpawn;
 });
 
 // src/lib/runner.ts
-import { existsSync as existsSync16, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync16, readdirSync as readdirSync9 } from "fs";
 import { join as join17, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function resolveConnectorsDir2() {
   const fromBin = join17(__dirname5, "..", "connectors");
   if (existsSync16(fromBin))
@@ -29585,6 +30332,25 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
       }
     }
   }
+  if (getAuthType(connectorName) === "oauth") {
+    const oauthConfig = getOAuthConfig(connectorName);
+    const tokens = loadTokens3(connectorName);
+    for (const { variable } of getEnvVars(connectorName)) {
+      if (env[variable])
+        continue;
+      if (variable.endsWith("_CLIENT_ID") && oauthConfig.clientId) {
+        env[variable] = oauthConfig.clientId;
+      } else if (variable.endsWith("_CLIENT_SECRET") && oauthConfig.clientSecret) {
+        env[variable] = oauthConfig.clientSecret;
+      } else if (variable.endsWith("_ACCESS_TOKEN") && tokens?.accessToken) {
+        env[variable] = tokens.accessToken;
+      } else if (variable.endsWith("_REFRESH_TOKEN") && tokens?.refreshToken) {
+        env[variable] = tokens.refreshToken;
+      } else if (variable.endsWith("_TOKEN_EXPIRES_AT") && tokens?.expiresAt) {
+        env[variable] = String(tokens.expiresAt);
+      }
+    }
+  }
   return env;
 }
 function getConnectorCliPath(name) {
@@ -29629,7 +30395,7 @@ function parseCommanderHelpOperations(helpText) {
         inCommands = false;
       continue;
     }
-    const row = line.match(/^ {2}(\S.*?)(?: {2,}(.+))?$/);
+    const row = line.match(/^ {2}(?! )(\S.*?)(?: {2,}(.+))?$/);
     if (!row)
       continue;
     const usage = row[1].trim();
@@ -29677,7 +30443,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
     });
   }
   return new Promise((resolve) => {
-    const proc = spawn3("bun", ["run", cliPath, ...args], {
+    const proc = spawn2("bun", ["run", cliPath, ...args], {
       timeout: timeoutMs,
       env: buildEnvWithCredentials(name, process.env),
       stdio: ["pipe", "pipe", "pipe"]
@@ -29757,7 +30523,9 @@ async function getConnectorCommandHelp(name, command) {
 var __dirname5, CONNECTORS_DIR2, ENV_VAR_NAME_OVERRIDES;
 var init_runner = __esm(() => {
   init_builtins();
+  init_connector();
   init_database();
+  init_auth();
   __dirname5 = dirname7(fileURLToPath5(import.meta.url));
   CONNECTORS_DIR2 = resolveConnectorsDir2();
   ENV_VAR_NAME_OVERRIDES = {
@@ -29774,8 +30542,8 @@ var exports_serve = {};
 __export(exports_serve, {
   startServer: () => startServer
 });
-import { existsSync as existsSync17, readdirSync as readdirSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync11 } from "fs";
-import { join as join18, dirname as dirname8, extname, basename } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
+import { join as join18, dirname as dirname8, extname, basename as basename3 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function logActivity(action, connector, detail) {
   activityLog.unshift({ action, connector, timestamp: Date.now(), detail });
@@ -30324,7 +31092,7 @@ ${result.stderr}`;
         if (!isValidConnectorName(name))
           return json({ error: "Invalid connector name" }, 400, port);
         try {
-          const profiles = listProfiles2(name);
+          const profiles = listProfiles4(name);
           const configDir = join18(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
           const currentProfileFile = join18(configDir, "current_profile");
           let current = "default";
@@ -30380,7 +31148,7 @@ ${result.stderr}`;
           const connectDir = getConnectorsHome();
           const result = {};
           if (existsSync17(connectDir)) {
-            const entries = readdirSync11(connectDir, { withFileTypes: true });
+            const entries = readdirSync10(connectDir, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory() || !entry.name.startsWith("connect-"))
                 continue;
@@ -30389,10 +31157,10 @@ ${result.stderr}`;
               if (!existsSync17(profilesDir))
                 continue;
               const profiles = {};
-              const profileEntries = readdirSync11(profilesDir, { withFileTypes: true });
+              const profileEntries = readdirSync10(profilesDir, { withFileTypes: true });
               for (const pEntry of profileEntries) {
                 if (pEntry.isFile() && pEntry.name.endsWith(".json")) {
-                  const profileName = basename(pEntry.name, ".json");
+                  const profileName = basename3(pEntry.name, ".json");
                   try {
                     const config = JSON.parse(readFileSync9(join18(profilesDir, pEntry.name), "utf-8"));
                     profiles[profileName] = config;
@@ -30448,7 +31216,7 @@ ${result.stderr}`;
             for (const [profileName, config] of Object.entries(data.profiles)) {
               if (!config || typeof config !== "object")
                 continue;
-              mkdirSync11(profilesDir, { recursive: true });
+              mkdirSync10(profilesDir, { recursive: true });
               const profileFile = join18(profilesDir, `${profileName}.json`);
               writeFileSync8(profileFile, JSON.stringify(config, null, 2));
               imported++;
@@ -32070,7 +32838,7 @@ init_registry2();
 init_installer();
 import { render } from "ink";
 import chalk2 from "chalk";
-import { readdirSync as readdirSync8, statSync as statSync4 } from "fs";
+import { readdirSync as readdirSync7, statSync as statSync4 } from "fs";
 import { join as join13, relative as relative2 } from "path";
 import { createInterface } from "readline";
 import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
@@ -32085,7 +32853,7 @@ var PRESETS = {
 };
 function listFilesRecursive(dir, base = dir) {
   const files = [];
-  for (const entry of readdirSync8(dir)) {
+  for (const entry of readdirSync7(dir)) {
     const fullPath = join13(dir, entry);
     if (statSync4(fullPath).isDirectory()) {
       files.push(...listFilesRecursive(fullPath, base));
@@ -32757,7 +33525,7 @@ init_installer();
 init_auth();
 init_database();
 import chalk4 from "chalk";
-import { existsSync as existsSync18, readdirSync as readdirSync12, statSync as statSync7, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync11, statSync as statSync7, readFileSync as readFileSync10 } from "fs";
 import { join as join19 } from "path";
 function registerCommands3(program2) {
   program2.command("status").option("--json", "Output as JSON", false).description("Show auth status of all configured connectors (project + global)").action((options) => {
@@ -32810,7 +33578,7 @@ function registerCommands3(program2) {
     }
     if (existsSync18(configDir)) {
       try {
-        const globalDirs = readdirSync12(configDir).filter((f) => {
+        const globalDirs = readdirSync11(configDir).filter((f) => {
           if (!f.startsWith("connect-"))
             return false;
           if (f.startsWith("connect-zzztest"))
@@ -33029,7 +33797,7 @@ init_registry2();
 init_auth();
 init_database();
 import chalk5 from "chalk";
-import { existsSync as existsSync19, readdirSync as readdirSync13, statSync as statSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync9, mkdirSync as mkdirSync12 } from "fs";
+import { existsSync as existsSync19, readdirSync as readdirSync12, statSync as statSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync9, mkdirSync as mkdirSync11 } from "fs";
 import { join as join20 } from "path";
 import { homedir as homedir8 } from "os";
 import { createInterface as createInterface2 } from "readline";
@@ -33083,7 +33851,7 @@ function redactSecrets(obj) {
   return obj;
 }
 function getOAuthTokenState(name) {
-  const tokens = loadTokens(name);
+  const tokens = loadTokens3(name);
   if (!tokens?.accessToken && !tokens?.refreshToken) {
     return { hasTokens: false, expired: false };
   }
@@ -33226,9 +33994,9 @@ ${meta.displayName} \u2014 Auth Configuration
       try {
         if (!options.browser) {
           console.log(chalk5.dim(`Starting OAuth server on port ${port}...`));
-          const { spawn: spawn4 } = await import("child_process");
+          const { spawn: spawn3 } = await import("child_process");
           const scriptPath = process.argv[1];
-          const serverProc = spawn4("node", [scriptPath, "serve", "--port", String(port)], {
+          const serverProc = spawn3("node", [scriptPath, "serve", "--port", String(port)], {
             detached: true,
             stdio: "ignore"
           });
@@ -33402,7 +34170,7 @@ Open this URL to authenticate:
     const configuredNames = [];
     try {
       if (existsSync19(connectorsHome)) {
-        const entries = readdirSync13(connectorsHome).filter((e) => e.startsWith("connect-") && statSync8(join20(connectorsHome, e)).isDirectory());
+        const entries = readdirSync12(connectorsHome).filter((e) => e.startsWith("connect-") && statSync8(join20(connectorsHome, e)).isDirectory());
         for (const entry of entries) {
           const profilesDir = join20(connectorsHome, entry, "profiles");
           if (existsSync19(profilesDir)) {
@@ -33457,7 +34225,7 @@ Open this URL to authenticate:
     const connectDir = getConnectorsHome();
     const result = {};
     if (existsSync19(connectDir)) {
-      for (const entry of readdirSync13(connectDir)) {
+      for (const entry of readdirSync12(connectDir)) {
         const entryPath = join20(connectDir, entry);
         if (!statSync8(entryPath).isDirectory() || !entry.startsWith("connect-"))
           continue;
@@ -33474,7 +34242,7 @@ Open this URL to authenticate:
           continue;
         const profiles = {};
         if (existsSync19(profilesDir)) {
-          for (const pEntry of readdirSync13(profilesDir)) {
+          for (const pEntry of readdirSync12(profilesDir)) {
             const pPath = join20(profilesDir, pEntry);
             if (statSync8(pPath).isFile() && pEntry.endsWith(".json")) {
               try {
@@ -33565,7 +34333,7 @@ Open this URL to authenticate:
         continue;
       const connectorDir = join20(connectDir, `connect-${connectorName}`);
       if (connData.credentials && typeof connData.credentials === "object") {
-        mkdirSync12(connectorDir, { recursive: true });
+        mkdirSync11(connectorDir, { recursive: true });
         writeFileSync9(join20(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
         imported++;
       }
@@ -33575,7 +34343,7 @@ Open this URL to authenticate:
       for (const [profileName, config] of Object.entries(connData.profiles)) {
         if (!config || typeof config !== "object")
           continue;
-        mkdirSync12(profilesDir, { recursive: true });
+        mkdirSync11(profilesDir, { recursive: true });
         writeFileSync9(join20(profilesDir, `${profileName}.json`), JSON.stringify(config, null, 2));
         imported++;
       }
@@ -33597,7 +34365,7 @@ Open this URL to authenticate:
       }
       return;
     }
-    const entries = readdirSync13(oldBase).filter((name) => {
+    const entries = readdirSync12(oldBase).filter((name) => {
       if (!name.startsWith("connect-"))
         return false;
       try {
@@ -33637,7 +34405,7 @@ Open this URL to authenticate:
         }
         if (!options.dryRun) {
           const parentDir = join20(destPath, "..");
-          mkdirSync12(parentDir, { recursive: true });
+          mkdirSync11(parentDir, { recursive: true });
           const content = readFileSync11(srcPath);
           writeFileSync9(destPath, content);
         }
@@ -33705,7 +34473,7 @@ init_installer();
 init_auth();
 init_database();
 import chalk6 from "chalk";
-import { existsSync as existsSync20, readdirSync as readdirSync14, statSync as statSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync13, statSync as statSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
 import { join as join21 } from "path";
 
 // src/lib/test-endpoints.ts
@@ -34147,7 +34915,7 @@ Available presets:
     }
     if (existsSync20(configDir)) {
       try {
-        const globalDirs = readdirSync14(configDir).filter((f) => {
+        const globalDirs = readdirSync13(configDir).filter((f) => {
           if (!f.startsWith("connect-"))
             return false;
           try {
@@ -34564,12 +35332,12 @@ Setting up ${meta.displayName}...
   ${chalk7.bold("Open this URL to authenticate:")}`);
             console.log(`  ${chalk7.cyan(oauthUrl)}
 `);
-            const { spawn: spawn4 } = await import("child_process");
+            const { spawn: spawn3 } = await import("child_process");
             const { getConnectorsHome: getConnectorsHome2 } = await Promise.resolve().then(() => (init_database(), exports_database));
             const { existsSync: existsSync8 } = await import("fs");
             const { join: join8 } = await import("path");
             const scriptPath = process.argv[1];
-            const serverProc = spawn4("node", [scriptPath, "serve", "--port", String(port)], {
+            const serverProc = spawn3("node", [scriptPath, "serve", "--port", String(port)], {
               detached: true,
               stdio: "ignore"
             });