@hasna/connectors 1.3.31 → 1.3.33

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

@@ -1,913 +0,0 @@
-// @bun
-// src/types/index.ts
-class GoogleContactsApiError extends Error {
-  statusCode;
-  errors;
-  constructor(message, statusCode, errors) {
-    super(message);
-    this.name = "GoogleContactsApiError";
-    this.statusCode = statusCode;
-    this.errors = errors;
-  }
-}
-
-class AuthError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AuthError";
-  }
-}
-
-class RateLimitError extends Error {
-  constructor(message = "Rate limited by Google People API") {
-    super(message);
-    this.name = "RateLimitError";
-  }
-}
-
-// src/utils/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var CONNECTOR_NAME = "connect-googlecontacts";
-var DEFAULT_PROFILE = "default";
-var profileOverride;
-var CONFIG_DIR = join(homedir(), ".hasna", "connectors", CONNECTOR_NAME);
-var PROFILES_DIR = join(CONFIG_DIR, "profiles");
-var CURRENT_PROFILE_FILE = join(CONFIG_DIR, "current_profile");
-function ensureConfigDir() {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  if (!existsSync(PROFILES_DIR)) {
-    mkdirSync(PROFILES_DIR, { recursive: true });
-  }
-}
-function getProfilePath(profile) {
-  return join(PROFILES_DIR, `${profile}.json`);
-}
-function getCurrentProfile() {
-  if (profileOverride) {
-    return profileOverride;
-  }
-  ensureConfigDir();
-  if (existsSync(CURRENT_PROFILE_FILE)) {
-    try {
-      const profile = readFileSync(CURRENT_PROFILE_FILE, "utf-8").trim();
-      if (profile && profileExists(profile)) {
-        return profile;
-      }
-    } catch {}
-  }
-  return DEFAULT_PROFILE;
-}
-function setCurrentProfile(profile) {
-  ensureConfigDir();
-  if (!profileExists(profile) && profile !== DEFAULT_PROFILE) {
-    throw new Error(`Profile "${profile}" does not exist`);
-  }
-  writeFileSync(CURRENT_PROFILE_FILE, profile);
-}
-function profileExists(profile) {
-  return existsSync(getProfilePath(profile));
-}
-function listProfiles() {
-  ensureConfigDir();
-  if (!existsSync(PROFILES_DIR)) {
-    return [];
-  }
-  return readdirSync(PROFILES_DIR).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", "")).sort();
-}
-function createProfile(profile, config = {}) {
-  ensureConfigDir();
-  if (profileExists(profile)) {
-    return false;
-  }
-  if (!/^[a-zA-Z0-9_-]+$/.test(profile)) {
-    throw new Error("Profile name can only contain letters, numbers, hyphens, and underscores");
-  }
-  writeFileSync(getProfilePath(profile), JSON.stringify(config, null, 2));
-  return true;
-}
-function deleteProfile(profile) {
-  if (profile === DEFAULT_PROFILE) {
-    return false;
-  }
-  if (!profileExists(profile)) {
-    return false;
-  }
-  if (getCurrentProfile() === profile) {
-    setCurrentProfile(DEFAULT_PROFILE);
-  }
-  rmSync(getProfilePath(profile));
-  return true;
-}
-function loadProfile(profile) {
-  ensureConfigDir();
-  const profileName = profile || getCurrentProfile();
-  let config = {};
-  const flatPath = getProfilePath(profileName);
-  if (existsSync(flatPath)) {
-    try {
-      config = JSON.parse(readFileSync(flatPath, "utf-8"));
-    } catch {}
-  }
-  const dirConfigPath = join(PROFILES_DIR, profileName, "config.json");
-  if (existsSync(dirConfigPath)) {
-    try {
-      const dirConfig = JSON.parse(readFileSync(dirConfigPath, "utf-8"));
-      config = { ...config, ...dirConfig };
-    } catch {}
-  }
-  const tokensPath = join(PROFILES_DIR, profileName, "tokens.json");
-  if (existsSync(tokensPath)) {
-    try {
-      const tokens = JSON.parse(readFileSync(tokensPath, "utf-8"));
-      if (tokens.accessToken && !config.accessToken)
-        config.accessToken = tokens.accessToken;
-      if (tokens.refreshToken && !config.refreshToken)
-        config.refreshToken = tokens.refreshToken;
-      if (tokens.expiresAt && !config.tokenExpiresAt)
-        config.tokenExpiresAt = tokens.expiresAt;
-    } catch {}
-  }
-  return config;
-}
-function saveProfile(config, profile) {
-  ensureConfigDir();
-  const profileName = profile || getCurrentProfile();
-  writeFileSync(getProfilePath(profileName), JSON.stringify(config, null, 2));
-}
-var CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
-function loadCredentials() {
-  ensureConfigDir();
-  if (!existsSync(CREDENTIALS_FILE)) {
-    const profiles = listProfiles();
-    for (const prof of profiles) {
-      const profileConfig = loadProfile(prof);
-      if (profileConfig.clientId && profileConfig.clientSecret) {
-        const creds = {
-          clientId: profileConfig.clientId,
-          clientSecret: profileConfig.clientSecret
-        };
-        writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), { mode: 384 });
-        return creds;
-      }
-    }
-    return {};
-  }
-  try {
-    return JSON.parse(readFileSync(CREDENTIALS_FILE, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function saveCredentials(creds) {
-  ensureConfigDir();
-  writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), { mode: 384 });
-}
-function getClientId() {
-  return process.env.GOOGLE_CONTACTS_CLIENT_ID || loadCredentials().clientId;
-}
-function setClientId(clientId) {
-  const creds = loadCredentials();
-  creds.clientId = clientId;
-  saveCredentials(creds);
-}
-function getClientSecret() {
-  return process.env.GOOGLE_CONTACTS_CLIENT_SECRET || loadCredentials().clientSecret;
-}
-function setClientSecret(clientSecret) {
-  const creds = loadCredentials();
-  creds.clientSecret = clientSecret;
-  saveCredentials(creds);
-}
-function getAccessToken() {
-  return process.env.GOOGLE_CONTACTS_ACCESS_TOKEN || loadProfile().accessToken;
-}
-function setAccessToken(accessToken) {
-  const config = loadProfile();
-  config.accessToken = accessToken;
-  saveProfile(config);
-}
-function getRefreshToken() {
-  return process.env.GOOGLE_CONTACTS_REFRESH_TOKEN || loadProfile().refreshToken;
-}
-function setRefreshToken(refreshToken) {
-  const config = loadProfile();
-  config.refreshToken = refreshToken;
-  saveProfile(config);
-}
-function getTokenExpiresAt() {
-  return loadProfile().tokenExpiresAt;
-}
-function getRedirectUri() {
-  return process.env.GOOGLE_CONTACTS_REDIRECT_URI || loadProfile().redirectUri || "urn:ietf:wg:oauth:2.0:oob";
-}
-function setRedirectUri(redirectUri) {
-  const config = loadProfile();
-  config.redirectUri = redirectUri;
-  saveProfile(config);
-}
-function saveTokens(tokens) {
-  const config = loadProfile();
-  config.accessToken = tokens.accessToken;
-  if (tokens.refreshToken) {
-    config.refreshToken = tokens.refreshToken;
-  }
-  if (tokens.expiresIn) {
-    config.tokenExpiresAt = Date.now() + tokens.expiresIn * 1000;
-  }
-  ensureConfigDir();
-  const profileName = getCurrentProfile();
-  const profilePath = getProfilePath(profileName);
-  writeFileSync(profilePath, JSON.stringify(config, null, 2), { mode: 384 });
-}
-function clearConfig() {
-  saveProfile({});
-}
-function hasOAuthCredentials() {
-  const clientId = getClientId();
-  const clientSecret = getClientSecret();
-  return Boolean(clientId && clientSecret);
-}
-function hasAccessTokens() {
-  const accessToken = getAccessToken();
-  return Boolean(accessToken);
-}
-function isTokenExpired() {
-  const expiresAt = getTokenExpiresAt();
-  if (!expiresAt)
-    return true;
-  return Date.now() >= expiresAt - 60000;
-}
-
-// src/api/client.ts
-var DEFAULT_BASE_URL = "https://people.googleapis.com";
-var OAUTH_TOKEN_URL = "https://oauth2.googleapis.com/token";
-var OAUTH_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
-var DEFAULT_SCOPES = "https://www.googleapis.com/auth/contacts";
-var HTTP_UNAUTHORIZED = 401;
-var HTTP_TOO_MANY_REQUESTS = 429;
-
-class GoogleContactsClient {
-  clientId;
-  clientSecret;
-  baseUrl;
-  redirectUri;
-  tokens;
-  constructor(config) {
-    if (!config.clientId) {
-      throw new Error("Client ID is required");
-    }
-    if (!config.clientSecret) {
-      throw new Error("Client Secret is required");
-    }
-    this.clientId = config.clientId;
-    this.clientSecret = config.clientSecret;
-    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
-    this.redirectUri = config.redirectUri || "urn:ietf:wg:oauth:2.0:oob";
-    this.tokens = {
-      accessToken: config.accessToken || "",
-      refreshToken: config.refreshToken,
-      expiresAt: undefined
-    };
-  }
-  getAuthorizationUrl(scopes = DEFAULT_SCOPES) {
-    const params = new URLSearchParams({
-      client_id: this.clientId,
-      redirect_uri: this.redirectUri,
-      response_type: "code",
-      scope: scopes,
-      access_type: "offline",
-      prompt: "consent"
-    });
-    return `${OAUTH_AUTH_URL}?${params.toString()}`;
-  }
-  async exchangeCode(code) {
-    const response = await fetch(OAUTH_TOKEN_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
-        client_id: this.clientId,
-        client_secret: this.clientSecret,
-        code,
-        grant_type: "authorization_code",
-        redirect_uri: this.redirectUri
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new AuthError(`Token exchange failed: ${errorText}`);
-    }
-    const data = await response.json();
-    this.tokens = this.parseTokenResponse(data);
-    return this.tokens;
-  }
-  async refreshAccessToken() {
-    if (!this.tokens.refreshToken) {
-      throw new AuthError("Missing refresh token; cannot refresh access token.");
-    }
-    const response = await fetch(OAUTH_TOKEN_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
-        client_id: this.clientId,
-        client_secret: this.clientSecret,
-        grant_type: "refresh_token",
-        refresh_token: this.tokens.refreshToken
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new AuthError(`Token refresh failed: ${errorText}`);
-    }
-    const data = await response.json();
-    const newTokens = this.parseTokenResponse(data);
-    if (!newTokens.refreshToken) {
-      newTokens.refreshToken = this.tokens.refreshToken;
-    }
-    this.tokens = newTokens;
-    saveTokens({
-      accessToken: newTokens.accessToken,
-      refreshToken: newTokens.refreshToken,
-      expiresIn: newTokens.expiresIn
-    });
-    return this.tokens;
-  }
-  setTokens(tokens) {
-    if (tokens.accessToken) {
-      this.tokens.accessToken = tokens.accessToken;
-    }
-    if (tokens.refreshToken) {
-      this.tokens.refreshToken = tokens.refreshToken;
-    }
-    if (tokens.expiresAt) {
-      this.tokens.expiresAt = tokens.expiresAt;
-    }
-  }
-  getTokens() {
-    return { ...this.tokens };
-  }
-  isTokenExpired() {
-    if (!this.tokens.expiresAt)
-      return false;
-    return Date.now() >= this.tokens.expiresAt - 60000;
-  }
-  async ensureValidToken() {
-    if (!this.tokens.accessToken) {
-      throw new AuthError("Missing access token. Run OAuth flow first.");
-    }
-    if (this.isTokenExpired() && this.tokens.refreshToken) {
-      await this.refreshAccessToken();
-    }
-  }
-  parseTokenResponse(data) {
-    return {
-      accessToken: data.access_token,
-      refreshToken: data.refresh_token,
-      expiresIn: data.expires_in,
-      expiresAt: data.expires_in ? Date.now() + data.expires_in * 1000 : undefined,
-      tokenType: data.token_type,
-      scope: data.scope
-    };
-  }
-  buildUrl(path, params) {
-    const url = new URL(`${this.baseUrl}${path}`);
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null && value !== "") {
-          url.searchParams.append(key, String(value));
-        }
-      });
-    }
-    return url.toString();
-  }
-  getAuthHeaders() {
-    if (!this.tokens.accessToken) {
-      throw new AuthError("Missing access token. Run OAuth flow first.");
-    }
-    return {
-      Authorization: `Bearer ${this.tokens.accessToken}`
-    };
-  }
-  async request(path, options = {}) {
-    const { method = "GET", params, body, headers = {} } = options;
-    await this.ensureValidToken();
-    const url = this.buildUrl(path, params);
-    const requestHeaders = {
-      ...this.getAuthHeaders(),
-      Accept: "application/json",
-      ...headers
-    };
-    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
-      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);
-    }
-    let response = await fetch(url, fetchOptions);
-    if (response.status === HTTP_UNAUTHORIZED && this.tokens.refreshToken) {
-      await this.refreshAccessToken();
-      requestHeaders["Authorization"] = `Bearer ${this.tokens.accessToken}`;
-      response = await fetch(url, {
-        ...fetchOptions,
-        headers: requestHeaders
-      });
-    }
-    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) {
-      if (response.status === HTTP_TOO_MANY_REQUESTS) {
-        throw new RateLimitError;
-      }
-      const errorMessage = typeof data === "object" && data !== null ? JSON.stringify(data) : String(data || response.statusText);
-      throw new GoogleContactsApiError(errorMessage, response.status);
-    }
-    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 });
-  }
-  getClientIdPreview() {
-    if (this.clientId.length > 10) {
-      return `${this.clientId.substring(0, 10)}...${this.clientId.substring(this.clientId.length - 4)}`;
-    }
-    return "***";
-  }
-}
-
-// src/api/contacts.ts
-var DEFAULT_PERSON_FIELDS = [
-  "names",
-  "emailAddresses",
-  "phoneNumbers",
-  "organizations",
-  "addresses",
-  "memberships",
-  "photos"
-];
-
-class ContactsApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(options = {}) {
-    const {
-      pageSize = 100,
-      pageToken,
-      personFields = DEFAULT_PERSON_FIELDS,
-      sortOrder = "LAST_MODIFIED_DESCENDING"
-    } = options;
-    return this.client.get("/v1/people/me/connections", {
-      pageSize,
-      pageToken,
-      personFields: personFields.join(","),
-      sortOrder
-    });
-  }
-  async* listAll(options = {}) {
-    let pageToken;
-    do {
-      const response = await this.list({ ...options, pageToken });
-      const connections = response.connections || [];
-      for (const contact of connections) {
-        yield contact;
-      }
-      pageToken = response.nextPageToken;
-    } while (pageToken);
-  }
-  async get(resourceName, personFields = DEFAULT_PERSON_FIELDS) {
-    const name = resourceName.startsWith("people/") ? resourceName : `people/${resourceName}`;
-    return this.client.get(`/v1/${name}`, {
-      personFields: personFields.join(",")
-    });
-  }
-  async create(params) {
-    const body = this.buildContactBody(params);
-    return this.client.post("/v1/people:createContact", body);
-  }
-  async update(resourceName, params, updatePersonFields) {
-    const name = resourceName.startsWith("people/") ? resourceName : `people/${resourceName}`;
-    const fieldsToUpdate = updatePersonFields || this.getFieldsFromParams(params);
-    const body = this.buildContactBody(params);
-    return this.client.patch(`/v1/${name}:updateContact`, body, {
-      updatePersonFields: fieldsToUpdate.join(",")
-    });
-  }
-  async delete(resourceName) {
-    const name = resourceName.startsWith("people/") ? resourceName : `people/${resourceName}`;
-    await this.client.delete(`/v1/${name}:deleteContact`);
-  }
-  async search(options) {
-    const { query, pageSize = 30, readMask = DEFAULT_PERSON_FIELDS } = options;
-    return this.client.get("/v1/people:searchContacts", {
-      query,
-      pageSize,
-      readMask: readMask.join(",")
-    });
-  }
-  async listGroups(pageSize = 100, pageToken) {
-    return this.client.get("/v1/contactGroups", {
-      pageSize,
-      pageToken
-    });
-  }
-  static normalize(contact) {
-    const names = contact.names || [];
-    const primaryName = names[0] || {};
-    const emails = (contact.emailAddresses || []).map((e) => e.value).filter(Boolean);
-    const phones = (contact.phoneNumbers || []).map((p) => p.value).filter(Boolean);
-    const orgs = contact.organizations || [];
-    const org = orgs[0] || {};
-    const photos = contact.photos || [];
-    const memberships = contact.memberships || [];
-    return {
-      resourceName: contact.resourceName,
-      etag: contact.etag,
-      names: {
-        displayName: primaryName.displayName,
-        givenName: primaryName.givenName,
-        familyName: primaryName.familyName,
-        phoneticFullName: primaryName.phoneticFullName
-      },
-      emails,
-      phones,
-      organization: {
-        name: org.name,
-        title: org.title,
-        department: org.department
-      },
-      addresses: (contact.addresses || []).map((a) => a.formattedValue).filter((v) => Boolean(v)),
-      memberships: memberships.map((m) => m.contactGroupMembership?.contactGroupResourceName).filter((v) => Boolean(v)),
-      photoUrl: photos[0]?.url
-    };
-  }
-  buildContactBody(params) {
-    const body = {};
-    if (params.givenName || params.familyName || params.displayName) {
-      body.names = [{
-        givenName: params.givenName,
-        familyName: params.familyName,
-        displayName: params.displayName
-      }];
-    }
-    if (params.emails && params.emails.length > 0) {
-      body.emailAddresses = params.emails.map((email) => ({
-        value: email
-      }));
-    }
-    if (params.phones && params.phones.length > 0) {
-      body.phoneNumbers = params.phones.map((phone) => ({
-        value: phone
-      }));
-    }
-    if (params.organization) {
-      body.organizations = [{
-        name: params.organization.name,
-        title: params.organization.title
-      }];
-    }
-    return body;
-  }
-  getFieldsFromParams(params) {
-    const fields = [];
-    if (params.givenName || params.familyName || params.displayName) {
-      fields.push("names");
-    }
-    if (params.emails) {
-      fields.push("emailAddresses");
-    }
-    if (params.phones) {
-      fields.push("phoneNumbers");
-    }
-    if (params.organization) {
-      fields.push("organizations");
-    }
-    return fields;
-  }
-}
-
-// src/api/bulk.ts
-class BulkApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async preview(options) {
-    const contacts = await this.fetchContacts({
-      query: options?.query,
-      maxResults: options?.maxResults || 50
-    });
-    return { contacts, total: contacts.length, query: options?.query };
-  }
-  async delete(options) {
-    const contacts = await this.fetchContacts({
-      query: options.query,
-      maxResults: options.maxResults || 100
-    });
-    return this.executeBatch(contacts, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (contact) => {
-        await this.client.delete(`/v1/${contact.resourceName}:deleteContact`);
-      }
-    });
-  }
-  async update(options) {
-    const contacts = await this.fetchContacts({
-      query: options.query,
-      maxResults: options.maxResults || 100
-    });
-    return this.executeBatch(contacts, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (contact) => {
-        const updateFields = [];
-        const body = {};
-        if (options.updates.givenName || options.updates.familyName) {
-          body.names = [{
-            givenName: options.updates.givenName,
-            familyName: options.updates.familyName
-          }];
-          updateFields.push("names");
-        }
-        if (options.updates.organization) {
-          body.organizations = [{
-            name: options.updates.organization.name,
-            title: options.updates.organization.title
-          }];
-          updateFields.push("organizations");
-        }
-        await this.client.patch(`/v1/${contact.resourceName}:updateContact`, body, {
-          updatePersonFields: updateFields.join(",")
-        });
-      }
-    });
-  }
-  async addToGroup(groupResourceName, options) {
-    let contactNames = options.contactNames;
-    if (!contactNames || contactNames.length === 0) {
-      const contacts = await this.fetchContacts({
-        query: options.query,
-        maxResults: options.maxResults || 100
-      });
-      contactNames = contacts.map((c) => c.resourceName);
-    }
-    const summaries = contactNames.map((name) => ({
-      resourceName: name,
-      displayName: name,
-      emails: []
-    }));
-    return this.executeBatch(summaries, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (contact) => {
-        await this.client.post(`/v1/${groupResourceName}:modifyMembers`, {
-          membersToAdd: [{ contactGroupMembership: { contactGroupResourceName: groupResourceName } }],
-          resourceNames: [contact.resourceName]
-        });
-      }
-    });
-  }
-  async removeFromGroup(groupResourceName, options) {
-    let contactNames = options.contactNames;
-    if (!contactNames || contactNames.length === 0) {
-      const contacts = await this.fetchContacts({
-        query: options.query,
-        maxResults: options.maxResults || 100
-      });
-      contactNames = contacts.map((c) => c.resourceName);
-    }
-    const summaries = contactNames.map((name) => ({
-      resourceName: name,
-      displayName: name,
-      emails: []
-    }));
-    return this.executeBatch(summaries, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (contact) => {
-        await this.client.post(`/v1/${groupResourceName}:modifyMembers`, {
-          membersToDelete: [{ contactId: contact.resourceName.split("/").pop() }]
-        });
-      }
-    });
-  }
-  async fetchContacts(params) {
-    const contacts = [];
-    let pageToken;
-    const max = params.maxResults || 100;
-    const personFields = "names,emailAddresses,organizations,memberships";
-    while (contacts.length < max) {
-      let response;
-      if (params.query) {
-        const searchResult = await this.client.get("/v1/people:searchContacts", {
-          query: params.query,
-          pageSize: Math.min(100, max - contacts.length),
-          pageToken,
-          readMask: personFields
-        });
-        if (!searchResult.results || searchResult.results.length === 0)
-          break;
-        for (const r of searchResult.results) {
-          const c = r.person;
-          contacts.push(this.toSummary(c));
-        }
-        pageToken = searchResult.nextPageToken;
-      } else {
-        response = await this.client.get("/v1/people/me/connections", {
-          pageSize: Math.min(100, max - contacts.length),
-          pageToken,
-          personFields,
-          sortOrder: "LAST_MODIFIED_DESCENDING"
-        });
-        if (!response.connections || response.connections.length === 0)
-          break;
-        for (const c of response.connections) {
-          contacts.push(this.toSummary(c));
-        }
-        pageToken = response.nextPageToken;
-      }
-      if (!pageToken)
-        break;
-    }
-    return contacts;
-  }
-  toSummary(contact) {
-    return {
-      resourceName: contact.resourceName,
-      displayName: contact.names?.[0]?.displayName || "(unnamed)",
-      emails: (contact.emailAddresses || []).map((e) => e.value).filter(Boolean)
-    };
-  }
-  async executeBatch(contacts, options) {
-    const { dryRun, concurrency, onProgress, onError, operation } = options;
-    const result = {
-      total: contacts.length,
-      success: 0,
-      failed: 0,
-      skipped: 0,
-      errors: [],
-      processedContacts: []
-    };
-    if (contacts.length === 0)
-      return result;
-    const chunks = this.chunkArray(contacts, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (contact) => {
-        try {
-          if (dryRun) {
-            result.success++;
-            result.processedContacts.push(contact);
-          } else {
-            await operation(contact);
-            result.success++;
-            result.processedContacts.push(contact);
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, contact);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ contactName: contact.resourceName, error: errorMessage });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), contact);
-        }
-      }));
-    }
-    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 GoogleContacts {
-  client;
-  contacts;
-  bulk;
-  constructor(config) {
-    this.client = new GoogleContactsClient(config);
-    this.contacts = new ContactsApi(this.client);
-    this.bulk = new BulkApi(this.client);
-  }
-  static fromEnv() {
-    const clientId = process.env.GOOGLE_CONTACTS_CLIENT_ID;
-    const clientSecret = process.env.GOOGLE_CONTACTS_CLIENT_SECRET;
-    const accessToken = process.env.GOOGLE_CONTACTS_ACCESS_TOKEN;
-    const refreshToken = process.env.GOOGLE_CONTACTS_REFRESH_TOKEN;
-    if (!clientId) {
-      throw new Error("GOOGLE_CONTACTS_CLIENT_ID environment variable is required");
-    }
-    if (!clientSecret) {
-      throw new Error("GOOGLE_CONTACTS_CLIENT_SECRET environment variable is required");
-    }
-    return new GoogleContacts({
-      clientId,
-      clientSecret,
-      accessToken,
-      refreshToken
-    });
-  }
-  getAuthorizationUrl(scopes) {
-    return this.client.getAuthorizationUrl(scopes);
-  }
-  async exchangeCode(code) {
-    return this.client.exchangeCode(code);
-  }
-  async refreshAccessToken() {
-    return this.client.refreshAccessToken();
-  }
-  setTokens(tokens) {
-    this.client.setTokens(tokens);
-  }
-  getTokens() {
-    return this.client.getTokens();
-  }
-  getClientIdPreview() {
-    return this.client.getClientIdPreview();
-  }
-  getClient() {
-    return this.client;
-  }
-}
-export {
-  setRefreshToken,
-  setRedirectUri,
-  setCurrentProfile,
-  setClientSecret,
-  setClientId,
-  setAccessToken,
-  saveTokens,
-  saveProfile,
-  loadProfile,
-  listProfiles,
-  isTokenExpired,
-  hasOAuthCredentials,
-  hasAccessTokens,
-  getRefreshToken,
-  getRedirectUri,
-  getCurrentProfile,
-  getClientSecret,
-  getClientId,
-  getAccessToken,
-  deleteProfile,
-  createProfile,
-  clearConfig,
-  RateLimitError,
-  GoogleContactsClient,
-  GoogleContactsApiError,
-  GoogleContacts,
-  ContactsApi,
-  AuthError
-};