@hasna/connectors 1.3.31 → 1.3.33

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

@@ -1,754 +0,0 @@
-// @bun
-// src/types/index.ts
-class GoogleDocsApiError extends Error {
-  statusCode;
-  errors;
-  constructor(message, statusCode, errors) {
-    super(message);
-    this.name = "GoogleDocsApiError";
-    this.statusCode = statusCode;
-    this.errors = errors;
-  }
-}
-
-// 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-googledocs";
-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();
-  const profilePath = getProfilePath(profileName);
-  if (!existsSync(profilePath)) {
-    return {};
-  }
-  try {
-    return JSON.parse(readFileSync(profilePath, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function saveProfile(config, profile) {
-  ensureConfigDir();
-  const profileName = profile || getCurrentProfile();
-  writeFileSync(getProfilePath(profileName), JSON.stringify(config, null, 2));
-}
-function getApiKey() {
-  return process.env.GOOGLE_API_KEY || loadProfile().apiKey;
-}
-function setApiKey(apiKey) {
-  const config = loadProfile();
-  config.apiKey = apiKey;
-  saveProfile(config);
-}
-function getAccessToken() {
-  return process.env.GOOGLE_ACCESS_TOKEN || loadProfile().accessToken;
-}
-function setAccessToken(accessToken) {
-  const config = loadProfile();
-  config.accessToken = accessToken;
-  saveProfile(config);
-}
-var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
-async function refreshAccessToken() {
-  const profile = loadProfile();
-  const clientId = process.env.GOOGLE_CLIENT_ID || profile.clientId;
-  const clientSecret = process.env.GOOGLE_CLIENT_SECRET || profile.clientSecret;
-  const refreshToken = process.env.GOOGLE_REFRESH_TOKEN || profile.refreshToken;
-  if (!clientId || !clientSecret) {
-    throw new Error("OAuth client credentials not configured. Set clientId/clientSecret in profile or GOOGLE_CLIENT_ID/GOOGLE_CLIENT_SECRET env vars.");
-  }
-  if (!refreshToken) {
-    throw new Error("No refresh token available. Please re-authenticate.");
-  }
-  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: 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 updatedProfile = {
-    ...profile,
-    accessToken: data.access_token,
-    refreshToken,
-    expiresAt: Date.now() + data.expires_in * 1000
-  };
-  saveProfile(updatedProfile);
-  return updatedProfile;
-}
-async function getValidAccessToken() {
-  if (process.env.GOOGLE_ACCESS_TOKEN) {
-    return process.env.GOOGLE_ACCESS_TOKEN;
-  }
-  const profile = loadProfile();
-  if (!profile.accessToken) {
-    throw new Error('Not authenticated. Run "connect-googledocs config set-token <token>" or set GOOGLE_ACCESS_TOKEN.');
-  }
-  if (profile.expiresAt && profile.refreshToken) {
-    if (Date.now() >= profile.expiresAt - 5 * 60 * 1000) {
-      const updated = await refreshAccessToken();
-      return updated.accessToken;
-    }
-  }
-  return profile.accessToken;
-}
-function clearConfig() {
-  saveProfile({});
-}
-
-// src/api/client.ts
-var DEFAULT_BASE_URL = "https://docs.googleapis.com/v1";
-
-class GoogleDocsClient {
-  apiKey;
-  accessToken;
-  baseUrl;
-  useAutoRefresh;
-  constructor(config) {
-    if (!config.apiKey && !config.accessToken) {
-      throw new Error("Either API key or access token is required");
-    }
-    this.apiKey = config.apiKey;
-    this.accessToken = config.accessToken;
-    this.useAutoRefresh = config.autoRefresh !== false;
-    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
-  }
-  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));
-        }
-      });
-    }
-    if (this.apiKey && !this.accessToken) {
-      url.searchParams.append("key", this.apiKey);
-    }
-    return url.toString();
-  }
-  async request(path, options = {}) {
-    const { method = "GET", params, body, headers = {} } = options;
-    if (this.accessToken && this.useAutoRefresh) {
-      try {
-        this.accessToken = await getValidAccessToken();
-      } catch {}
-    }
-    const url = this.buildUrl(path, params);
-    const requestHeaders = {
-      Accept: "application/json",
-      ...headers
-    };
-    if (this.accessToken) {
-      requestHeaders["Authorization"] = `Bearer ${this.accessToken}`;
-    }
-    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);
-    }
-    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 errorMessage = typeof data === "object" && data !== null ? JSON.stringify(data) : String(data || response.statusText);
-      throw new GoogleDocsApiError(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 });
-  }
-  getCredentialsPreview() {
-    if (this.accessToken) {
-      if (this.accessToken.length > 10) {
-        return `Bearer ${this.accessToken.substring(0, 6)}...${this.accessToken.substring(this.accessToken.length - 4)}`;
-      }
-      return "Bearer ***";
-    }
-    if (this.apiKey) {
-      if (this.apiKey.length > 10) {
-        return `API Key ${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
-      }
-      return "API Key ***";
-    }
-    return "No credentials";
-  }
-  hasWriteAccess() {
-    return !!this.accessToken;
-  }
-}
-
-// src/api/documents.ts
-class DocumentsApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async get(documentId, suggestionsViewMode) {
-    const params = {};
-    if (suggestionsViewMode) {
-      params.suggestionsViewMode = suggestionsViewMode;
-    }
-    return this.client.get(`/documents/${documentId}`, params);
-  }
-  async create(title) {
-    return this.client.post("/documents", { title });
-  }
-  async batchUpdate(documentId, requests, writeControl) {
-    const body = { requests };
-    if (writeControl) {
-      body.writeControl = writeControl;
-    }
-    return this.client.post(`/documents/${documentId}:batchUpdate`, body);
-  }
-}
-
-// src/api/content.ts
-class ContentApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async insertText(documentId, text, index) {
-    const requests = [
-      {
-        insertText: {
-          text,
-          location: { index }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async appendText(documentId, text) {
-    const requests = [
-      {
-        insertText: {
-          text,
-          endOfSegmentLocation: {}
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async deleteRange(documentId, startIndex, endIndex) {
-    const requests = [
-      {
-        deleteContentRange: {
-          range: { startIndex, endIndex }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async replaceText(documentId, find, replace, matchCase = false) {
-    const requests = [
-      {
-        replaceAllText: {
-          containsText: {
-            text: find,
-            matchCase
-          },
-          replaceText: replace
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async insertImage(documentId, uri, index, objectSize) {
-    const requests = [
-      {
-        insertInlineImage: {
-          uri,
-          location: { index },
-          ...objectSize && { objectSize }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async appendImage(documentId, uri, objectSize) {
-    const requests = [
-      {
-        insertInlineImage: {
-          uri,
-          endOfSegmentLocation: {},
-          ...objectSize && { objectSize }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async insertPageBreak(documentId, index) {
-    const requests = [
-      {
-        insertPageBreak: {
-          location: { index }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async insertTable(documentId, rows, columns, index) {
-    const requests = [
-      {
-        insertTable: {
-          rows,
-          columns,
-          location: { index }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async createNamedRange(documentId, name, startIndex, endIndex) {
-    const requests = [
-      {
-        createNamedRange: {
-          name,
-          range: { startIndex, endIndex }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async deleteNamedRange(documentId, name) {
-    const requests = [
-      {
-        deleteNamedRange: { name }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async batchUpdate(documentId, requests) {
-    return this.client.post(`/documents/${documentId}:batchUpdate`, { requests });
-  }
-}
-
-// src/api/styles.ts
-class StylesApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async updateTextStyle(documentId, range, style, fields) {
-    const requests = [
-      {
-        updateTextStyle: {
-          range,
-          textStyle: style,
-          fields
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async updateParagraphStyle(documentId, range, style, fields) {
-    const requests = [
-      {
-        updateParagraphStyle: {
-          range,
-          paragraphStyle: style,
-          fields
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async setBold(documentId, startIndex, endIndex) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { bold: true }, "bold");
-  }
-  async setItalic(documentId, startIndex, endIndex) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { italic: true }, "italic");
-  }
-  async setUnderline(documentId, startIndex, endIndex) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { underline: true }, "underline");
-  }
-  async setStrikethrough(documentId, startIndex, endIndex) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { strikethrough: true }, "strikethrough");
-  }
-  async setFontSize(documentId, startIndex, endIndex, sizePt) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { fontSize: { magnitude: sizePt, unit: "PT" } }, "fontSize");
-  }
-  async setFontFamily(documentId, startIndex, endIndex, fontFamily) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { weightedFontFamily: { fontFamily } }, "weightedFontFamily");
-  }
-  async setTextColor(documentId, startIndex, endIndex, red, green, blue) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, {
-      foregroundColor: {
-        color: { rgbColor: { red, green, blue } }
-      }
-    }, "foregroundColor");
-  }
-  async setHighlightColor(documentId, startIndex, endIndex, red, green, blue) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, {
-      backgroundColor: {
-        color: { rgbColor: { red, green, blue } }
-      }
-    }, "backgroundColor");
-  }
-  async setLink(documentId, startIndex, endIndex, url) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { link: { url } }, "link");
-  }
-  async setAlignment(documentId, startIndex, endIndex, alignment) {
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, { alignment }, "alignment");
-  }
-  async setLineSpacing(documentId, startIndex, endIndex, lineSpacing) {
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, { lineSpacing }, "lineSpacing");
-  }
-  async setNamedStyle(documentId, startIndex, endIndex, namedStyleType) {
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, { namedStyleType }, "namedStyleType");
-  }
-  async setSpacing(documentId, startIndex, endIndex, spaceAbovePt, spaceBelowPt) {
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, {
-      spaceAbove: { magnitude: spaceAbovePt, unit: "PT" },
-      spaceBelow: { magnitude: spaceBelowPt, unit: "PT" }
-    }, "spaceAbove,spaceBelow");
-  }
-  async setIndentation(documentId, startIndex, endIndex, firstLinePt, startPt, endPt) {
-    const style = {};
-    const fields = [];
-    if (firstLinePt !== undefined) {
-      style.indentFirstLine = { magnitude: firstLinePt, unit: "PT" };
-      fields.push("indentFirstLine");
-    }
-    if (startPt !== undefined) {
-      style.indentStart = { magnitude: startPt, unit: "PT" };
-      fields.push("indentStart");
-    }
-    if (endPt !== undefined) {
-      style.indentEnd = { magnitude: endPt, unit: "PT" };
-      fields.push("indentEnd");
-    }
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, style, fields.join(","));
-  }
-  async batchUpdate(documentId, requests) {
-    return this.client.post(`/documents/${documentId}:batchUpdate`, { requests });
-  }
-}
-
-// src/api/bulk.ts
-class BulkApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async createDocuments(options) {
-    const { titles, concurrency = 10, dryRun = false, onProgress, onError } = options;
-    const result = {
-      total: titles.length,
-      success: 0,
-      failed: 0,
-      errors: [],
-      createdDocuments: []
-    };
-    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 doc = await this.client.post("/documents", { title });
-            result.success++;
-            result.createdDocuments.push({
-              documentId: doc.documentId,
-              title: doc.title
-            });
-          }
-          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 findReplace(options) {
-    const { entries, concurrency = 10, dryRun = false, onProgress, onError } = options;
-    const result = {
-      total: entries.length,
-      success: 0,
-      failed: 0,
-      errors: [],
-      results: []
-    };
-    if (entries.length === 0)
-      return result;
-    const chunks = this.chunkArray(entries, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (entry) => {
-        try {
-          if (dryRun) {
-            result.success++;
-            result.results.push({
-              documentId: entry.documentId,
-              occurrencesChanged: 0,
-              find: entry.find,
-              replace: entry.replace
-            });
-          } else {
-            const requests = [
-              {
-                replaceAllText: {
-                  containsText: {
-                    text: entry.find,
-                    matchCase: entry.matchCase || false
-                  },
-                  replaceText: entry.replace
-                }
-              }
-            ];
-            const response = await this.client.post(`/documents/${entry.documentId}:batchUpdate`, { requests });
-            const occurrencesChanged = response.replies?.find((r) => r.replaceAllText)?.replaceAllText?.occurrencesChanged || 0;
-            result.success++;
-            result.results.push({
-              documentId: entry.documentId,
-              occurrencesChanged,
-              find: entry.find,
-              replace: entry.replace
-            });
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, entry);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({
-            documentId: entry.documentId,
-            find: entry.find,
-            error: errorMessage
-          });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), entry);
-        }
-      }));
-    }
-    return result;
-  }
-  async batchUpdate(options) {
-    const { entries, concurrency = 10, dryRun = false, onProgress, onError } = options;
-    const result = {
-      total: entries.length,
-      success: 0,
-      failed: 0,
-      errors: [],
-      results: []
-    };
-    if (entries.length === 0)
-      return result;
-    const chunks = this.chunkArray(entries, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (entry) => {
-        try {
-          if (dryRun) {
-            result.success++;
-          } else {
-            const response = await this.client.post(`/documents/${entry.documentId}:batchUpdate`, { requests: entry.requests });
-            result.success++;
-            result.results.push({
-              documentId: entry.documentId,
-              response
-            });
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, entry);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({
-            documentId: entry.documentId,
-            error: errorMessage
-          });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), entry);
-        }
-      }));
-    }
-    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 GoogleDocs {
-  client;
-  documents;
-  content;
-  styles;
-  bulk;
-  constructor(config) {
-    this.client = new GoogleDocsClient(config);
-    this.documents = new DocumentsApi(this.client);
-    this.content = new ContentApi(this.client);
-    this.styles = new StylesApi(this.client);
-    this.bulk = new BulkApi(this.client);
-  }
-  static fromEnv() {
-    const accessToken = process.env.GOOGLE_ACCESS_TOKEN;
-    const apiKey = process.env.GOOGLE_API_KEY;
-    if (!accessToken && !apiKey) {
-      throw new Error("GOOGLE_ACCESS_TOKEN or GOOGLE_API_KEY environment variable is required");
-    }
-    return new GoogleDocs({ accessToken, apiKey });
-  }
-  getCredentialsPreview() {
-    return this.client.getCredentialsPreview();
-  }
-  hasWriteAccess() {
-    return this.client.hasWriteAccess();
-  }
-  getClient() {
-    return this.client;
-  }
-}
-export {
-  setCurrentProfile,
-  setApiKey,
-  setAccessToken,
-  saveProfile,
-  loadProfile,
-  listProfiles,
-  getCurrentProfile,
-  getApiKey,
-  getAccessToken,
-  deleteProfile,
-  createProfile,
-  clearConfig,
-  StylesApi,
-  GoogleDocsClient,
-  GoogleDocsApiError,
-  GoogleDocs,
-  DocumentsApi,
-  ContentApi
-};