@hasna/connectors 0.8.1 → 0.9.0

package/connectors/connect-cloudconvert/src/utils/storage.ts

@@ -0,0 +1,198 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { getConfigDir } from './config';
+
+// ============================================
+// Generic Data Storage Utility
+// ============================================
+
+/**
+ * Base interface for storable entities
+ * All stored entities should have an id field
+ */
+export interface Storable {
+  id: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+/**
+ * Get the storage directory for an entity type
+ */
+function getStorageDir(entityType: string): string {
+  const dir = join(getConfigDir(), 'data', entityType);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+/**
+ * Convert an ID to a safe filename
+ */
+function idToFilename(id: string): string {
+  return id.toLowerCase().replace(/[^a-z0-9]/g, '_') + '.json';
+}
+
+/**
+ * Get the file path for an entity
+ */
+function getEntityPath(entityType: string, id: string): string {
+  return join(getStorageDir(entityType), idToFilename(id));
+}
+
+/**
+ * Save an entity to storage
+ */
+export function saveEntity<T extends Storable>(entityType: string, entity: T): void {
+  const filepath = getEntityPath(entityType, entity.id);
+  const now = new Date().toISOString();
+
+  const existing = getEntity<T>(entityType, entity.id);
+
+  const data: T = {
+    ...entity,
+    createdAt: existing?.createdAt || now,
+    updatedAt: now,
+  };
+
+  writeFileSync(filepath, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Get an entity by ID
+ */
+export function getEntity<T extends Storable>(entityType: string, id: string): T | null {
+  const filepath = getEntityPath(entityType, id);
+
+  if (!existsSync(filepath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(filepath, 'utf-8');
+    return JSON.parse(content) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if an entity exists
+ */
+export function entityExists(entityType: string, id: string): boolean {
+  return existsSync(getEntityPath(entityType, id));
+}
+
+/**
+ * Get all entities of a type
+ */
+export function getAllEntities<T extends Storable>(entityType: string): T[] {
+  const storageDir = getStorageDir(entityType);
+  const files = readdirSync(storageDir).filter(f => f.endsWith('.json'));
+
+  const entities: T[] = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(storageDir, file), 'utf-8');
+      entities.push(JSON.parse(content) as T);
+    } catch {
+      // Skip invalid files
+    }
+  }
+
+  return entities.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+/**
+ * Delete an entity
+ */
+export function deleteEntity(entityType: string, id: string): boolean {
+  const filepath = getEntityPath(entityType, id);
+
+  if (existsSync(filepath)) {
+    unlinkSync(filepath);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Search entities by a predicate function
+ */
+export function searchEntities<T extends Storable>(
+  entityType: string,
+  predicate: (entity: T) => boolean
+): T[] {
+  const all = getAllEntities<T>(entityType);
+  return all.filter(predicate);
+}
+
+/**
+ * Search entities by text match across all string fields
+ */
+export function searchEntitiesByText<T extends Storable>(
+  entityType: string,
+  query: string,
+  fields?: (keyof T)[]
+): T[] {
+  const all = getAllEntities<T>(entityType);
+  const q = query.toLowerCase();
+
+  return all.filter(entity => {
+    const searchFields = fields || (Object.keys(entity) as (keyof T)[]);
+    return searchFields.some(field => {
+      const value = entity[field];
+      if (typeof value === 'string') {
+        return value.toLowerCase().includes(q);
+      }
+      return false;
+    });
+  });
+}
+
+/**
+ * Count entities of a type
+ */
+export function countEntities(entityType: string): number {
+  const storageDir = getStorageDir(entityType);
+  if (!existsSync(storageDir)) {
+    return 0;
+  }
+  return readdirSync(storageDir).filter(f => f.endsWith('.json')).length;
+}
+
+/**
+ * Clear all entities of a type
+ */
+export function clearEntities(entityType: string): number {
+  const storageDir = getStorageDir(entityType);
+  if (!existsSync(storageDir)) {
+    return 0;
+  }
+
+  const files = readdirSync(storageDir).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    unlinkSync(join(storageDir, file));
+  }
+
+  return files.length;
+}
+
+/**
+ * Create a typed storage helper for a specific entity type
+ * This provides a cleaner API for working with a single entity type
+ */
+export function createStorage<T extends Storable>(entityType: string) {
+  return {
+    save: (entity: T) => saveEntity<T>(entityType, entity),
+    get: (id: string) => getEntity<T>(entityType, id),
+    exists: (id: string) => entityExists(entityType, id),
+    getAll: () => getAllEntities<T>(entityType),
+    delete: (id: string) => deleteEntity(entityType, id),
+    search: (predicate: (entity: T) => boolean) => searchEntities<T>(entityType, predicate),
+    searchByText: (query: string, fields?: (keyof T)[]) => searchEntitiesByText<T>(entityType, query, fields),
+    count: () => countEntities(entityType),
+    clear: () => clearEntities(entityType),
+  };
+}

package/connectors/connect-cloudconvert/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "bin"]
+}

package/connectors/connect-gmail/src/api/attachments.ts

@@ -96,16 +96,18 @@ export class AttachmentsApi {
    * Download a specific attachment to disk
    */
   async download(messageId: string, attachmentId: string, filename: string, mimeType: string): Promise<DownloadedAttachment> {
+    // Normalize Unicode whitespace characters in filename (e.g. non-breaking spaces from Gmail)
+    const cleanFilename = filename.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, ' ');
     const data = await this.get(messageId, attachmentId);
     const dir = this.getAttachmentsDir(messageId);
-    const filepath = join(dir, filename);
+    const filepath = join(dir, cleanFilename);
 
     // Decode base64url to buffer
     const buffer = Buffer.from(data.data, 'base64url');
     writeFileSync(filepath, buffer);
 
     return {
-      filename,
+      filename: cleanFilename,
       path: filepath,
       size: buffer.length,
       mimeType,

package/connectors/connect-googledrive/src/api/client.ts

@@ -182,7 +182,7 @@ export class DriveClient {
 
   async download(fileId: string): Promise<ArrayBuffer> {
     const accessToken = await getValidAccessToken();
-    const url = DRIVE_API_BASE + '/files/' + fileId + '?alt=media';
+    const url = DRIVE_API_BASE + '/files/' + fileId + '?alt=media&supportsAllDrives=true';
 
     const response = await fetch(url, {
       headers: {
@@ -199,7 +199,7 @@ export class DriveClient {
 
   async export(fileId: string, mimeType: string): Promise<ArrayBuffer> {
     const accessToken = await getValidAccessToken();
-    const url = DRIVE_API_BASE + '/files/' + fileId + '/export?mimeType=' + encodeURIComponent(mimeType);
+    const url = DRIVE_API_BASE + '/files/' + fileId + '/export?mimeType=' + encodeURIComponent(mimeType) + '&supportsAllDrives=true';
 
     const response = await fetch(url, {
       headers: {

package/connectors/connect-googledrive/src/api/files.ts

@@ -97,7 +97,7 @@ export class FilesApi {
       '/files',
       content,
       metadata,
-      { fields: DEFAULT_FILE_FIELDS },
+      { fields: DEFAULT_FILE_FIELDS, supportsAllDrives: true },
       mimeType
     );
   }
@@ -107,19 +107,19 @@ export class FilesApi {
    */
   async create(name: string, content: string | Buffer, options?: { folderId?: string; mimeType?: string }): Promise<DriveFile> {
     const metadata: Record<string, unknown> = { name };
-    
+
     if (options?.folderId) {
       metadata.parents = [options.folderId];
     }
 
     const buffer = typeof content === 'string' ? Buffer.from(content) : content;
     const mimeType = options?.mimeType || 'text/plain';
-    
+
     return this.client.upload<DriveFile>(
       '/files',
       buffer,
       metadata,
-      { fields: DEFAULT_FILE_FIELDS },
+      { fields: DEFAULT_FILE_FIELDS, supportsAllDrives: true },
       mimeType
     );
   }

package/dist/index.js

@@ -1656,6 +1656,265 @@ var CONNECTORS = [
     description: "Remote logging and crash reporting for apps",
     category: "Developer Tools",
     tags: ["logging", "crash-reporting", "mobile"]
+  },
+  {
+    name: "bugherd",
+    displayName: "BugHerd",
+    description: "Visual bug tracking and website feedback",
+    category: "Developer Tools",
+    tags: ["bugs", "feedback", "testing"]
+  },
+  {
+    name: "bugpilot",
+    displayName: "Bugpilot",
+    description: "AI-powered bug reporting and session replay",
+    category: "Developer Tools",
+    tags: ["bugs", "monitoring", "ai"]
+  },
+  {
+    name: "bugreplay",
+    displayName: "BugReplay",
+    description: "Screen recording and bug reporting for QA",
+    category: "Developer Tools",
+    tags: ["bugs", "recording", "qa"]
+  },
+  {
+    name: "bugshot",
+    displayName: "Bugshot",
+    description: "Screenshot-based bug reporting and annotation",
+    category: "Developer Tools",
+    tags: ["bugs", "screenshots", "annotation"]
+  },
+  {
+    name: "buildkite",
+    displayName: "Buildkite",
+    description: "CI/CD pipelines and build automation",
+    category: "Developer Tools",
+    tags: ["cicd", "builds", "pipelines"]
+  },
+  {
+    name: "bunnycdn",
+    displayName: "Bunny CDN",
+    description: "Content delivery network and edge storage",
+    category: "Developer Tools",
+    tags: ["cdn", "storage", "edge"]
+  },
+  {
+    name: "calendarhero",
+    displayName: "CalendarHero",
+    description: "AI-powered scheduling and meeting automation",
+    category: "Business Tools",
+    tags: ["scheduling", "calendar", "meetings"]
+  },
+  {
+    name: "canvas",
+    displayName: "Canvas LMS",
+    description: "Learning management system for courses and assignments",
+    category: "Business Tools",
+    tags: ["lms", "education", "courses"]
+  },
+  {
+    name: "capsule",
+    displayName: "Capsule CRM",
+    description: "Simple CRM for contacts, sales, and tasks",
+    category: "Business Tools",
+    tags: ["crm", "contacts", "sales"]
+  },
+  {
+    name: "carbonblack",
+    displayName: "Carbon Black",
+    description: "Endpoint security and threat detection",
+    category: "Developer Tools",
+    tags: ["security", "endpoint", "threat-detection"]
+  },
+  {
+    name: "chaindesk",
+    displayName: "Chaindesk",
+    description: "No-code AI chatbot platform for custom data",
+    category: "AI & ML",
+    tags: ["ai", "chatbot", "no-code"]
+  },
+  {
+    name: "chargeover",
+    displayName: "ChargeOver",
+    description: "Recurring billing and invoicing automation",
+    category: "Commerce & Finance",
+    tags: ["billing", "invoicing", "subscriptions"]
+  },
+  {
+    name: "chargify",
+    displayName: "Chargify",
+    description: "Subscription billing and revenue management",
+    category: "Commerce & Finance",
+    tags: ["billing", "subscriptions", "saas"]
+  },
+  {
+    name: "chatbase",
+    displayName: "Chatbase",
+    description: "Custom AI chatbots trained on your data",
+    category: "AI & ML",
+    tags: ["ai", "chatbot", "custom"]
+  },
+  {
+    name: "chatling",
+    displayName: "Chatling",
+    description: "AI chatbot builder for websites",
+    category: "AI & ML",
+    tags: ["ai", "chatbot", "website"]
+  },
+  {
+    name: "chatmasters",
+    displayName: "Chatmasters",
+    description: "AI-powered customer service chatbots",
+    category: "AI & ML",
+    tags: ["ai", "chatbot", "support"]
+  },
+  {
+    name: "chatrace",
+    displayName: "Chatrace",
+    description: "Chatbot marketing and lead generation",
+    category: "Communication",
+    tags: ["chatbot", "marketing", "leads"]
+  },
+  {
+    name: "chatsonic",
+    displayName: "ChatSonic",
+    description: "AI content generation and conversational AI",
+    category: "AI & ML",
+    tags: ["ai", "content", "chat"]
+  },
+  {
+    name: "chekhub",
+    displayName: "Chekhub",
+    description: "Field service management and work order tracking",
+    category: "Business Tools",
+    tags: ["field-service", "work-orders", "maintenance"]
+  },
+  {
+    name: "chromavectorstore",
+    displayName: "Chroma Vector Store",
+    description: "Open-source vector database for AI embeddings",
+    category: "AI & ML",
+    tags: ["ai", "vector", "embeddings", "database"]
+  },
+  {
+    name: "circleci",
+    displayName: "CircleCI",
+    description: "Continuous integration and delivery platform",
+    category: "Developer Tools",
+    tags: ["cicd", "builds", "devops"]
+  },
+  {
+    name: "ciscomeraki",
+    displayName: "Cisco Meraki",
+    description: "Cloud-managed networking and WiFi",
+    category: "Developer Tools",
+    tags: ["networking", "wifi", "cisco"]
+  },
+  {
+    name: "ciscosecureendpoint",
+    displayName: "Cisco Secure Endpoint",
+    description: "Endpoint protection and threat response",
+    category: "Developer Tools",
+    tags: ["security", "endpoint", "cisco"]
+  },
+  {
+    name: "ciscoumbrella",
+    displayName: "Cisco Umbrella",
+    description: "Cloud security and DNS protection",
+    category: "Developer Tools",
+    tags: ["security", "dns", "cisco"]
+  },
+  {
+    name: "ciscowebex",
+    displayName: "Cisco Webex",
+    description: "Video conferencing, messaging, and collaboration",
+    category: "Communication",
+    tags: ["video", "meetings", "cisco"]
+  },
+  {
+    name: "citrixadc",
+    displayName: "Citrix ADC",
+    description: "Application delivery controller and load balancing",
+    category: "Developer Tools",
+    tags: ["networking", "load-balancing", "adc"]
+  },
+  {
+    name: "clappia",
+    displayName: "Clappia",
+    description: "No-code business app builder",
+    category: "Developer Tools",
+    tags: ["no-code", "app-builder", "business"]
+  },
+  {
+    name: "clarifai",
+    displayName: "Clarifai",
+    description: "AI platform for computer vision and NLP",
+    category: "AI & ML",
+    tags: ["ai", "vision", "nlp"]
+  },
+  {
+    name: "cleverreach",
+    displayName: "CleverReach",
+    description: "Email marketing and newsletter automation",
+    category: "Communication",
+    tags: ["email", "marketing", "newsletters"]
+  },
+  {
+    name: "clicksendsms",
+    displayName: "ClickSend SMS",
+    description: "SMS, MMS, and communication APIs",
+    category: "Communication",
+    tags: ["sms", "mms", "messaging"]
+  },
+  {
+    name: "clockify",
+    displayName: "Clockify",
+    description: "Time tracking and timesheet management",
+    category: "Business Tools",
+    tags: ["time-tracking", "timesheets", "productivity"]
+  },
+  {
+    name: "cloozo",
+    displayName: "Cloozo",
+    description: "AI chatbot builder with knowledge base integration",
+    category: "AI & ML",
+    tags: ["ai", "chatbot", "knowledge-base"]
+  },
+  {
+    name: "cloud66",
+    displayName: "Cloud 66",
+    description: "DevOps and infrastructure management for cloud deployments",
+    category: "Developer Tools",
+    tags: ["devops", "deployment", "infrastructure"]
+  },
+  {
+    name: "cloudboost",
+    displayName: "CloudBoost",
+    description: "Backend-as-a-service with database, search, and storage",
+    category: "Developer Tools",
+    tags: ["baas", "database", "backend"]
+  },
+  {
+    name: "cloudconvert",
+    displayName: "CloudConvert",
+    description: "File conversion API for 200+ formats",
+    category: "Developer Tools",
+    tags: ["conversion", "files", "api"]
+  },
+  {
+    name: "browseruse",
+    displayName: "Browser Use",
+    description: "AI-powered browser automation tasks and sessions",
+    category: "AI & ML",
+    tags: ["ai", "browser", "automation"]
+  },
+  {
+    name: "clickbank",
+    displayName: "ClickBank",
+    description: "Affiliate marketplace and digital product sales",
+    category: "Commerce & Finance",
+    tags: ["affiliate", "marketplace", "digital"]
   }
 ];
 function getConnectorsByCategory(category) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/connectors",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Open source connector library - Install API connectors with a single command",
   "type": "module",
   "bin": {