@hasna/connectors 1.3.31 → 1.3.33

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

@@ -1,1137 +0,0 @@
-// @bun
-var __require = import.meta.require;
-
-// src/types/index.ts
-class PhotosApiError extends Error {
-  statusCode;
-  status;
-  details;
-  constructor(message, statusCode, status, details) {
-    super(message);
-    this.name = "PhotosApiError";
-    this.statusCode = statusCode;
-    this.status = status;
-    this.details = details;
-  }
-}
-
-// 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-googlephotos");
-}
-var BASE_CONFIG_DIR = resolveBaseConfigDir();
-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 setCurrentProfile(profile) {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  if (!profileExists(profile)) {
-    throw new Error(`Profile "${profile}" does not exist. Create it first with "profile create ${profile}"`);
-  }
-  writeFileSync(getCurrentProfileFile(), 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 createProfile(profile) {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  if (profileExists(profile)) {
-    throw new Error(`Profile "${profile}" already exists`);
-  }
-  if (!/^[a-zA-Z0-9_-]+$/.test(profile)) {
-    throw new Error("Profile name can only contain letters, numbers, hyphens, and underscores");
-  }
-  const profileDir = join(getProfilesDir(), profile);
-  mkdirSync(profileDir, { recursive: true });
-}
-function deleteProfile(profile) {
-  if (profile === DEFAULT_PROFILE) {
-    throw new Error("Cannot delete the default profile");
-  }
-  if (!profileExists(profile)) {
-    throw new Error(`Profile "${profile}" does not exist`);
-  }
-  const currentProfile = getCurrentProfile();
-  if (currentProfile === profile) {
-    setCurrentProfile(DEFAULT_PROFILE);
-  }
-  const profileDir = join(getProfilesDir(), profile);
-  rmSync(profileDir, { recursive: true });
-}
-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_PHOTOS_CLIENT_ID || loadBaseConfig().clientId;
-}
-function getClientSecret() {
-  return process.env.GOOGLE_PHOTOS_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 PHOTOS_SCOPES = [
-  "https://www.googleapis.com/auth/photoslibrary.appendonly",
-  "https://www.googleapis.com/auth/photoslibrary.readonly.appcreateddata",
-  "https://www.googleapis.com/auth/photoslibrary.edit.appcreateddata",
-  "https://www.googleapis.com/auth/userinfo.email"
-].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-googlephotos config set-credentials" first.');
-  }
-  const params = new URLSearchParams({
-    client_id: clientId,
-    redirect_uri: REDIRECT_URI,
-    response_type: "code",
-    scope: PHOTOS_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 error = await response.json();
-    throw new Error(`Token exchange failed: ${error.error_description || error.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
-  };
-  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 error = await response.json();
-    throw new Error(`Token refresh failed: ${error.error_description || error.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-googlephotos auth login" first.');
-  }
-  if (Date.now() >= tokens.expiresAt - 5 * 60 * 1000) {
-    const newTokens = await refreshAccessToken();
-    return newTokens.accessToken;
-  }
-  return tokens.accessToken;
-}
-async function getUserInfo(accessToken) {
-  const response = await fetch("https://www.googleapis.com/oauth2/v2/userinfo", {
-    headers: {
-      Authorization: `Bearer ${accessToken}`
-    }
-  });
-  if (!response.ok) {
-    throw new Error("Failed to get user info");
-  }
-  const data = await response.json();
-  return {
-    email: data.email,
-    name: data.name
-  };
-}
-
-// src/api/client.ts
-var PHOTOS_API_BASE = "https://photoslibrary.googleapis.com/v1";
-
-class PhotosClient {
-  buildUrl(path, params) {
-    const url = new URL(`${PHOTOS_API_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 = {} } = options;
-    const accessToken = await getValidAccessToken();
-    const url = this.buildUrl(path, params);
-    const requestHeaders = {
-      Authorization: `Bearer ${accessToken}`,
-      Accept: "application/json",
-      ...headers
-    };
-    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
-      if (typeof body === "string") {
-        if (!requestHeaders["Content-Type"]) {
-          requestHeaders["Content-Type"] = "application/octet-stream";
-        }
-      } else {
-        requestHeaders["Content-Type"] = "application/json";
-      }
-    }
-    const fetchOptions = {
-      method,
-      headers: requestHeaders
-    };
-    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
-      fetchOptions.body = typeof body === "string" ? body : JSON.stringify(body);
-    }
-    const response = await fetch(url, fetchOptions);
-    if (response.status === 204) {
-      return {};
-    }
-    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);
-      const errorStatus = errorData?.error?.status || "UNKNOWN";
-      throw new PhotosApiError(errorMessage, response.status, errorStatus, errorData?.error?.details);
-    }
-    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 uploadBytes(data, mimeType, filename) {
-    const accessToken = await getValidAccessToken();
-    const headers = {
-      Authorization: `Bearer ${accessToken}`,
-      "Content-Type": "application/octet-stream",
-      "X-Goog-Upload-Content-Type": mimeType,
-      "X-Goog-Upload-Protocol": "raw"
-    };
-    if (filename) {
-      headers["X-Goog-Upload-File-Name"] = filename;
-    }
-    const response = await fetch("https://photoslibrary.googleapis.com/v1/uploads", {
-      method: "POST",
-      headers,
-      body: data
-    });
-    if (!response.ok) {
-      const text = await response.text();
-      throw new PhotosApiError(`Upload failed: ${text}`, response.status, "UPLOAD_FAILED");
-    }
-    const uploadToken = await response.text();
-    return uploadToken;
-  }
-}
-
-// src/api/albums.ts
-class AlbumsApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(options = {}) {
-    const params = {
-      pageSize: options.pageSize || 50,
-      pageToken: options.pageToken,
-      excludeNonAppCreatedData: options.excludeNonAppCreatedData
-    };
-    return this.client.get("/albums", params);
-  }
-  async listAll(options = {}) {
-    const albums = [];
-    let pageToken;
-    do {
-      const response = await this.list({ ...options, pageToken });
-      if (response.albums) {
-        albums.push(...response.albums);
-      }
-      pageToken = response.nextPageToken;
-    } while (pageToken);
-    return albums;
-  }
-  async get(albumId) {
-    return this.client.get(`/albums/${albumId}`);
-  }
-  async create(title) {
-    return this.client.post("/albums", {
-      album: { title }
-    });
-  }
-  async addEnrichment(albumId, enrichment, position = "LAST_IN_ALBUM") {
-    return this.client.post(`/albums/${albumId}:addEnrichment`, {
-      newEnrichmentItem: enrichment,
-      albumPosition: { position }
-    });
-  }
-  async share(albumId, options) {
-    const request = {};
-    if (options) {
-      request.sharedAlbumOptions = options;
-    }
-    return this.client.post(`/albums/${albumId}:share`, request);
-  }
-  async unshare(albumId) {
-    await this.client.post(`/albums/${albumId}:unshare`, {});
-  }
-  async listShared(options = {}) {
-    const params = {
-      pageSize: options.pageSize || 50,
-      pageToken: options.pageToken,
-      excludeNonAppCreatedData: options.excludeNonAppCreatedData
-    };
-    return this.client.get("/sharedAlbums", params);
-  }
-  async join(shareToken) {
-    return this.client.post("/sharedAlbums:join", { shareToken });
-  }
-  async leave(shareToken) {
-    await this.client.post("/sharedAlbums:leave", { shareToken });
-  }
-  async addMediaItems(albumId, mediaItemIds) {
-    await this.client.post(`/albums/${albumId}:batchAddMediaItems`, {
-      mediaItemIds
-    });
-  }
-  async removeMediaItems(albumId, mediaItemIds) {
-    await this.client.post(`/albums/${albumId}:batchRemoveMediaItems`, {
-      mediaItemIds
-    });
-  }
-  async updateTitle(albumId, title) {
-    return this.client.patch(`/albums/${albumId}`, { title }, { updateMask: "title" });
-  }
-  async updateCoverPhoto(albumId, coverPhotoMediaItemId) {
-    return this.client.patch(`/albums/${albumId}`, { coverPhotoMediaItemId }, { updateMask: "coverPhotoMediaItemId" });
-  }
-}
-
-// src/api/media.ts
-class MediaApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(options = {}) {
-    const params = {
-      pageSize: options.pageSize || 25,
-      pageToken: options.pageToken
-    };
-    return this.client.get("/mediaItems", params);
-  }
-  async listAll(options = {}, maxItems) {
-    const items = [];
-    let pageToken;
-    do {
-      const response = await this.list({ ...options, pageToken });
-      if (response.mediaItems) {
-        items.push(...response.mediaItems);
-        if (maxItems && items.length >= maxItems) {
-          return items.slice(0, maxItems);
-        }
-      }
-      pageToken = response.nextPageToken;
-    } while (pageToken);
-    return items;
-  }
-  async get(mediaItemId) {
-    return this.client.get(`/mediaItems/${mediaItemId}`);
-  }
-  async batchGet(mediaItemIds) {
-    const params = {};
-    mediaItemIds.forEach((id, index) => {
-      params[`mediaItemIds[${index}]`] = id;
-    });
-    return this.client.get("/mediaItems:batchGet", params);
-  }
-  async search(options = {}) {
-    const body = {
-      pageSize: options.pageSize || 25,
-      pageToken: options.pageToken
-    };
-    if (options.albumId) {
-      body.albumId = options.albumId;
-    }
-    if (options.filters) {
-      body.filters = options.filters;
-    }
-    if (options.orderBy) {
-      body.orderBy = options.orderBy;
-    }
-    return this.client.post("/mediaItems:search", body);
-  }
-  async searchAll(options = {}, maxItems) {
-    const items = [];
-    let pageToken;
-    do {
-      const response = await this.search({ ...options, pageToken });
-      if (response.mediaItems) {
-        items.push(...response.mediaItems);
-        if (maxItems && items.length >= maxItems) {
-          return items.slice(0, maxItems);
-        }
-      }
-      pageToken = response.nextPageToken;
-    } while (pageToken);
-    return items;
-  }
-  async searchByDate(startDate, endDate, options = {}) {
-    const filters = {
-      dateFilter: endDate ? { ranges: [{ startDate, endDate }] } : { dates: [startDate] }
-    };
-    return this.searchAll({ ...options, filters });
-  }
-  async searchByCategory(categories, options = {}) {
-    const filters = {
-      contentFilter: {
-        includedContentCategories: categories
-      }
-    };
-    return this.searchAll({ ...options, filters });
-  }
-  async searchByMediaType(mediaTypes, options = {}) {
-    const filters = {
-      mediaTypeFilter: { mediaTypes }
-    };
-    return this.searchAll({ ...options, filters });
-  }
-  async getFavorites(options = {}) {
-    const filters = {
-      featureFilter: {
-        includedFeatures: ["FAVORITES"]
-      }
-    };
-    return this.searchAll({ ...options, filters });
-  }
-  async getInAlbum(albumId, options = {}) {
-    return this.searchAll({ ...options, albumId });
-  }
-  getDownloadUrl(mediaItem, width, height) {
-    let url = mediaItem.baseUrl;
-    if (mediaItem.mediaMetadata.photo) {
-      if (width && height) {
-        url += `=w${width}-h${height}`;
-      } else if (width) {
-        url += `=w${width}`;
-      } else if (height) {
-        url += `=h${height}`;
-      } else {
-        url += `=d`;
-      }
-    }
-    if (mediaItem.mediaMetadata.video) {
-      url += "=dv";
-    }
-    return url;
-  }
-  async download(mediaItem, width, height) {
-    const url = this.getDownloadUrl(mediaItem, width, height);
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to download media item: ${response.statusText}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    return Buffer.from(arrayBuffer);
-  }
-  async updateDescription(mediaItemId, description) {
-    return this.client.patch(`/mediaItems/${mediaItemId}`, { description }, { updateMask: "description" });
-  }
-}
-
-// src/api/upload.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { basename, extname } from "path";
-var MIME_TYPES = {
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".heic": "image/heic",
-  ".heif": "image/heif",
-  ".bmp": "image/bmp",
-  ".tiff": "image/tiff",
-  ".tif": "image/tiff",
-  ".raw": "image/raw",
-  ".ico": "image/x-icon",
-  ".mp4": "video/mp4",
-  ".mov": "video/quicktime",
-  ".avi": "video/x-msvideo",
-  ".mkv": "video/x-matroska",
-  ".webm": "video/webm",
-  ".m4v": "video/x-m4v",
-  ".3gp": "video/3gpp",
-  ".mpg": "video/mpeg",
-  ".mpeg": "video/mpeg",
-  ".wmv": "video/x-ms-wmv"
-};
-
-class UploadApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  getMimeType(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return MIME_TYPES[ext] || "application/octet-stream";
-  }
-  async uploadFile(filePath) {
-    const data = readFileSync2(filePath);
-    const mimeType = this.getMimeType(filePath);
-    const filename = basename(filePath);
-    return this.client.uploadBytes(data, mimeType, filename);
-  }
-  async uploadBytes(data, mimeType, filename) {
-    return this.client.uploadBytes(data, mimeType, filename);
-  }
-  async createMediaItems(uploadTokens, albumId) {
-    const newMediaItems = uploadTokens.map((item) => ({
-      description: item.description,
-      simpleMediaItem: {
-        fileName: item.filename,
-        uploadToken: item.uploadToken
-      }
-    }));
-    const request = {
-      newMediaItems
-    };
-    if (albumId) {
-      request.albumId = albumId;
-    }
-    return this.client.post("/mediaItems:batchCreate", request);
-  }
-  async uploadAndCreate(filePath, options = {}) {
-    const uploadToken = await this.uploadFile(filePath);
-    const filename = basename(filePath);
-    const response = await this.createMediaItems([{ uploadToken, filename, description: options.description }], options.albumId);
-    const result = response.newMediaItemResults[0];
-    if (result.status?.code && result.status.code !== 0) {
-      throw new Error(`Failed to create media item: ${result.status.message}`);
-    }
-    return result.mediaItem || null;
-  }
-  async uploadMultiple(filePaths, options = {}) {
-    const uploadTokens = [];
-    for (let i = 0;i < filePaths.length; i++) {
-      const filePath = filePaths[i];
-      const filename = basename(filePath);
-      if (options.onProgress) {
-        options.onProgress(i, filePaths.length, filename);
-      }
-      const uploadToken = await this.uploadFile(filePath);
-      uploadTokens.push({ uploadToken, filename });
-    }
-    if (options.onProgress) {
-      options.onProgress(filePaths.length, filePaths.length, "Creating media items...");
-    }
-    return this.createMediaItems(uploadTokens, options.albumId);
-  }
-  async uploadDirectory(dirPath, options = {}) {
-    const { readdirSync: readdirSync2, statSync } = await import("fs");
-    const { join: join2 } = await import("path");
-    const supportedExtensions = options.extensions || Object.keys(MIME_TYPES);
-    const files = [];
-    const collectFiles = (dir) => {
-      const entries = readdirSync2(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join2(dir, entry.name);
-        if (entry.isDirectory() && options.recursive) {
-          collectFiles(fullPath);
-        } else if (entry.isFile()) {
-          const ext = extname(entry.name).toLowerCase();
-          if (supportedExtensions.includes(ext)) {
-            files.push(fullPath);
-          }
-        }
-      }
-    };
-    collectFiles(dirPath);
-    if (files.length === 0) {
-      return { newMediaItemResults: [] };
-    }
-    return this.uploadMultiple(files, {
-      albumId: options.albumId,
-      onProgress: options.onProgress
-    });
-  }
-  getSupportedExtensions() {
-    return Object.keys(MIME_TYPES);
-  }
-  isSupported(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return ext in MIME_TYPES;
-  }
-}
-
-// src/api/bulk.ts
-class BulkApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async preview(options) {
-    const items = await this.fetchMediaItems({
-      albumId: options?.albumId,
-      mediaType: options?.mediaType,
-      favoritesOnly: options?.favoritesOnly,
-      maxResults: options?.maxResults || 50
-    });
-    return { items, total: items.length };
-  }
-  async removeFromAlbums(options) {
-    const { albumIds, mediaItemIds, ...rest } = options;
-    let items;
-    if (mediaItemIds && mediaItemIds.length > 0) {
-      items = mediaItemIds.map((id) => ({
-        id,
-        filename: id,
-        mimeType: "unknown",
-        created: "",
-        productUrl: ""
-      }));
-    } else {
-      items = await this.fetchMediaItems({
-        albumId: albumIds[0],
-        maxResults: rest.maxResults || 100
-      });
-    }
-    return this.executeBatch(items, {
-      dryRun: rest.dryRun || false,
-      concurrency: rest.concurrency || 10,
-      onProgress: rest.onProgress,
-      onError: rest.onError,
-      operation: async (item) => {
-        for (const albumId of albumIds) {
-          await this.client.post(`/albums/${albumId}:batchRemoveMediaItems`, {
-            mediaItemIds: [item.id]
-          });
-        }
-      }
-    });
-  }
-  async addToAlbum(options) {
-    let itemIds = options.mediaItemIds;
-    if (!itemIds || itemIds.length === 0) {
-      const items = await this.fetchMediaItems({
-        albumId: options.albumId,
-        mediaType: options.mediaType,
-        favoritesOnly: options.favoritesOnly,
-        includeArchived: options.includeArchived,
-        maxResults: options.maxResults || 100
-      });
-      itemIds = items.map((i) => i.id);
-    }
-    const summaries = itemIds.map((id) => ({
-      id,
-      filename: id,
-      mimeType: "unknown",
-      created: "",
-      productUrl: ""
-    }));
-    return this.executeBatch(summaries, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (item) => {
-        await this.client.post(`/albums/${options.targetAlbumId}:batchAddMediaItems`, {
-          mediaItemIds: [item.id]
-        });
-      }
-    });
-  }
-  async removeFromAlbum(options) {
-    let itemIds = options.mediaItemIds;
-    if (!itemIds || itemIds.length === 0) {
-      const items = await this.fetchMediaItems({
-        albumId: options.albumId,
-        maxResults: options.maxResults || 100
-      });
-      itemIds = items.map((i) => i.id);
-    }
-    const summaries = itemIds.map((id) => ({
-      id,
-      filename: id,
-      mimeType: "unknown",
-      created: "",
-      productUrl: ""
-    }));
-    return this.executeBatch(summaries, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (item) => {
-        await this.client.post(`/albums/${options.albumId}:batchRemoveMediaItems`, {
-          mediaItemIds: [item.id]
-        });
-      }
-    });
-  }
-  async createAlbums(options) {
-    const { titles, concurrency = 10, dryRun = false, onProgress, onError } = options;
-    const result = {
-      total: titles.length,
-      success: 0,
-      failed: 0,
-      errors: [],
-      createdAlbums: []
-    };
-    if (titles.length === 0)
-      return result;
-    const chunks = this.chunkArray(titles, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (title) => {
-        try {
-          if (dryRun) {
-            result.success++;
-          } else {
-            const album = await this.client.post("/albums", { album: { title } });
-            result.success++;
-            result.createdAlbums.push(album);
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, title);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ title, error: errorMessage });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), title);
-        }
-      }));
-    }
-    return result;
-  }
-  async listFavorites(options) {
-    const items = await this.fetchMediaItems({
-      favoritesOnly: true,
-      maxResults: options?.maxResults || 100
-    });
-    return { items, total: items.length };
-  }
-  async fetchMediaItems(params) {
-    const items = [];
-    let pageToken;
-    const max = params.maxResults || 100;
-    while (items.length < max) {
-      const body = {
-        pageSize: Math.min(100, max - items.length)
-      };
-      if (params.albumId) {
-        body.albumId = params.albumId;
-      }
-      const filters = {};
-      if (params.mediaType) {
-        filters.mediaTypeFilter = { mediaTypes: [params.mediaType] };
-      }
-      if (params.favoritesOnly) {
-        filters.featureFilter = { includedFeatures: ["FAVORITES"] };
-      }
-      if (params.includeArchived) {
-        filters.includeArchivedMedia = true;
-      }
-      if (Object.keys(filters).length > 0) {
-        body.filters = filters;
-      }
-      if (pageToken) {
-        body.pageToken = pageToken;
-      }
-      const response = await this.client.post("/mediaItems:search", body);
-      if (!response.mediaItems || response.mediaItems.length === 0)
-        break;
-      for (const item of response.mediaItems) {
-        items.push({
-          id: item.id,
-          filename: item.filename,
-          mimeType: item.mimeType,
-          created: item.mediaMetadata.creationTime,
-          productUrl: item.productUrl
-        });
-      }
-      pageToken = response.nextPageToken;
-      if (!pageToken)
-        break;
-    }
-    return items;
-  }
-  async executeBatch(items, options) {
-    const { dryRun, concurrency, onProgress, onError, operation } = options;
-    const result = {
-      total: items.length,
-      success: 0,
-      failed: 0,
-      skipped: 0,
-      errors: [],
-      processedItems: []
-    };
-    if (items.length === 0)
-      return result;
-    const chunks = this.chunkArray(items, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (item) => {
-        try {
-          if (dryRun) {
-            result.success++;
-            result.processedItems.push(item);
-          } else {
-            await operation(item);
-            result.success++;
-            result.processedItems.push(item);
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, item);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ mediaId: item.id, error: errorMessage });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), item);
-        }
-      }));
-    }
-    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 GooglePhotos {
-  client;
-  albums;
-  media;
-  upload;
-  bulk;
-  constructor() {
-    this.client = new PhotosClient;
-    this.albums = new AlbumsApi(this.client);
-    this.media = new MediaApi(this.client);
-    this.upload = new UploadApi(this.client);
-    this.bulk = new BulkApi(this.client);
-  }
-  static create() {
-    return new GooglePhotos;
-  }
-  getClient() {
-    return this.client;
-  }
-}
-export {
-  startCallbackServer,
-  setCurrentProfile,
-  saveTokens,
-  refreshAccessToken,
-  loadTokens,
-  listProfiles,
-  isAuthenticated,
-  getValidAccessToken,
-  getUserInfo,
-  getCurrentProfile,
-  getAuthUrl,
-  deleteProfile,
-  createProfile,
-  clearConfig,
-  UploadApi,
-  PhotosClient,
-  PhotosApiError,
-  MediaApi,
-  GooglePhotos,
-  AlbumsApi
-};