@hasna/connectors 1.3.21 → 1.3.23

package/bin/serve.js

@@ -17,7 +17,7 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// node_modules/@hasna/cloud/dist/index.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/@hasna/cloud/dist/index.js
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import {
@@ -10327,7 +10327,7 @@ import { existsSync as existsSync7 } from "fs";
 import { dirname as dirname3, join as join8 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 
-// node_modules/zod/v3/external.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/zod/v3/external.js
 var exports_external2 = {};
 __export(exports_external2, {
   void: () => voidType2,
@@ -10439,7 +10439,7 @@ __export(exports_external2, {
   BRAND: () => BRAND2
 });
 
-// node_modules/zod/v3/helpers/util.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/zod/v3/helpers/util.js
 var util2;
 (function(util3) {
   util3.assertEqual = (_) => {};
@@ -10570,7 +10570,7 @@ var getParsedType2 = (data) => {
   }
 };
 
-// node_modules/zod/v3/ZodError.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/zod/v3/ZodError.js
 var ZodIssueCode2 = util2.arrayToEnum([
   "invalid_type",
   "invalid_literal",
@@ -10689,7 +10689,7 @@ ZodError2.create = (issues) => {
   return error;
 };
 
-// node_modules/zod/v3/locales/en.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/zod/v3/locales/en.js
 var errorMap2 = (issue, _ctx) => {
   let message;
   switch (issue.code) {
@@ -10792,7 +10792,7 @@ var errorMap2 = (issue, _ctx) => {
 };
 var en_default2 = errorMap2;
 
-// node_modules/zod/v3/errors.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/zod/v3/errors.js
 var overrideErrorMap2 = en_default2;
 function setErrorMap2(map) {
   overrideErrorMap2 = map;
@@ -10800,7 +10800,7 @@ function setErrorMap2(map) {
 function getErrorMap2() {
   return overrideErrorMap2;
 }
-// node_modules/zod/v3/helpers/parseUtil.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue2 = (params) => {
   const { data, path, errorMaps, issueData } = params;
   const fullPath = [...path, ...issueData.path || []];
@@ -10906,14 +10906,14 @@ var isAborted2 = (x) => x.status === "aborted";
 var isDirty2 = (x) => x.status === "dirty";
 var isValid2 = (x) => x.status === "valid";
 var isAsync2 = (x) => typeof Promise !== "undefined" && x instanceof Promise;
-// node_modules/zod/v3/helpers/errorUtil.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil2;
 (function(errorUtil3) {
   errorUtil3.errToObj = (message) => typeof message === "string" ? { message } : message || {};
   errorUtil3.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil2 || (errorUtil2 = {}));
 
-// node_modules/zod/v3/types.js
+// ../../../home/hasna/workspace/hasna/opensource/open-connectors/node_modules/zod/v3/types.js
 class ParseInputLazyPath2 {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
@@ -15160,7 +15160,7 @@ var githubConnector = defineConnector({
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.20",
+  version: "1.3.23",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {
@@ -15191,7 +15191,7 @@ var package_default = {
     typecheck: "tsc --noEmit",
     test: "bun test",
     "sdk:build": "cd sdk && bun run build",
-    prepublishOnly: "bun test && bun run build"
+    prepublishOnly: "bun run build && bun test"
   },
   keywords: [
     "connectors",
@@ -23528,6 +23528,53 @@ function getConnectorCliPath(name) {
 function hasConnectorCommandSurface(name) {
   return Boolean(getInternalCommandRuntime(name)?.commands.length || getConnectorCliPath(name));
 }
+function normalizeCommanderUsage(usage) {
+  const commandToken = usage.trim().split(/\s+/)[0];
+  if (!commandToken || commandToken === "help")
+    return null;
+  const aliases = commandToken.split("|").filter(Boolean);
+  const [name, ...rest] = aliases;
+  if (!name)
+    return null;
+  return {
+    name,
+    aliases: rest,
+    usage: usage.trim()
+  };
+}
+function parseCommanderHelpOperations(helpText) {
+  const operations = [];
+  const lines = helpText.split(`
+`);
+  let inCommands = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("Commands:")) {
+      inCommands = true;
+      continue;
+    }
+    if (!inCommands)
+      continue;
+    if (line.trim() === "") {
+      if (operations.length > 0)
+        inCommands = false;
+      continue;
+    }
+    const row = line.match(/^ {2}(\S.*?)(?: {2,}(.+))?$/);
+    if (!row)
+      continue;
+    const usage = row[1].trim();
+    const summary = (row[2] ?? "").trim();
+    const normalized = normalizeCommanderUsage(usage);
+    if (!normalized)
+      continue;
+    operations.push({
+      ...normalized,
+      summary,
+      source: "cli"
+    });
+  }
+  return operations;
+}
 function runConnectorCommand2(name, args, timeoutMs = 30000) {
   getConnectorsHome();
   const internalRuntime = getInternalCommandRuntime(name);
@@ -23594,38 +23641,33 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
 async function getConnectorOperations(name) {
   const internalRuntime = getInternalCommandRuntime(name);
   if (internalRuntime?.commands.length) {
+    const operations2 = internalRuntime.commands.map((command) => ({
+      name: command.name,
+      aliases: [],
+      usage: command.name,
+      summary: command.summary,
+      source: "internal"
+    }));
     return {
-      commands: internalRuntime.commands.map((command) => command.name),
+      commands: operations2.map((operation) => operation.name),
+      operations: operations2,
       helpText: internalRuntime.helpText ?? buildInternalHelpText(name, internalRuntime.commands),
       hasCli: true
     };
   }
   const cliPath = getConnectorCliPath(name);
   if (!cliPath) {
-    return { commands: [], helpText: "", hasCli: false };
+    return { commands: [], operations: [], helpText: "", hasCli: false };
   }
   const result = await runConnectorCommand2(name, ["--help"]);
   const helpText = result.stdout || result.stderr;
-  const commands = [];
-  const lines = helpText.split(`
-`);
-  let inCommands = false;
-  for (const line of lines) {
-    if (line.trim().startsWith("Commands:")) {
-      inCommands = true;
-      continue;
-    }
-    if (inCommands) {
-      const match = line.match(/^\s{2,}(\S+)/);
-      if (match && match[1] !== "help") {
-        commands.push(match[1]);
-      }
-      if (line.trim() === "" && commands.length > 0) {
-        inCommands = false;
-      }
-    }
-  }
-  return { commands, helpText, hasCli: true };
+  const operations = parseCommanderHelpOperations(helpText);
+  return {
+    commands: operations.map((operation) => operation.name),
+    operations,
+    helpText,
+    hasCli: true
+  };
 }
 async function getConnectorCommandHelp(name, command) {
   const internalRuntime = getInternalCommandRuntime(name);
@@ -24349,7 +24391,9 @@ Dashboard not found at: ${dashboardDir}`);
         return json({
           connector: name,
           displayName: meta.displayName,
+          auth: getAuthStatus(name),
           commands: ops.commands,
+          operations: ops.operations,
           helpText: ops.helpText
         }, 200, port);
       }

package/connectors/connect-dropbox/src/api/bulk.ts

@@ -0,0 +1,285 @@
+import type { DropboxClient } from './client';
+import type { Metadata, FileMetadata, RelocationBatchV2Result } from '../types';
+
+// ============================================
+// Bulk Operation Types
+// ============================================
+
+export interface BulkOperationOptions {
+  /** Maximum concurrent API calls (default: 10) */
+  concurrency?: number;
+  /** Dry run - don't actually modify */
+  dryRun?: boolean;
+  /** Progress callback */
+  onProgress?: (current: number, total: number, item: unknown) => void;
+  /** Error callback */
+  onError?: (error: Error, item: unknown) => void;
+}
+
+export interface PathSummary {
+  path: string;
+  displayName?: string;
+}
+
+export interface BulkDeleteOptions extends BulkOperationOptions {
+  /** Paths to delete */
+  paths: string[];
+}
+
+export interface BulkDeleteResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ path: string; error: string }>;
+  deletedPaths: string[];
+}
+
+export interface CopyEntry {
+  fromPath: string;
+  toPath: string;
+}
+
+export interface BulkCopyOptions extends BulkOperationOptions {
+  /** Source/destination path pairs */
+  entries: CopyEntry[];
+  /** Autorename if destination exists */
+  autorename?: boolean;
+  /** Allow shared folders */
+  allowSharedFolder?: boolean;
+}
+
+export interface CopyResult {
+  fromPath: string;
+  toPath: string;
+  metadata?: Metadata;
+}
+
+export interface BulkCopyResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ fromPath: string; toPath: string; error: string }>;
+  results: CopyResult[];
+}
+
+export interface MoveEntry {
+  fromPath: string;
+  toPath: string;
+}
+
+export interface BulkMoveOptions extends BulkOperationOptions {
+  /** Source/destination path pairs */
+  entries: MoveEntry[];
+  /** Autorename if destination exists */
+  autorename?: boolean;
+  /** Allow shared folders */
+  allowSharedFolder?: boolean;
+}
+
+export interface MoveResult {
+  fromPath: string;
+  toPath: string;
+  metadata?: Metadata;
+}
+
+export interface BulkMoveResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ fromPath: string; toPath: string; error: string }>;
+  results: MoveResult[];
+}
+
+// ============================================
+// Bulk Operations API
+// ============================================
+
+export class BulkApi {
+  private readonly client: DropboxClient;
+
+  constructor(client: DropboxClient) {
+    this.client = client;
+  }
+
+  // ============================================
+  // Delete Batch
+  // ============================================
+
+  /**
+   * Bulk delete files and folders
+   */
+  async delete(options: BulkDeleteOptions): Promise<BulkDeleteResult> {
+    const { paths, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkDeleteResult = {
+      total: paths.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      deletedPaths: [],
+    };
+
+    if (paths.length === 0) return result;
+
+    const chunks = this.chunkArray(paths, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (path) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              await this.client.post('/files/delete_v2', { path });
+              result.success++;
+              result.deletedPaths.push(path);
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, path);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ path, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), path);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Copy Batch
+  // ============================================
+
+  /**
+   * Bulk copy files and folders
+   */
+  async copy(options: BulkCopyOptions): Promise<BulkCopyResult> {
+    const { entries, concurrency = 10, dryRun = false, autorename = false, allowSharedFolder = false, onProgress, onError } = options;
+
+    const result: BulkCopyResult = {
+      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<RelocationBatchV2Result>('/files/copy_v2', {
+                from_path: entry.fromPath,
+                to_path: entry.toPath,
+                autorename,
+                allow_shared_folder: allowSharedFolder,
+              });
+              result.success++;
+              result.results.push({
+                fromPath: entry.fromPath,
+                toPath: entry.toPath,
+                metadata: (response as unknown as { metadata: Metadata }).metadata,
+              });
+            }
+
+            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({
+              fromPath: entry.fromPath,
+              toPath: entry.toPath,
+              error: errorMessage,
+            });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), entry);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Move Batch
+  // ============================================
+
+  /**
+   * Bulk move files and folders
+   */
+  async move(options: BulkMoveOptions): Promise<BulkMoveResult> {
+    const { entries, concurrency = 10, dryRun = false, autorename = false, allowSharedFolder = false, onProgress, onError } = options;
+
+    const result: BulkMoveResult = {
+      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<RelocationBatchV2Result>('/files/move_v2', {
+                from_path: entry.fromPath,
+                to_path: entry.toPath,
+                autorename,
+                allow_shared_folder: allowSharedFolder,
+              });
+              result.success++;
+              result.results.push({
+                fromPath: entry.fromPath,
+                toPath: entry.toPath,
+                metadata: (response as unknown as { metadata: Metadata }).metadata,
+              });
+            }
+
+            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({
+              fromPath: entry.fromPath,
+              toPath: entry.toPath,
+              error: errorMessage,
+            });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), entry);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Helper Methods
+  // ============================================
+
+  private chunkArray<T>(array: T[], size: number): T[][] {
+    const chunks: T[][] = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+}

package/connectors/connect-dropbox/src/api/index.ts

@@ -15,15 +15,18 @@ import type {
   DeleteResult,
 } from '../types';
 import { DropboxClient } from './client';
+import { BulkApi } from './bulk';
 
 /**
  * Dropbox API wrapper
  */
 export class Dropbox {
   private readonly client: DropboxClient;
+  public readonly bulk: BulkApi;
 
   constructor(config: DropboxConfig) {
     this.client = new DropboxClient(config);
+    this.bulk = new BulkApi(this.client);
   }
 
   /**
@@ -393,3 +396,4 @@ export class Dropbox {
 }
 
 export { DropboxClient } from './client';
+export { BulkApi } from './bulk';

package/connectors/connect-dropbox/src/cli/index.ts

@@ -623,5 +623,156 @@ accountCmd
     }
   });
 
+// ============================================
+// Bulk Commands
+// ============================================
+
+const bulkCmd = program.command('bulk').description('Bulk operations on files and folders');
+
+bulkCmd
+  .command('delete')
+  .description('Bulk delete files and folders')
+  .requiredOption('--paths <paths>', 'Comma-separated list of paths')
+  .option('--concurrency <number>', 'Max concurrent requests', '10')
+  .option('--dry-run', 'Preview without making changes')
+  .action(async (opts) => {
+    const paths = opts.paths.split(',').map((p: string) => p.trim()).filter(Boolean);
+    const concurrency = parseInt(opts.concurrency, 10);
+
+    if (paths.length === 0) {
+      console.error(chalk.red('Error: No paths provided'));
+      process.exit(1);
+    }
+
+    const client = getClient();
+    console.log(chalk.blue(`Deleting ${paths.length} path(s) (concurrency: ${concurrency})...`));
+    if (opts.dryRun) console.log(chalk.yellow('(dry run)'));
+
+    const result = await client.bulk.delete({
+      paths,
+      concurrency,
+      dryRun: opts.dryRun,
+      onProgress: (current, total) => {
+        process.stdout.write(`\rProgress: ${current}/${total}`);
+      },
+      onError: (err, path) => {
+        console.error(`\n  Failed: ${path} - ${err.message}`);
+      },
+    });
+
+    console.log();
+    console.log(chalk.green(`Done: ${result.success} deleted, ${result.failed} failed`));
+    if (result.errors.length > 0) {
+      console.log(chalk.yellow('Errors:'));
+      for (const e of result.errors) {
+        console.log(`  - ${e.path}: ${e.error}`);
+      }
+    }
+  });
+
+bulkCmd
+  .command('copy')
+  .description('Bulk copy files and folders')
+  .requiredOption('--entries <entries>', 'JSON array of {fromPath, toPath}')
+  .option('--concurrency <number>', 'Max concurrent requests', '10')
+  .option('--dry-run', 'Preview without making changes')
+  .option('--autorename', 'Autorename if destination exists')
+  .option('--allow-shared-folder', 'Allow shared folders')
+  .action(async (opts) => {
+    let entries: Array<{ fromPath: string; toPath: string }>;
+    try {
+      entries = JSON.parse(opts.entries) as Array<{ fromPath: string; toPath: string }>;
+    } catch {
+      console.error(chalk.red('Error: Invalid JSON for --entries'));
+      process.exit(1);
+    }
+
+    if (entries.length === 0) {
+      console.error(chalk.red('Error: No entries provided'));
+      process.exit(1);
+    }
+
+    const client = getClient();
+    const concurrency = parseInt(opts.concurrency, 10);
+    console.log(chalk.blue(`Copying ${entries.length} item(s)...`));
+    if (opts.dryRun) console.log(chalk.yellow('(dry run)'));
+
+    const result = await client.bulk.copy({
+      entries,
+      concurrency,
+      dryRun: opts.dryRun,
+      autorename: opts.autorename,
+      allowSharedFolder: opts.allowSharedFolder,
+      onProgress: (current, total) => {
+        process.stdout.write(`\rProgress: ${current}/${total}`);
+      },
+      onError: (err, entry) => {
+        const e = entry as { fromPath: string };
+        console.error(`\n  Failed: ${e.fromPath} - ${err.message}`);
+      },
+    });
+
+    console.log();
+    console.log(chalk.green(`Done: ${result.success} copied, ${result.failed} failed`));
+    if (result.errors.length > 0) {
+      console.log(chalk.yellow('Errors:'));
+      for (const e of result.errors) {
+        console.log(`  - ${e.fromPath} -> ${e.toPath}: ${e.error}`);
+      }
+    }
+  });
+
+bulkCmd
+  .command('move')
+  .description('Bulk move files and folders')
+  .requiredOption('--entries <entries>', 'JSON array of {fromPath, toPath}')
+  .option('--concurrency <number>', 'Max concurrent requests', '10')
+  .option('--dry-run', 'Preview without making changes')
+  .option('--autorename', 'Autorename if destination exists')
+  .option('--allow-shared-folder', 'Allow shared folders')
+  .action(async (opts) => {
+    let entries: Array<{ fromPath: string; toPath: string }>;
+    try {
+      entries = JSON.parse(opts.entries) as Array<{ fromPath: string; toPath: string }>;
+    } catch {
+      console.error(chalk.red('Error: Invalid JSON for --entries'));
+      process.exit(1);
+    }
+
+    if (entries.length === 0) {
+      console.error(chalk.red('Error: No entries provided'));
+      process.exit(1);
+    }
+
+    const client = getClient();
+    const concurrency = parseInt(opts.concurrency, 10);
+    console.log(chalk.blue(`Moving ${entries.length} item(s)...`));
+    if (opts.dryRun) console.log(chalk.yellow('(dry run)'));
+
+    const result = await client.bulk.move({
+      entries,
+      concurrency,
+      dryRun: opts.dryRun,
+      autorename: opts.autorename,
+      allowSharedFolder: opts.allowSharedFolder,
+      onProgress: (current, total) => {
+        process.stdout.write(`\rProgress: ${current}/${total}`);
+      },
+      onError: (err, entry) => {
+        const e = entry as { fromPath: string };
+        console.error(`\n  Failed: ${e.fromPath} - ${err.message}`);
+      },
+    });
+
+    console.log();
+    console.log(chalk.green(`Done: ${result.success} moved, ${result.failed} failed`));
+    if (result.errors.length > 0) {
+      console.log(chalk.yellow('Errors:'));
+      for (const e of result.errors) {
+        console.log(`  - ${e.fromPath} -> ${e.toPath}: ${e.error}`);
+      }
+    }
+  });
+
 // Parse and execute
 program.parse();