@hasna/connectors 1.3.31 → 1.3.33

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

@@ -1,650 +0,0 @@
-// @bun
-// 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-googletasks";
-var DEFAULT_PROFILE = "default";
-var CURRENT_PROFILE_FILE = "current_profile";
-var PROFILES_DIR = "profiles";
-var profileOverride;
-function resolveBaseConfigDir() {
-  return join(homedir(), ".hasna", "connectors", CONNECTOR_NAME);
-}
-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 profileExists(profile) {
-  const profileDir = join(getProfilesDir(), profile);
-  return existsSync(profileDir);
-}
-function getCurrentProfile() {
-  if (profileOverride) {
-    return profileOverride;
-  }
-  ensureBaseConfigDir();
-  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();
-  if (!profileExists(profile) && profile !== DEFAULT_PROFILE) {
-    throw new Error(`Profile "${profile}" does not exist`);
-  }
-  writeFileSync(getCurrentProfileFile(), profile);
-}
-function listProfiles() {
-  ensureBaseConfigDir();
-  const profilesDir = getProfilesDir();
-  if (!existsSync(profilesDir)) {
-    return [];
-  }
-  return readdirSync(profilesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
-}
-function createProfile(profile, config = {}) {
-  ensureBaseConfigDir();
-  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");
-  }
-  const profileDir = join(getProfilesDir(), profile);
-  mkdirSync(profileDir, { recursive: true });
-  if (Object.keys(config).length > 0) {
-    writeFileSync(join(profileDir, "config.json"), 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);
-  }
-  const profileDir = join(getProfilesDir(), profile);
-  rmSync(profileDir, { recursive: true });
-  return true;
-}
-function resolveConfigDir() {
-  ensureBaseConfigDir();
-  const profile = getCurrentProfile();
-  const profileDir = join(getProfilesDir(), profile);
-  if (!existsSync(profileDir)) {
-    mkdirSync(profileDir, { recursive: true });
-  }
-  return profileDir;
-}
-function ensureConfigDir() {
-  const configDir = resolveConfigDir();
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
-  }
-}
-function loadProfile(profile) {
-  ensureConfigDir();
-  const profileName = profile || getCurrentProfile();
-  let config = {};
-  const flatPath = join(getProfilesDir(), `${profileName}.json`);
-  if (existsSync(flatPath)) {
-    try {
-      config = JSON.parse(readFileSync(flatPath, "utf-8"));
-    } catch {}
-  }
-  const dirConfigPath = join(getProfilesDir(), profileName, "config.json");
-  if (existsSync(dirConfigPath)) {
-    try {
-      const dirConfig = JSON.parse(readFileSync(dirConfigPath, "utf-8"));
-      config = { ...config, ...dirConfig };
-    } catch {}
-  }
-  const tokensPath = join(getProfilesDir(), 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.tokenExpiry)
-        config.tokenExpiry = tokens.expiresAt;
-    } catch {}
-  }
-  return config;
-}
-function saveProfile(config, profile) {
-  ensureConfigDir();
-  const profileName = profile || getCurrentProfile();
-  const profileDir = join(getProfilesDir(), profileName);
-  if (!existsSync(profileDir)) {
-    mkdirSync(profileDir, { recursive: true });
-  }
-  writeFileSync(join(profileDir, "config.json"), JSON.stringify(config, null, 2));
-}
-var CREDENTIALS_FILE = join(BASE_CONFIG_DIR, "credentials.json");
-function loadCredentials() {
-  ensureBaseConfigDir();
-  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) {
-  ensureBaseConfigDir();
-  writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), { mode: 384 });
-}
-function getClientId() {
-  return process.env.GOOGLE_TASKS_CLIENT_ID || process.env.GOOGLE_CLIENT_ID || loadCredentials().clientId || loadProfile().clientId;
-}
-function getClientSecret() {
-  return process.env.GOOGLE_TASKS_CLIENT_SECRET || process.env.GOOGLE_CLIENT_SECRET || loadCredentials().clientSecret || loadProfile().clientSecret;
-}
-function getAccessToken() {
-  return process.env.GOOGLE_ACCESS_TOKEN || loadProfile().accessToken;
-}
-function getRefreshToken() {
-  return loadProfile().refreshToken;
-}
-function getTokenExpiry() {
-  return loadProfile().tokenExpiry;
-}
-function setCredentials(clientId, clientSecret) {
-  saveCredentials({ clientId, clientSecret });
-}
-function setTokens(accessToken, refreshToken, expiresIn) {
-  const config = loadProfile();
-  config.accessToken = accessToken;
-  if (refreshToken) {
-    config.refreshToken = refreshToken;
-  }
-  config.tokenExpiry = Date.now() + expiresIn * 1000;
-  saveProfile(config);
-}
-function isTokenExpired() {
-  const expiry = getTokenExpiry();
-  if (!expiry)
-    return true;
-  return Date.now() >= expiry - 60000;
-}
-function clearTokens() {
-  const config = loadProfile();
-  delete config.accessToken;
-  delete config.refreshToken;
-  delete config.tokenExpiry;
-  saveProfile(config);
-}
-function clearConfig() {
-  saveProfile({});
-}
-
-// src/api/bulk.ts
-var TASKS_API_BASE = "https://tasks.googleapis.com/tasks/v1";
-var OAUTH_TOKEN_URL = "https://oauth2.googleapis.com/token";
-
-class BulkApi {
-  token = null;
-  async#getValidToken() {
-    if (this.token)
-      return this.token;
-    let accessToken = getAccessToken();
-    if (!accessToken) {
-      throw new Error('Not authenticated. Run "connect-googletasks auth login" first.');
-    }
-    if (isTokenExpired()) {
-      const refreshToken = getRefreshToken();
-      const clientId = getClientId();
-      const clientSecret = getClientSecret();
-      if (!refreshToken || !clientId || !clientSecret) {
-        throw new Error('Token expired and cannot refresh. Run "connect-googletasks auth login"');
-      }
-      const response = await fetch(OAUTH_TOKEN_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-          refresh_token: refreshToken,
-          client_id: clientId,
-          client_secret: clientSecret,
-          grant_type: "refresh_token"
-        }).toString()
-      });
-      if (!response.ok) {
-        throw new Error("Failed to refresh token");
-      }
-      const tokens = await response.json();
-      setTokens(tokens.access_token, tokens.refresh_token, tokens.expires_in);
-      accessToken = tokens.access_token;
-    }
-    this.token = accessToken;
-    return accessToken;
-  }
-  async#request(method, path, body, params) {
-    const token = await this.#getValidToken();
-    let url = `${TASKS_API_BASE}${path}`;
-    if (params) {
-      const searchParams = new URLSearchParams;
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined)
-          searchParams.append(key, String(value));
-      }
-      const qs = searchParams.toString();
-      if (qs)
-        url += `?${qs}`;
-    }
-    const headers = {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json"
-    };
-    const response = await fetch(url, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      const message = error.error?.message || response.statusText;
-      throw new Error(message);
-    }
-    if (response.status === 204)
-      return {};
-    return response.json();
-  }
-  async preview(taskListId, options) {
-    const tasks = await this.#fetchTasks(taskListId, {
-      q: options?.query,
-      showCompleted: options?.showCompleted,
-      maxResults: options?.maxResults || 50
-    });
-    return { tasks, total: tasks.length, taskListId };
-  }
-  async complete(options) {
-    const tasks = await this.#fetchTasks(options.taskListId, {
-      q: options.query,
-      showCompleted: options.showCompleted ?? false,
-      maxResults: options.maxResults || 100
-    });
-    const pending = tasks.filter((t) => t.status !== "completed");
-    return this.#executeBatch(pending, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (task) => {
-        await this.#request("PATCH", `/lists/${options.taskListId}/tasks/${task.id}`, { status: "completed", completed: new Date().toISOString() });
-      }
-    });
-  }
-  async uncomplete(options) {
-    const tasks = await this.#fetchTasks(options.taskListId, {
-      showCompleted: true,
-      maxResults: options.maxResults || 100
-    });
-    const completed = tasks.filter((t) => t.status === "completed");
-    return this.#executeBatch(completed, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (task) => {
-        await this.#request("PATCH", `/lists/${options.taskListId}/tasks/${task.id}`, { status: "needsAction" });
-      }
-    });
-  }
-  async delete(options) {
-    const tasks = await this.#fetchTasks(options.taskListId, {
-      q: options.query,
-      showCompleted: options.showCompleted,
-      maxResults: options.maxResults || 100
-    });
-    return this.#executeBatch(tasks, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (task) => {
-        await this.#request("DELETE", `/lists/${options.taskListId}/tasks/${task.id}`);
-      }
-    });
-  }
-  async update(taskListId, options) {
-    const tasks = await this.#fetchTasks(taskListId, {
-      q: options.query,
-      showCompleted: options.showCompleted,
-      maxResults: options.maxResults || 100
-    });
-    return this.#executeBatch(tasks, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (task) => {
-        const patch = {};
-        if (options.updates.due !== undefined)
-          patch.due = options.updates.due;
-        if (options.updates.notes !== undefined)
-          patch.notes = options.updates.notes;
-        await this.#request("PATCH", `/lists/${taskListId}/tasks/${task.id}`, patch);
-      }
-    });
-  }
-  async#fetchTasks(taskListId, params) {
-    const tasks = [];
-    let pageToken;
-    const max = params.maxResults || 100;
-    while (tasks.length < max) {
-      const requestParams = {
-        maxResults: Math.min(100, max - tasks.length),
-        pageToken,
-        showCompleted: params.showCompleted ?? false
-      };
-      if (params.q)
-        requestParams.q = params.q;
-      const response = await this.#request("GET", `/lists/${taskListId}/tasks`, undefined, requestParams);
-      if (!response.items || response.items.length === 0)
-        break;
-      for (const t of response.items) {
-        tasks.push({
-          id: t.id,
-          title: t.title || "(untitled)",
-          status: t.status || "needsAction",
-          due: t.due,
-          notes: t.notes
-        });
-      }
-      pageToken = response.nextPageToken;
-      if (!pageToken)
-        break;
-    }
-    return tasks;
-  }
-  async#executeBatch(tasks, options) {
-    const { dryRun, concurrency, onProgress, onError, operation } = options;
-    const result = {
-      total: tasks.length,
-      success: 0,
-      failed: 0,
-      skipped: 0,
-      errors: [],
-      processedTasks: []
-    };
-    if (tasks.length === 0)
-      return result;
-    const chunks = this.#chunkArray(tasks, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (task) => {
-        try {
-          if (dryRun) {
-            result.success++;
-            result.processedTasks.push(task);
-          } else {
-            await operation(task);
-            result.success++;
-            result.processedTasks.push(task);
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, task);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ taskId: task.id, error: errorMessage });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), task);
-        }
-      }));
-    }
-    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
-var TASKS_API_BASE2 = "https://tasks.googleapis.com/tasks/v1";
-var OAUTH_TOKEN_URL2 = "https://oauth2.googleapis.com/token";
-var OAUTH_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
-var REDIRECT_URI = "urn:ietf:wg:oauth:2.0:oob";
-var SCOPES = ["https://www.googleapis.com/auth/tasks"];
-
-class GoogleTasksClient {
-  accessToken;
-  constructor(accessToken) {
-    this.accessToken = accessToken;
-  }
-  static getAuthUrl(clientId) {
-    const params = new URLSearchParams({
-      client_id: clientId,
-      redirect_uri: REDIRECT_URI,
-      response_type: "code",
-      scope: SCOPES.join(" "),
-      access_type: "offline",
-      prompt: "consent"
-    });
-    return `${OAUTH_AUTH_URL}?${params.toString()}`;
-  }
-  static async exchangeCode(code, clientId, clientSecret) {
-    const response = await fetch(OAUTH_TOKEN_URL2, {
-      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"
-      }).toString()
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new Error(`Failed to exchange code: ${error.error_description || response.statusText}`);
-    }
-    return response.json();
-  }
-  static async refreshAccessToken(refreshToken, clientId, clientSecret) {
-    const response = await fetch(OAUTH_TOKEN_URL2, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
-        refresh_token: refreshToken,
-        client_id: clientId,
-        client_secret: clientSecret,
-        grant_type: "refresh_token"
-      }).toString()
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new Error(`Failed to refresh token: ${error.error_description || response.statusText}`);
-    }
-    return response.json();
-  }
-  async getValidToken() {
-    if (this.accessToken) {
-      return this.accessToken;
-    }
-    let token = getAccessToken();
-    if (!token) {
-      throw new AuthenticationError;
-    }
-    if (isTokenExpired()) {
-      const refreshToken = getRefreshToken();
-      const clientId = getClientId();
-      const clientSecret = getClientSecret();
-      if (!refreshToken || !clientId || !clientSecret) {
-        throw new AuthenticationError('Token expired and cannot refresh. Run "connect-googletasks auth login"');
-      }
-      const tokens = await GoogleTasksClient.refreshAccessToken(refreshToken, clientId, clientSecret);
-      setTokens(tokens.access_token, tokens.refresh_token, tokens.expires_in);
-      token = tokens.access_token;
-    }
-    return token;
-  }
-  async request(method, path, body, params) {
-    const token = await this.getValidToken();
-    let url = `${TASKS_API_BASE2}${path}`;
-    if (params) {
-      const searchParams = new URLSearchParams;
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined) {
-          searchParams.append(key, String(value));
-        }
-      }
-      const queryString = searchParams.toString();
-      if (queryString) {
-        url += `?${queryString}`;
-      }
-    }
-    const headers = {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json"
-    };
-    const response = await fetch(url, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      const message = error.error?.message || response.statusText;
-      throw {
-        name: "GoogleTasksError",
-        message,
-        statusCode: response.status,
-        details: error
-      };
-    }
-    if (response.status === 204) {
-      return {};
-    }
-    return response.json();
-  }
-  async listTaskLists(maxResults, pageToken) {
-    return this.request("GET", "/users/@me/lists", undefined, {
-      maxResults,
-      pageToken
-    });
-  }
-  async getTaskList(taskListId) {
-    return this.request("GET", `/users/@me/lists/${taskListId}`);
-  }
-  async createTaskList(params) {
-    return this.request("POST", "/users/@me/lists", params);
-  }
-  async updateTaskList(taskListId, params) {
-    return this.request("PATCH", `/users/@me/lists/${taskListId}`, params);
-  }
-  async deleteTaskList(taskListId) {
-    await this.request("DELETE", `/users/@me/lists/${taskListId}`);
-  }
-  async listTasks(taskListId, params) {
-    return this.request("GET", `/lists/${taskListId}/tasks`, undefined, {
-      maxResults: params?.maxResults,
-      pageToken: params?.pageToken,
-      showCompleted: params?.showCompleted,
-      showDeleted: params?.showDeleted,
-      showHidden: params?.showHidden,
-      updatedMin: params?.updatedMin,
-      completedMin: params?.completedMin,
-      completedMax: params?.completedMax,
-      dueMin: params?.dueMin,
-      dueMax: params?.dueMax
-    });
-  }
-  async getTask(taskListId, taskId) {
-    return this.request("GET", `/lists/${taskListId}/tasks/${taskId}`);
-  }
-  async createTask(taskListId, params, parent, previous) {
-    return this.request("POST", `/lists/${taskListId}/tasks`, params, {
-      parent,
-      previous
-    });
-  }
-  async updateTask(taskListId, taskId, params) {
-    return this.request("PATCH", `/lists/${taskListId}/tasks/${taskId}`, params);
-  }
-  async deleteTask(taskListId, taskId) {
-    await this.request("DELETE", `/lists/${taskListId}/tasks/${taskId}`);
-  }
-  async completeTask(taskListId, taskId) {
-    return this.updateTask(taskListId, taskId, {
-      status: "completed",
-      completed: new Date().toISOString()
-    });
-  }
-  async uncompleteTask(taskListId, taskId) {
-    return this.updateTask(taskListId, taskId, {
-      status: "needsAction"
-    });
-  }
-  async moveTask(taskListId, taskId, params) {
-    return this.request("POST", `/lists/${taskListId}/tasks/${taskId}/move`, undefined, {
-      parent: params?.parent,
-      previous: params?.previous
-    });
-  }
-  async clearCompleted(taskListId) {
-    await this.request("POST", `/lists/${taskListId}/clear`);
-  }
-}
-export {
-  setTokens,
-  setCurrentProfile,
-  setCredentials,
-  saveProfile,
-  loadProfile,
-  listProfiles,
-  isTokenExpired,
-  getRefreshToken,
-  getCurrentProfile,
-  getClientSecret,
-  getClientId,
-  getAccessToken,
-  deleteProfile,
-  createProfile,
-  clearTokens,
-  clearConfig,
-  GoogleTasksClient
-};

package/connectors/connect-imessage/bin/.gitkeep

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-// This file is generated by the build. Run: bun run build