@hasna/connectors 1.3.31 → 1.3.33

package/connectors/connect-googledrive/dist/index.js

@@ -1,1301 +0,0 @@
-// @bun
-// src/types/index.ts
-class DriveApiError extends Error {
-  statusCode;
-  errors;
-  constructor(message, statusCode, errors) {
-    super(message);
-    this.name = "DriveApiError";
-    this.statusCode = statusCode;
-    this.errors = errors;
-  }
-}
-var MIME_TYPES = {
-  FOLDER: "application/vnd.google-apps.folder",
-  DOCUMENT: "application/vnd.google-apps.document",
-  SPREADSHEET: "application/vnd.google-apps.spreadsheet",
-  PRESENTATION: "application/vnd.google-apps.presentation",
-  FORM: "application/vnd.google-apps.form",
-  DRAWING: "application/vnd.google-apps.drawing",
-  SCRIPT: "application/vnd.google-apps.script",
-  SITE: "application/vnd.google-apps.site",
-  SHORTCUT: "application/vnd.google-apps.shortcut",
-  PDF: "application/pdf",
-  DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  CSV: "text/csv",
-  TXT: "text/plain",
-  HTML: "text/html",
-  RTF: "application/rtf",
-  ODS: "application/vnd.oasis.opendocument.spreadsheet",
-  ODT: "application/vnd.oasis.opendocument.text",
-  ZIP: "application/zip",
-  JPEG: "image/jpeg",
-  PNG: "image/png",
-  SVG: "image/svg+xml"
-};
-
-// src/utils/auth.ts
-import { createServer } from "http";
-
-// src/utils/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync, renameSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var DEFAULT_PROFILE = "default";
-var CURRENT_PROFILE_FILE = "current_profile";
-var PROFILES_DIR = "profiles";
-var profileOverride;
-function resolveBaseConfigDir() {
-  return join(homedir(), ".hasna", "connectors", "connect-googledrive");
-}
-var BASE_CONFIG_DIR = resolveBaseConfigDir();
-function setProfileOverride(profile) {
-  profileOverride = profile;
-}
-function getProfileOverride() {
-  return profileOverride;
-}
-function ensureBaseConfigDir() {
-  if (!existsSync(BASE_CONFIG_DIR)) {
-    mkdirSync(BASE_CONFIG_DIR, { recursive: true });
-  }
-}
-function getProfilesDir() {
-  return join(BASE_CONFIG_DIR, PROFILES_DIR);
-}
-function getCurrentProfileFile() {
-  return join(BASE_CONFIG_DIR, CURRENT_PROFILE_FILE);
-}
-function migrateToProfileStructure() {
-  const profilesDir = getProfilesDir();
-  const defaultProfileDir = join(profilesDir, DEFAULT_PROFILE);
-  if (existsSync(profilesDir)) {
-    return;
-  }
-  const oldConfigFile = join(BASE_CONFIG_DIR, "config.json");
-  const oldTokensFile = join(BASE_CONFIG_DIR, "tokens.json");
-  const hasOldStructure = existsSync(oldConfigFile) || existsSync(oldTokensFile);
-  if (!hasOldStructure) {
-    mkdirSync(profilesDir, { recursive: true });
-    return;
-  }
-  mkdirSync(defaultProfileDir, { recursive: true });
-  if (existsSync(oldConfigFile)) {
-    renameSync(oldConfigFile, join(defaultProfileDir, "config.json"));
-  }
-  if (existsSync(oldTokensFile)) {
-    renameSync(oldTokensFile, join(defaultProfileDir, "tokens.json"));
-  }
-  writeFileSync(getCurrentProfileFile(), DEFAULT_PROFILE);
-}
-function getCurrentProfile() {
-  if (profileOverride) {
-    return profileOverride;
-  }
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  const currentProfileFile = getCurrentProfileFile();
-  if (existsSync(currentProfileFile)) {
-    try {
-      const profile = readFileSync(currentProfileFile, "utf-8").trim();
-      if (profile && profileExists(profile)) {
-        return profile;
-      }
-    } catch {}
-  }
-  return DEFAULT_PROFILE;
-}
-function profileExists(profile) {
-  const profileDir = join(getProfilesDir(), profile);
-  return existsSync(profileDir);
-}
-function listProfiles() {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  const profilesDir = getProfilesDir();
-  if (!existsSync(profilesDir)) {
-    return [];
-  }
-  return readdirSync(profilesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
-}
-function resolveConfigDir() {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  const profile = getCurrentProfile();
-  const profileDir = join(getProfilesDir(), profile);
-  if (!existsSync(profileDir)) {
-    mkdirSync(profileDir, { recursive: true });
-  }
-  return profileDir;
-}
-function getConfigDirInternal() {
-  return resolveConfigDir();
-}
-function ensureConfigDir() {
-  const configDir = getConfigDirInternal();
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
-  }
-}
-function saveConfig(config) {
-  ensureConfigDir();
-  const configFile = join(getConfigDirInternal(), "config.json");
-  writeFileSync(configFile, JSON.stringify(config, null, 2));
-}
-function loadBaseConfig() {
-  ensureBaseConfigDir();
-  const configFile = join(BASE_CONFIG_DIR, "credentials.json");
-  if (!existsSync(configFile)) {
-    const profiles = listProfiles();
-    for (const profile of profiles) {
-      const profileConfigFile = join(getProfilesDir(), profile, "config.json");
-      if (existsSync(profileConfigFile)) {
-        try {
-          const content = readFileSync(profileConfigFile, "utf-8");
-          const profileConfig = JSON.parse(content);
-          if (profileConfig.clientId && profileConfig.clientSecret) {
-            writeFileSync(configFile, JSON.stringify({
-              clientId: profileConfig.clientId,
-              clientSecret: profileConfig.clientSecret
-            }, null, 2));
-            return { clientId: profileConfig.clientId, clientSecret: profileConfig.clientSecret };
-          }
-        } catch {}
-      }
-    }
-    return {};
-  }
-  try {
-    const content = readFileSync(configFile, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function getClientId() {
-  return process.env.GOOGLE_CLIENT_ID || loadBaseConfig().clientId;
-}
-function getClientSecret() {
-  return process.env.GOOGLE_CLIENT_SECRET || loadBaseConfig().clientSecret;
-}
-function loadTokens() {
-  ensureConfigDir();
-  const tokensFile = join(getConfigDirInternal(), "tokens.json");
-  if (!existsSync(tokensFile)) {
-    return null;
-  }
-  try {
-    const content = readFileSync(tokensFile, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function saveTokens(tokens) {
-  ensureConfigDir();
-  const tokensFile = join(getConfigDirInternal(), "tokens.json");
-  writeFileSync(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
-}
-function clearTokens() {
-  const tokensFile = join(getConfigDirInternal(), "tokens.json");
-  if (existsSync(tokensFile)) {
-    writeFileSync(tokensFile, "{}");
-  }
-}
-function clearConfig() {
-  saveConfig({});
-  clearTokens();
-}
-function isAuthenticated() {
-  const tokens = loadTokens();
-  return tokens !== null && tokens.accessToken !== undefined && tokens.refreshToken !== undefined;
-}
-
-// src/utils/auth.ts
-var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
-var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
-var DRIVE_SCOPES = [
-  "https://www.googleapis.com/auth/drive",
-  "https://www.googleapis.com/auth/drive.file",
-  "https://www.googleapis.com/auth/drive.metadata",
-  "https://www.googleapis.com/auth/drive.appdata",
-  "https://www.googleapis.com/auth/userinfo.email",
-  "https://www.googleapis.com/auth/userinfo.profile"
-].join(" ");
-var REDIRECT_PORT = 8090;
-var REDIRECT_URI = "http://localhost:" + REDIRECT_PORT + "/callback";
-function getAuthUrl() {
-  const clientId = getClientId();
-  if (!clientId) {
-    throw new Error('Client ID not configured. Run "connect-googledrive config set-credentials" first.');
-  }
-  const params = new URLSearchParams({
-    client_id: clientId,
-    redirect_uri: REDIRECT_URI,
-    response_type: "code",
-    scope: DRIVE_SCOPES,
-    access_type: "offline",
-    prompt: "consent"
-  });
-  return GOOGLE_AUTH_URL + "?" + params.toString();
-}
-async function exchangeCodeForTokens(code) {
-  const clientId = getClientId();
-  const clientSecret = getClientSecret();
-  if (!clientId || !clientSecret) {
-    throw new Error("OAuth credentials not configured");
-  }
-  const response = await fetch(GOOGLE_TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      code,
-      client_id: clientId,
-      client_secret: clientSecret,
-      redirect_uri: REDIRECT_URI,
-      grant_type: "authorization_code"
-    })
-  });
-  if (!response.ok) {
-    const errorData = await response.json();
-    throw new Error("Token exchange failed: " + (errorData.error_description || errorData.error));
-  }
-  const data = await response.json();
-  const tokens = {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token,
-    expiresAt: Date.now() + data.expires_in * 1000,
-    tokenType: data.token_type,
-    scope: data.scope
-  };
-  saveTokens(tokens);
-  return tokens;
-}
-async function refreshAccessToken() {
-  const clientId = getClientId();
-  const clientSecret = getClientSecret();
-  const currentTokens = loadTokens();
-  if (!clientId || !clientSecret) {
-    throw new Error("OAuth credentials not configured");
-  }
-  if (!currentTokens?.refreshToken) {
-    throw new Error("No refresh token available. Please login again.");
-  }
-  const response = await fetch(GOOGLE_TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      client_id: clientId,
-      client_secret: clientSecret,
-      refresh_token: currentTokens.refreshToken,
-      grant_type: "refresh_token"
-    })
-  });
-  if (!response.ok) {
-    const errorData = await response.json();
-    throw new Error("Token refresh failed: " + (errorData.error_description || errorData.error));
-  }
-  const data = await response.json();
-  const tokens = {
-    accessToken: data.access_token,
-    refreshToken: currentTokens.refreshToken,
-    expiresAt: Date.now() + data.expires_in * 1000,
-    tokenType: data.token_type,
-    scope: data.scope || currentTokens.scope
-  };
-  saveTokens(tokens);
-  return tokens;
-}
-function startCallbackServer() {
-  return new Promise((resolve) => {
-    const server = createServer(async (req, res) => {
-      const url = new URL(req.url || "", "http://localhost:" + REDIRECT_PORT);
-      if (url.pathname === "/callback") {
-        const code = url.searchParams.get("code");
-        const error = url.searchParams.get("error");
-        if (error) {
-          res.writeHead(200, { "Content-Type": "text/html" });
-          res.end('<html><body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;"><div style="text-align: center;"><h1 style="color: #dc3545;">Authentication Failed</h1><p>Error: ' + error + "</p><p>You can close this window.</p></div></body></html>");
-          server.close();
-          resolve({ success: false, error });
-          return;
-        }
-        if (code) {
-          try {
-            const tokens = await exchangeCodeForTokens(code);
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end('<html><body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;"><div style="text-align: center;"><h1 style="color: #28a745;">Authentication Successful!</h1><p>You can close this window and return to the terminal.</p></div></body></html>');
-            server.close();
-            resolve({ success: true, tokens });
-          } catch (err) {
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end('<html><body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;"><div style="text-align: center;"><h1 style="color: #dc3545;">Authentication Failed</h1><p>Error: ' + String(err) + "</p><p>You can close this window.</p></div></body></html>");
-            server.close();
-            resolve({ success: false, error: String(err) });
-          }
-        }
-      }
-    });
-    server.listen(REDIRECT_PORT, () => {});
-    setTimeout(() => {
-      server.close();
-      resolve({ success: false, error: "Authentication timed out" });
-    }, 5 * 60 * 1000);
-  });
-}
-async function getValidAccessToken() {
-  const tokens = loadTokens();
-  if (!tokens) {
-    throw new Error('Not authenticated. Run "connect-googledrive auth login" first.');
-  }
-  if (Date.now() >= tokens.expiresAt - 5 * 60 * 1000) {
-    const newTokens = await refreshAccessToken();
-    return newTokens.accessToken;
-  }
-  return tokens.accessToken;
-}
-
-// src/api/client.ts
-var DRIVE_API_BASE = "https://www.googleapis.com/drive/v3";
-var UPLOAD_API_BASE = "https://www.googleapis.com/upload/drive/v3";
-
-class DriveClient {
-  constructor() {}
-  buildUrl(path, params, isUpload = false) {
-    const base = isUpload ? UPLOAD_API_BASE : DRIVE_API_BASE;
-    const url = new URL(base + path);
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null && value !== "") {
-          url.searchParams.append(key, String(value));
-        }
-      });
-    }
-    return url.toString();
-  }
-  async request(path, options = {}) {
-    const { method = "GET", params, body, headers = {}, isUpload = false, rawResponse = false } = options;
-    const accessToken = await getValidAccessToken();
-    const url = this.buildUrl(path, params, isUpload);
-    const requestHeaders = {
-      Authorization: "Bearer " + accessToken,
-      Accept: "application/json",
-      ...headers
-    };
-    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
-      if (body instanceof Buffer || body instanceof Uint8Array) {} else if (typeof body === "string") {
-        requestHeaders["Content-Type"] = "application/json";
-      } else {
-        requestHeaders["Content-Type"] = "application/json";
-      }
-    }
-    const fetchOptions = {
-      method,
-      headers: requestHeaders
-    };
-    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
-      if (body instanceof Buffer || body instanceof Uint8Array) {
-        fetchOptions.body = body;
-      } else if (typeof body === "string") {
-        fetchOptions.body = body;
-      } else {
-        fetchOptions.body = JSON.stringify(body);
-      }
-    }
-    const response = await fetch(url, fetchOptions);
-    if (response.status === 204) {
-      return {};
-    }
-    if (rawResponse) {
-      return response;
-    }
-    let data;
-    const contentType = response.headers.get("content-type") || "";
-    if (contentType.includes("application/json")) {
-      const text = await response.text();
-      if (text) {
-        try {
-          data = JSON.parse(text);
-        } catch {
-          data = text;
-        }
-      }
-    } else {
-      data = await response.text();
-    }
-    if (!response.ok) {
-      const errorData = data;
-      const errorMessage = errorData?.error?.message || String(data || response.statusText);
-      throw new DriveApiError(errorMessage, response.status, errorData?.error?.errors);
-    }
-    return data;
-  }
-  async get(path, params) {
-    return this.request(path, { method: "GET", params });
-  }
-  async post(path, body, params) {
-    return this.request(path, { method: "POST", body, params });
-  }
-  async put(path, body, params) {
-    return this.request(path, { method: "PUT", body, params });
-  }
-  async patch(path, body, params) {
-    return this.request(path, { method: "PATCH", body, params });
-  }
-  async delete(path, params) {
-    return this.request(path, { method: "DELETE", params });
-  }
-  async upload(path, content, metadata, params, mimeType) {
-    const accessToken = await getValidAccessToken();
-    const boundary = "-------314159265358979323846";
-    const delimiter = `\r
---` + boundary + `\r
-`;
-    const closeDelimiter = `\r
---` + boundary + "--";
-    let multipartBody = "";
-    if (metadata) {
-      multipartBody += delimiter;
-      multipartBody += `Content-Type: application/json; charset=UTF-8\r
-\r
-`;
-      multipartBody += JSON.stringify(metadata);
-    }
-    multipartBody += delimiter;
-    multipartBody += "Content-Type: " + (mimeType || "application/octet-stream") + `\r
-`;
-    multipartBody += `Content-Transfer-Encoding: base64\r
-\r
-`;
-    const base64Content = Buffer.from(content).toString("base64");
-    multipartBody += base64Content;
-    multipartBody += closeDelimiter;
-    const url = this.buildUrl(path, { ...params, uploadType: "multipart" }, true);
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: "Bearer " + accessToken,
-        "Content-Type": "multipart/related; boundary=" + boundary
-      },
-      body: multipartBody
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new DriveApiError(errorData?.error?.message || response.statusText, response.status, errorData?.error?.errors);
-    }
-    return response.json();
-  }
-  async download(fileId) {
-    const accessToken = await getValidAccessToken();
-    const url = DRIVE_API_BASE + "/files/" + fileId + "?alt=media&supportsAllDrives=true";
-    const response = await fetch(url, {
-      headers: {
-        Authorization: "Bearer " + accessToken
-      }
-    });
-    if (!response.ok) {
-      throw new DriveApiError("Download failed: " + response.statusText, response.status);
-    }
-    return response.arrayBuffer();
-  }
-  async export(fileId, mimeType) {
-    const accessToken = await getValidAccessToken();
-    const url = DRIVE_API_BASE + "/files/" + fileId + "/export?mimeType=" + encodeURIComponent(mimeType) + "&supportsAllDrives=true";
-    const response = await fetch(url, {
-      headers: {
-        Authorization: "Bearer " + accessToken
-      }
-    });
-    if (!response.ok) {
-      throw new DriveApiError("Export failed: " + response.statusText, response.status);
-    }
-    return response.arrayBuffer();
-  }
-}
-
-// src/api/files.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename, extname } from "path";
-var DEFAULT_FILE_FIELDS = "id,name,mimeType,size,createdTime,modifiedTime,parents,webViewLink,webContentLink,trashed,starred,shared,owners,permissions";
-
-class FilesApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(options = {}) {
-    const params = {
-      pageSize: options.pageSize || 100,
-      pageToken: options.pageToken,
-      q: options.q,
-      orderBy: options.orderBy || "modifiedTime desc",
-      fields: options.fields || "nextPageToken,files(" + DEFAULT_FILE_FIELDS + ")",
-      spaces: options.spaces || "drive",
-      supportsAllDrives: options.supportsAllDrives ?? true,
-      includeItemsFromAllDrives: options.includeItemsFromAllDrives ?? true
-    };
-    if (options.corpora) {
-      params.corpora = options.corpora;
-    }
-    if (options.driveId) {
-      params.driveId = options.driveId;
-    }
-    return this.client.get("/files", params);
-  }
-  async get(fileId, fields) {
-    return this.client.get("/files/" + fileId, {
-      fields: fields || DEFAULT_FILE_FIELDS,
-      supportsAllDrives: true
-    });
-  }
-  async download(fileId, destPath) {
-    const file = await this.get(fileId);
-    if (file.mimeType.startsWith("application/vnd.google-apps.")) {
-      const exportMimeType = this.getExportMimeType(file.mimeType);
-      if (!exportMimeType) {
-        throw new Error("Cannot download Google Workspace file type: " + file.mimeType);
-      }
-      const data2 = await this.client.export(fileId, exportMimeType);
-      const ext = this.getExtensionForMimeType(exportMimeType);
-      const filename2 = file.name + ext;
-      if (destPath) {
-        writeFileSync2(destPath, Buffer.from(data2));
-      }
-      return { data: data2, filename: filename2 };
-    }
-    const data = await this.client.download(fileId);
-    const filename = file.name;
-    if (destPath) {
-      writeFileSync2(destPath, Buffer.from(data));
-    }
-    return { data, filename };
-  }
-  async upload(filePath, options) {
-    const content = readFileSync2(filePath);
-    const name = options?.name || basename(filePath);
-    const metadata = { name };
-    if (options?.folderId) {
-      metadata.parents = [options.folderId];
-    }
-    const mimeType = options?.mimeType || this.getMimeTypeFromExtension(extname(filePath));
-    return this.client.upload("/files", content, metadata, { fields: DEFAULT_FILE_FIELDS, supportsAllDrives: true }, mimeType);
-  }
-  async create(name, content, options) {
-    const metadata = { name };
-    if (options?.folderId) {
-      metadata.parents = [options.folderId];
-    }
-    const buffer = typeof content === "string" ? Buffer.from(content) : content;
-    const mimeType = options?.mimeType || "text/plain";
-    return this.client.upload("/files", buffer, metadata, { fields: DEFAULT_FILE_FIELDS, supportsAllDrives: true }, mimeType);
-  }
-  async update(fileId, metadata) {
-    return this.client.patch("/files/" + fileId, metadata, {
-      fields: DEFAULT_FILE_FIELDS,
-      supportsAllDrives: true
-    });
-  }
-  async delete(fileId) {
-    await this.client.delete("/files/" + fileId, { supportsAllDrives: true });
-  }
-  async trash(fileId) {
-    return this.update(fileId, { trashed: true });
-  }
-  async untrash(fileId) {
-    return this.update(fileId, { trashed: false });
-  }
-  async move(fileId, newParentId) {
-    const file = await this.get(fileId);
-    const currentParents = file.parents?.join(",") || "";
-    return this.client.patch("/files/" + fileId, {}, {
-      addParents: newParentId,
-      removeParents: currentParents,
-      fields: DEFAULT_FILE_FIELDS,
-      supportsAllDrives: true
-    });
-  }
-  async copy(fileId, options) {
-    const metadata = {};
-    if (options?.name) {
-      metadata.name = options.name;
-    }
-    if (options?.folderId) {
-      metadata.parents = [options.folderId];
-    }
-    return this.client.post("/files/" + fileId + "/copy", metadata, {
-      fields: DEFAULT_FILE_FIELDS,
-      supportsAllDrives: true
-    });
-  }
-  async share(fileId, email, role, options) {
-    const permission = {
-      type: "user",
-      role,
-      emailAddress: email
-    };
-    const params = {
-      supportsAllDrives: true,
-      sendNotificationEmail: options?.sendNotificationEmail ?? true
-    };
-    if (options?.emailMessage) {
-      params.emailMessage = options.emailMessage;
-    }
-    if (options?.transferOwnership) {
-      params.transferOwnership = options.transferOwnership;
-    }
-    return this.client.post("/files/" + fileId + "/permissions", permission, params);
-  }
-  async listPermissions(fileId) {
-    return this.client.get("/files/" + fileId + "/permissions", {
-      supportsAllDrives: true,
-      fields: "permissions(id,type,role,emailAddress,displayName,domain)"
-    });
-  }
-  async removePermission(fileId, permissionId) {
-    await this.client.delete("/files/" + fileId + "/permissions/" + permissionId, {
-      supportsAllDrives: true
-    });
-  }
-  async search(query, options) {
-    const q = "fullText contains '" + query.replace(/'/g, "\\'") + "' and trashed = false";
-    return this.list({
-      q,
-      pageSize: options?.pageSize,
-      pageToken: options?.pageToken
-    });
-  }
-  getExportMimeType(googleMimeType) {
-    const exportMap = {
-      [MIME_TYPES.DOCUMENT]: MIME_TYPES.DOCX,
-      [MIME_TYPES.SPREADSHEET]: MIME_TYPES.XLSX,
-      [MIME_TYPES.PRESENTATION]: MIME_TYPES.PPTX,
-      [MIME_TYPES.DRAWING]: MIME_TYPES.PNG
-    };
-    return exportMap[googleMimeType] || null;
-  }
-  getExtensionForMimeType(mimeType) {
-    const extMap = {
-      [MIME_TYPES.DOCX]: ".docx",
-      [MIME_TYPES.XLSX]: ".xlsx",
-      [MIME_TYPES.PPTX]: ".pptx",
-      [MIME_TYPES.PDF]: ".pdf",
-      [MIME_TYPES.PNG]: ".png",
-      [MIME_TYPES.JPEG]: ".jpg",
-      [MIME_TYPES.CSV]: ".csv",
-      [MIME_TYPES.TXT]: ".txt",
-      [MIME_TYPES.HTML]: ".html"
-    };
-    return extMap[mimeType] || "";
-  }
-  getMimeTypeFromExtension(ext) {
-    const mimeMap = {
-      ".txt": "text/plain",
-      ".html": "text/html",
-      ".htm": "text/html",
-      ".css": "text/css",
-      ".js": "application/javascript",
-      ".json": "application/json",
-      ".xml": "application/xml",
-      ".pdf": "application/pdf",
-      ".doc": "application/msword",
-      ".docx": MIME_TYPES.DOCX,
-      ".xls": "application/vnd.ms-excel",
-      ".xlsx": MIME_TYPES.XLSX,
-      ".ppt": "application/vnd.ms-powerpoint",
-      ".pptx": MIME_TYPES.PPTX,
-      ".jpg": "image/jpeg",
-      ".jpeg": "image/jpeg",
-      ".png": "image/png",
-      ".gif": "image/gif",
-      ".svg": "image/svg+xml",
-      ".webp": "image/webp",
-      ".mp3": "audio/mpeg",
-      ".mp4": "video/mp4",
-      ".zip": "application/zip",
-      ".gz": "application/gzip",
-      ".tar": "application/x-tar"
-    };
-    return mimeMap[ext.toLowerCase()] || "application/octet-stream";
-  }
-}
-
-// src/api/folders.ts
-var DEFAULT_FILE_FIELDS2 = "id,name,mimeType,size,createdTime,modifiedTime,parents,webViewLink,webContentLink,trashed,starred,shared,owners";
-
-class FoldersApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(parentId) {
-    let q = "mimeType = '" + MIME_TYPES.FOLDER + "' and trashed = false";
-    if (parentId) {
-      q += " and '" + parentId + "' in parents";
-    }
-    return this.client.get("/files", {
-      q,
-      pageSize: 100,
-      orderBy: "name",
-      fields: "nextPageToken,files(" + DEFAULT_FILE_FIELDS2 + ")",
-      supportsAllDrives: true,
-      includeItemsFromAllDrives: true
-    });
-  }
-  async listContents(folderId) {
-    const q = "'" + folderId + "' in parents and trashed = false";
-    return this.client.get("/files", {
-      q,
-      pageSize: 100,
-      orderBy: "folder,name",
-      fields: "nextPageToken,files(" + DEFAULT_FILE_FIELDS2 + ")",
-      supportsAllDrives: true,
-      includeItemsFromAllDrives: true
-    });
-  }
-  async get(folderId) {
-    return this.client.get("/files/" + folderId, {
-      fields: DEFAULT_FILE_FIELDS2,
-      supportsAllDrives: true
-    });
-  }
-  async create(name, parentId) {
-    const metadata = {
-      name,
-      mimeType: MIME_TYPES.FOLDER
-    };
-    if (parentId) {
-      metadata.parents = [parentId];
-    }
-    return this.client.post("/files", metadata, {
-      fields: DEFAULT_FILE_FIELDS2,
-      supportsAllDrives: true
-    });
-  }
-  async delete(folderId, permanent = false) {
-    if (permanent) {
-      await this.client.delete("/files/" + folderId, { supportsAllDrives: true });
-    } else {
-      await this.client.patch("/files/" + folderId, { trashed: true }, {
-        supportsAllDrives: true
-      });
-    }
-  }
-  async rename(folderId, newName) {
-    return this.client.patch("/files/" + folderId, { name: newName }, {
-      fields: DEFAULT_FILE_FIELDS2,
-      supportsAllDrives: true
-    });
-  }
-  async move(folderId, newParentId) {
-    const folder = await this.get(folderId);
-    const currentParents = folder.parents?.join(",") || "";
-    return this.client.patch("/files/" + folderId, {}, {
-      addParents: newParentId,
-      removeParents: currentParents,
-      fields: DEFAULT_FILE_FIELDS2,
-      supportsAllDrives: true
-    });
-  }
-  async getPath(folderId) {
-    const path = [];
-    let currentId = folderId;
-    while (currentId) {
-      const folder = await this.get(currentId);
-      path.unshift(folder);
-      if (folder.parents && folder.parents.length > 0) {
-        currentId = folder.parents[0];
-      } else {
-        break;
-      }
-    }
-    return path;
-  }
-}
-
-// src/api/trash.ts
-var DEFAULT_FILE_FIELDS3 = "id,name,mimeType,size,createdTime,modifiedTime,parents,webViewLink,trashed,trashedTime,explicitlyTrashed";
-
-class TrashApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(pageSize = 100, pageToken) {
-    return this.client.get("/files", {
-      q: "trashed = true",
-      pageSize,
-      pageToken,
-      orderBy: "modifiedTime desc",
-      fields: "nextPageToken,files(" + DEFAULT_FILE_FIELDS3 + ")",
-      supportsAllDrives: true,
-      includeItemsFromAllDrives: true
-    });
-  }
-  async restore(fileId) {
-    return this.client.patch("/files/" + fileId, { trashed: false }, {
-      fields: DEFAULT_FILE_FIELDS3,
-      supportsAllDrives: true
-    });
-  }
-  async deletePermanently(fileId) {
-    await this.client.delete("/files/" + fileId, { supportsAllDrives: true });
-  }
-  async empty() {
-    await this.client.delete("/files/trash");
-  }
-}
-
-// src/api/storage.ts
-class StorageApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async getQuota() {
-    const about = await this.client.get("/about", {
-      fields: "storageQuota"
-    });
-    return about.storageQuota || {};
-  }
-  async getUser() {
-    const about = await this.client.get("/about", {
-      fields: "user"
-    });
-    return about.user || {};
-  }
-  async getAbout() {
-    return this.client.get("/about", {
-      fields: "kind,user,storageQuota,maxUploadSize,appInstalled,folderColorPalette,canCreateDrives"
-    });
-  }
-  async getFormats() {
-    const about = await this.client.get("/about", {
-      fields: "importFormats,exportFormats"
-    });
-    return {
-      importFormats: about.importFormats || {},
-      exportFormats: about.exportFormats || {}
-    };
-  }
-}
-
-// src/api/drives.ts
-class DrivesApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(options = {}) {
-    return this.client.get("/drives", {
-      pageSize: options.pageSize || 100,
-      pageToken: options.pageToken,
-      q: options.q,
-      useDomainAdminAccess: options.useDomainAdminAccess
-    });
-  }
-  async get(driveId, useDomainAdminAccess = false) {
-    return this.client.get("/drives/" + driveId, {
-      useDomainAdminAccess
-    });
-  }
-  async create(options) {
-    const requestId = crypto.randomUUID();
-    const metadata = {
-      name: options.name
-    };
-    if (options.themeId) {
-      metadata.themeId = options.themeId;
-    }
-    if (options.colorRgb) {
-      metadata.colorRgb = options.colorRgb;
-    }
-    if (options.restrictions) {
-      metadata.restrictions = options.restrictions;
-    }
-    return this.client.post("/drives", metadata, {
-      requestId
-    });
-  }
-  async update(driveId, updates) {
-    return this.client.patch("/drives/" + driveId, updates, {
-      useDomainAdminAccess: false
-    });
-  }
-  async delete(driveId, useDomainAdminAccess = false) {
-    await this.client.delete("/drives/" + driveId, {
-      useDomainAdminAccess,
-      allowItemDeletion: false
-    });
-  }
-  async hide(driveId) {
-    return this.client.post("/drives/" + driveId + "/hide", {});
-  }
-  async unhide(driveId) {
-    return this.client.post("/drives/" + driveId + "/unhide", {});
-  }
-  async listFiles(driveId, options = {}) {
-    let q = "trashed = false";
-    if (options.q) {
-      q += " and " + options.q;
-    }
-    return this.client.get("/files", {
-      driveId,
-      corpora: "drive",
-      q,
-      pageSize: options.pageSize || 100,
-      pageToken: options.pageToken,
-      includeItemsFromAllDrives: true,
-      supportsAllDrives: true,
-      fields: "nextPageToken,files(id,name,mimeType,size,createdTime,modifiedTime,parents,webViewLink)"
-    });
-  }
-}
-
-// src/api/bulk.ts
-class BulkApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async preview(query, maxResults = 50) {
-    const files = await this.fetchFiles(query, maxResults);
-    return { files, total: files.length, query };
-  }
-  async trash(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        await this.client.patch("/files/" + file.id, { trashed: true }, {
-          fields: "id,name",
-          supportsAllDrives: true
-        });
-      }
-    });
-  }
-  async delete(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        if (options.trash) {
-          await this.client.patch("/files/" + file.id, { trashed: true }, {
-            fields: "id,name",
-            supportsAllDrives: true
-          });
-        } else {
-          await this.client.delete("/files/" + file.id, { supportsAllDrives: true });
-        }
-      }
-    });
-  }
-  async untrash(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        await this.client.patch("/files/" + file.id, { trashed: false }, {
-          fields: "id,name",
-          supportsAllDrives: true
-        });
-      }
-    });
-  }
-  async move(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        const fullFile = await this.client.get("/files/" + file.id, {
-          fields: "parents",
-          supportsAllDrives: true
-        });
-        const currentParents = fullFile.parents?.join(",") || "";
-        await this.client.patch("/files/" + file.id, {}, {
-          addParents: options.destinationFolderId,
-          removeParents: currentParents,
-          fields: "id,name",
-          supportsAllDrives: true
-        });
-      }
-    });
-  }
-  async rename(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        const newName = this.applyRenamePattern(file.name, options);
-        await this.client.patch("/files/" + file.id, { name: newName }, {
-          fields: "id,name",
-          supportsAllDrives: true
-        });
-      }
-    });
-  }
-  async share(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        const permission = {
-          type: "user",
-          role: options.role,
-          emailAddress: options.email
-        };
-        const params = {
-          supportsAllDrives: true,
-          sendNotificationEmail: options.sendNotification ?? true
-        };
-        await this.client.post("/files/" + file.id + "/permissions", permission, params);
-      }
-    });
-  }
-  async makePublic(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        await this.client.post("/files/" + file.id + "/permissions", {
-          type: "anyone",
-          role: "reader"
-        }, {
-          supportsAllDrives: true,
-          sendNotificationEmail: false
-        });
-      }
-    });
-  }
-  async removePublicAccess(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        const perms = await this.client.get("/files/" + file.id + "/permissions", { supportsAllDrives: true, fields: "permissions(id,type)" });
-        const anyonePerm = perms.permissions.find((p) => p.type === "anyone");
-        if (anyonePerm) {
-          await this.client.delete("/files/" + file.id + "/permissions/" + anyonePerm.id, {
-            supportsAllDrives: true
-          });
-        }
-      }
-    });
-  }
-  async star(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        await this.client.patch("/files/" + file.id, { starred: true }, {
-          fields: "id,name",
-          supportsAllDrives: true
-        });
-      }
-    });
-  }
-  async unstar(options) {
-    const files = await this.fetchFiles(options.query, options.maxResults || 100);
-    return this.executeBatch(files, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (file) => {
-        await this.client.patch("/files/" + file.id, { starred: false }, {
-          fields: "id,name",
-          supportsAllDrives: true
-        });
-      }
-    });
-  }
-  async fetchFiles(query, maxResults) {
-    const files = [];
-    let pageToken;
-    const fields = "id,name,mimeType,size,parents,webViewLink";
-    while (files.length < maxResults) {
-      const params = {
-        pageSize: Math.min(100, maxResults - files.length),
-        pageToken,
-        q: query,
-        fields: "nextPageToken,files(" + fields + ")",
-        supportsAllDrives: true,
-        includeItemsFromAllDrives: true
-      };
-      const response = await this.client.get("/files", params);
-      if (!response.files || response.files.length === 0) {
-        break;
-      }
-      for (const f of response.files) {
-        files.push({
-          id: f.id,
-          name: f.name,
-          mimeType: f.mimeType,
-          size: f.size,
-          parents: f.parents,
-          webViewLink: f.webViewLink
-        });
-      }
-      pageToken = response.nextPageToken;
-      if (!pageToken)
-        break;
-    }
-    return files;
-  }
-  applyRenamePattern(name, options) {
-    switch (options.mode) {
-      case "prefix":
-        return (options.prefix || "") + name;
-      case "suffix": {
-        const dotIndex = name.lastIndexOf(".");
-        if (dotIndex > 0 && !name.startsWith(".")) {
-          return name.slice(0, dotIndex) + (options.suffix || "") + name.slice(dotIndex);
-        }
-        return name + (options.suffix || "");
-      }
-      case "replace":
-        return options.find ? name.replace(new RegExp(options.find, "g"), options.replace || "") : name;
-      case "lowercase": {
-        const dotIndex = name.lastIndexOf(".");
-        if (dotIndex > 0 && !name.startsWith(".")) {
-          return name.slice(0, dotIndex).toLowerCase() + name.slice(dotIndex);
-        }
-        return name.toLowerCase();
-      }
-      case "uppercase": {
-        const dotIndex = name.lastIndexOf(".");
-        if (dotIndex > 0 && !name.startsWith(".")) {
-          return name.slice(0, dotIndex).toUpperCase() + name.slice(dotIndex);
-        }
-        return name.toUpperCase();
-      }
-      default:
-        return name;
-    }
-  }
-  async executeBatch(files, options) {
-    const { dryRun, concurrency, onProgress, onError, operation } = options;
-    const result = {
-      total: files.length,
-      success: 0,
-      failed: 0,
-      skipped: 0,
-      errors: [],
-      processedFiles: []
-    };
-    if (files.length === 0) {
-      return result;
-    }
-    const chunks = this.chunkArray(files, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (file) => {
-        try {
-          if (dryRun) {
-            result.success++;
-            result.processedFiles.push(file);
-          } else {
-            await operation(file);
-            result.success++;
-            result.processedFiles.push(file);
-          }
-          if (onProgress) {
-            onProgress(result.success + result.failed, result.total, file);
-          }
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ fileId: file.id, error: errorMessage });
-          if (onError) {
-            onError(err instanceof Error ? err : new Error(errorMessage), file);
-          }
-        }
-      }));
-    }
-    return result;
-  }
-  chunkArray(array, size) {
-    const chunks = [];
-    for (let i = 0;i < array.length; i += size) {
-      chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
-  }
-}
-
-// src/api/index.ts
-class Drive {
-  client;
-  files;
-  folders;
-  trash;
-  storage;
-  drives;
-  bulk;
-  constructor() {
-    this.client = new DriveClient;
-    this.files = new FilesApi(this.client);
-    this.folders = new FoldersApi(this.client);
-    this.trash = new TrashApi(this.client);
-    this.storage = new StorageApi(this.client);
-    this.drives = new DrivesApi(this.client);
-    this.bulk = new BulkApi(this.client);
-  }
-  static create() {
-    return new Drive;
-  }
-  getClient() {
-    return this.client;
-  }
-}
-export {
-  startCallbackServer,
-  setProfileOverride,
-  saveTokens,
-  refreshAccessToken,
-  loadTokens,
-  isAuthenticated,
-  getValidAccessToken,
-  getProfileOverride,
-  getAuthUrl,
-  clearConfig,
-  TrashApi,
-  StorageApi,
-  MIME_TYPES,
-  FoldersApi,
-  FilesApi,
-  DriveClient,
-  DriveApiError,
-  Drive
-};