@arela/uploader 1.1.4 → 1.2.0

package/src/commands/AgentInitCommand.js

@@ -0,0 +1,316 @@
+import { parse as parseEnv } from 'dotenv';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import {
+  DEFAULT_AGENT_LOG_PATH,
+  expandHome,
+} from '../services/ProfileManager.js';
+
+const TUNING_ENV_KEYS = [
+  'SCAN_EXCLUDE_PATTERNS',
+  'SCAN_BATCH_SIZE',
+  'PUSH_BATCH_SIZE',
+  'PUSH_UPLOAD_BATCH_SIZE',
+  'MAX_CONCURRENT_SOURCES',
+  'MAX_API_CONNECTIONS',
+  'API_CONNECTION_TIMEOUT',
+  'BATCH_DELAY',
+  'BATCH_SIZE',
+];
+
+/**
+ * Agent Init Command Handler
+ * Migration helper: reads the legacy per-folder .env files (one folder per
+ * RFC×source) and generates, WITHOUT calling any API:
+ *   - profiles.json      → minimal agent config (folders on the same tenant API
+ *                          collapse into one profile)
+ *   - seed-configs.json  → one pipeline_config payload per folder (the data that
+ *                          moves server-side: scan directories, tuning, schedule)
+ *   - seed-configs.sh    → ready-to-run curls to POST those payloads
+ *
+ * Tokens never leave the machine: everything is generated locally for review.
+ *
+ * Usage:
+ *   arela agent init --from ../ktj-cli-maya ../ktj-cli-matro --server-id PALCO-01
+ */
+export class AgentInitCommand {
+  /**
+   * Execute the init command
+   * @param {string[]} dirs - Folders containing legacy .env files
+   * @param {Object} options
+   * @param {string} options.serverId - Machine server id (default: ARELA_SERVER_ID from first .env, else hostname)
+   * @param {string} options.out - Output directory (default ~/.arela)
+   * @param {boolean} options.force - Overwrite an existing profiles.json
+   */
+  async execute(dirs, options = {}) {
+    if (!dirs || dirs.length === 0) {
+      throw new Error(
+        'At least one folder is required: arela agent init --from <dir1> <dir2> …',
+      );
+    }
+
+    const outDir = path.resolve(expandHome(options.out || '~/.arela'));
+    fs.mkdirSync(outDir, { recursive: true });
+
+    const profilesPath = path.join(outDir, 'profiles.json');
+    if (fs.existsSync(profilesPath) && !options.force) {
+      throw new Error(
+        `${profilesPath} already exists. Use --force to overwrite it.`,
+      );
+    }
+
+    const parsedFolders = [];
+    for (const dir of dirs) {
+      const resolvedDir = path.resolve(expandHome(dir));
+      const envPath = path.join(resolvedDir, '.env');
+      if (!fs.existsSync(envPath)) {
+        console.warn(`⚠️ Skipping ${resolvedDir}: no .env file found`);
+        continue;
+      }
+      const env = parseEnv(fs.readFileSync(envPath));
+      const clienteUrl = env.ARELA_API_CLIENTE_URL || env.ARELA_API_URL || null;
+      const clienteToken =
+        env.ARELA_API_CLIENTE_TOKEN || env.ARELA_API_TOKEN || null;
+      if (!clienteUrl || !clienteToken) {
+        console.warn(
+          `⚠️ Skipping ${resolvedDir}: no ARELA_API_CLIENTE_URL/_TOKEN (nor ARELA_API_URL/_TOKEN)`,
+        );
+        continue;
+      }
+      parsedFolders.push({ dir: resolvedDir, env, clienteUrl, clienteToken });
+    }
+
+    if (parsedFolders.length === 0) {
+      throw new Error('No usable .env files found in the given folders');
+    }
+
+    const serverId =
+      options.serverId ||
+      parsedFolders.find((f) => f.env.ARELA_SERVER_ID)?.env.ARELA_SERVER_ID ||
+      os.hostname();
+
+    // Group folders by tenant API URL → one profile per tenant
+    const profilesByUrl = new Map();
+    for (const folder of parsedFolders) {
+      const key = folder.clienteUrl.replace(/\/+$/, '').toLowerCase();
+      if (!profilesByUrl.has(key)) {
+        const profile = {
+          name: this.#deriveProfileName(folder, profilesByUrl),
+          url: folder.clienteUrl.replace(/\/+$/, ''),
+          token: folder.clienteToken,
+        };
+        const agenciaUrl = folder.env.ARELA_API_AGENCIA_URL;
+        if (
+          agenciaUrl &&
+          agenciaUrl.replace(/\/+$/, '').toLowerCase() !== key
+        ) {
+          profile.targets = {
+            agencia: {
+              baseUrl: agenciaUrl.replace(/\/+$/, ''),
+              token: folder.env.ARELA_API_AGENCIA_TOKEN || folder.clienteToken,
+            },
+          };
+        }
+        profilesByUrl.set(key, profile);
+      }
+      folder.profile = profilesByUrl.get(key);
+    }
+
+    const profilesJson = {
+      version: 1,
+      serverId,
+      pollIntervalMs: 5000,
+      logFile: DEFAULT_AGENT_LOG_PATH,
+      profiles: [...profilesByUrl.values()],
+    };
+
+    // One pipeline_config payload per folder×RFC
+    const seeds = [];
+    for (const folder of parsedFolders) {
+      const rfcs = this.#splitPipe(
+        folder.env.UPLOAD_RFCS || folder.env.PUSH_RFCS,
+      );
+      if (rfcs.length === 0) {
+        console.warn(
+          `⚠️ ${folder.dir}: no UPLOAD_RFCS/PUSH_RFCS — using placeholder RFC_PENDIENTE (edit before seeding)`,
+        );
+        rfcs.push('RFC_PENDIENTE');
+      }
+      for (const rfc of rfcs) {
+        seeds.push({
+          profile: folder.profile.name,
+          apiUrl: folder.profile.url,
+          sourceFolder: folder.dir,
+          config: this.#buildPipelineConfig(folder, rfc, serverId),
+        });
+      }
+    }
+
+    const seedsJsonPath = path.join(outDir, 'seed-configs.json');
+    const seedsShPath = path.join(outDir, 'seed-configs.sh');
+
+    fs.writeFileSync(profilesPath, JSON.stringify(profilesJson, null, 2));
+    try {
+      fs.chmodSync(profilesPath, 0o600);
+    } catch {
+      // chmod is best-effort on Windows
+    }
+    fs.writeFileSync(seedsJsonPath, JSON.stringify(seeds, null, 2));
+    fs.writeFileSync(seedsShPath, this.#buildSeedScript(seeds, profilesJson));
+    try {
+      fs.chmodSync(seedsShPath, 0o755);
+    } catch {
+      // chmod is best-effort on Windows
+    }
+
+    console.log(`\n✅ Generated from ${parsedFolders.length} folder(s):`);
+    console.log(
+      `   📄 ${profilesPath} (${profilesJson.profiles.length} profile(s))`,
+    );
+    console.log(
+      `   📄 ${seedsJsonPath} (${seeds.length} pipeline_config payload(s))`,
+    );
+    console.log(`   📄 ${seedsShPath}`);
+    console.log('\nNext steps:');
+    console.log('   1. Review both files (RFCs, scan directories, slugs)');
+    console.log(`   2. Seed the server configs: bash ${seedsShPath}`);
+    console.log('   3. Start the agent: arela agent');
+    console.log(
+      '   4. Once stable, enable scheduling per config (scheduleEnabled) and the PIPELINE_SCHEDULER cronjob per tenant',
+    );
+  }
+
+  /**
+   * Profile name from the API hostname's first label (ktj.api… → 'ktj'),
+   * falling back to the folder basename; deduped with numeric suffixes.
+   * @private
+   */
+  #deriveProfileName(folder, profilesByUrl) {
+    let base;
+    try {
+      base = new URL(folder.clienteUrl).hostname.split('.')[0];
+    } catch {
+      base = path.basename(folder.dir);
+    }
+    base = base.toLowerCase();
+    const taken = new Set(
+      [...profilesByUrl.values()].map((profile) => profile.name),
+    );
+    let name = base;
+    let suffix = 2;
+    while (taken.has(name)) {
+      name = `${base}-${suffix++}`;
+    }
+    return name;
+  }
+
+  /**
+   * Build the POST /api/uploader/pipeline/config payload for one folder×RFC
+   * @private
+   */
+  #buildPipelineConfig(folder, rfc, serverId) {
+    const { env, dir } = folder;
+
+    // Folder naming convention 'ktj-cli-maya' → source slug 'maya'
+    const basenameParts = path.basename(dir).split('-');
+    const agenciaSlug =
+      basenameParts.length > 1
+        ? basenameParts[basenameParts.length - 1]
+        : env.ARELA_COMPANY_SLUG || path.basename(dir);
+
+    const basePath = env.UPLOAD_BASE_PATH;
+    const sources = this.#splitPipe(env.UPLOAD_SOURCES);
+    let scanDirectories = [];
+    if (basePath && basePath !== '*' && sources.length > 0) {
+      const trimmedBase = basePath.replace(/[\\/]+$/, '');
+      const separator = trimmedBase.includes('\\') ? '\\' : '/';
+      scanDirectories = sources.map(
+        (source) => `${trimmedBase}${separator}${source}`,
+      );
+    } else if (basePath && basePath !== '*') {
+      scanDirectories = [basePath];
+    } else if (sources.length > 0) {
+      scanDirectories = sources;
+    }
+
+    const extraOptions = {};
+    if (env.ARELA_COMPANY_SLUG) {
+      extraOptions.companySlug = env.ARELA_COMPANY_SLUG;
+    }
+    if (env.SCAN_DIRECTORY_LEVEL !== undefined) {
+      extraOptions.directoryLevel = parseInt(env.SCAN_DIRECTORY_LEVEL) || 0;
+    }
+    for (const key of TUNING_ENV_KEYS) {
+      if (env[key] !== undefined) {
+        extraOptions[key] = env[key];
+      }
+    }
+
+    const crossTenant = !!folder.profile.targets?.agencia;
+
+    return {
+      rfc,
+      agenciaSlug: agenciaSlug.toLowerCase(),
+      displayName: `${rfc} — ${agenciaSlug}`,
+      scanDirectories,
+      ...(env.UPLOAD_FILE_EXTENSIONS && {
+        fileExtensions: env.UPLOAD_FILE_EXTENSIONS.split(',')
+          .map((extension) => extension.trim())
+          .filter(Boolean),
+      }),
+      ...(env.PUSH_BUCKET && { pushBucket: env.PUSH_BUCKET }),
+      folderStructure: env.PUSH_FOLDER_STRUCTURE || 'pedimento',
+      serverId,
+      sourceApi: crossTenant ? 'agencia' : 'cliente',
+      targetApi: 'cliente',
+      active: true,
+      extraOptions,
+      // Enable after the agent runs stable (see README)
+      scheduleEnabled: false,
+      scheduleIntervalHours: 24,
+      scheduleStartTime: '02:00',
+      scheduleJobType: 'full',
+    };
+  }
+
+  /**
+   * Build the curl script that seeds every pipeline_config
+   * @private
+   */
+  #buildSeedScript(seeds, profilesJson) {
+    const tokenByProfile = Object.fromEntries(
+      profilesJson.profiles.map((profile) => [profile.name, profile.token]),
+    );
+
+    let script = '#!/usr/bin/env bash\n';
+    script += '# Generated by `arela agent init` — review before running.\n';
+    script += '# Seeds one pipeline_config row per legacy folder×RFC.\n';
+    script += 'set -euo pipefail\n\n';
+
+    for (const seed of seeds) {
+      script += `# ${seed.config.rfc} / ${seed.config.agenciaSlug} (from ${seed.sourceFolder})\n`;
+      script += `curl -sS -X POST '${seed.apiUrl}/api/uploader/pipeline/config' \\\n`;
+      script += `  -H 'x-api-key: ${tokenByProfile[seed.profile]}' \\\n`;
+      script += `  -H 'Content-Type: application/json' \\\n`;
+      script += `  --data '${JSON.stringify(seed.config).replace(/'/g, `'\\''`)}'\n`;
+      script += 'echo\n\n';
+    }
+
+    return script;
+  }
+
+  /**
+   * Split a pipe-separated env value into trimmed parts
+   * @private
+   */
+  #splitPipe(value) {
+    return (value || '')
+      .split('|')
+      .map((part) => part.trim())
+      .filter(Boolean);
+  }
+}
+
+export default new AgentInitCommand();

package/src/commands/PollWorkerCommand.js

@@ -1,16 +1,15 @@
-import path from 'path';
-
 import logger from '../services/LoggingService.js';
 import { PipelineApiService } from '../services/PipelineApiService.js';
+import { PipelineJobRunner } from '../services/PipelineJobRunner.js';
 
 import appConfig from '../config/config.js';
 import ErrorHandler from '../errors/ErrorHandler.js';
-import { PathNormalizer } from '../utils/PathNormalizer.js';
 
 /**
  * Poll Worker Command Handler
  * Runs arela-uploader as an HTTP-polling worker, fetching jobs from the API.
  * Alternative to BullMQ/Redis-based worker for environments without Redis access.
+ * Job execution lives in PipelineJobRunner (shared with `arela agent`).
  *
  * Usage:
  *   arela worker --poll
@@ -27,6 +26,7 @@ export class PollWorkerCommand {
     this.isShuttingDown = false;
     this.currentJob = null;
     this.pipelineApi = null;
+    this.jobRunner = null;
     this.pollTimer = null;
   }
 
@@ -54,8 +54,9 @@ export class PollWorkerCommand {
 
       this.serverId = serverId;
 
-      // Initialize Pipeline API service
+      // Initialize Pipeline API service and the shared job runner
       this.pipelineApi = new PipelineApiService(apiTarget);
+      this.jobRunner = new PipelineJobRunner(this.pipelineApi, serverId);
 
       console.log('\n🔧 Starting Arela Poll Worker');
       console.log(`📡 API Target: ${apiTarget}`);
@@ -94,7 +95,12 @@ export class PollWorkerCommand {
         if (job && job.id) {
           console.log(`📥 Got job: ${job.type} for RFC ${job.rfc}`);
           logger.info(`📥 Got job: ${job.id} - ${job.type} for RFC ${job.rfc}`);
-          await this.#processJob(job);
+          this.currentJob = job;
+          try {
+            await this.jobRunner.processJob(job);
+          } finally {
+            this.currentJob = null;
+          }
         } else {
           // Only log to file, not console (too noisy)
           logger.debug('📭 No jobs available, waiting...');
@@ -111,323 +117,6 @@ export class PollWorkerCommand {
     }
   }
 
-  /**
-   * Process a job
-   * @private
-   */
-  async #processJob(job) {
-    this.currentJob = job;
-
-    // Start heartbeat timer to keep worker alive during long-running jobs
-    const heartbeatInterval = setInterval(async () => {
-      try {
-        await this.pipelineApi.sendHeartbeat(this.serverId, 'busy');
-        logger.debug(`💓 Heartbeat sent for ${this.serverId}`);
-      } catch {
-        // Non-critical — progress updates also refresh heartbeat
-      }
-    }, 20000);
-
-    try {
-      logger.info(`🔄 Processing ${job.type} job ${job.id}`);
-
-      // DEBUG: Delay to observe busy status in UI (remove in production)
-      const debugDelay = parseInt(process.env.DEBUG_JOB_DELAY) || 0;
-      if (debugDelay > 0) {
-        console.log(
-          `⏳ DEBUG: Waiting ${debugDelay / 1000}s before executing job...`,
-        );
-        await this.#sleep(debugDelay);
-      }
-
-      // Create progress callback that reports to API
-      const onProgress = async (percent, message) => {
-        await this.pipelineApi.updateProgress(
-          job.id,
-          percent,
-          message,
-          null,
-          job.type,
-        );
-      };
-
-      // Configure API targets for this job
-      this.#configureApiTargets(job);
-
-      // Execute the appropriate command
-      let result;
-      switch (job.type) {
-        case 'scan':
-          result = await this.#processScanJob(job, onProgress);
-          break;
-        case 'identify':
-          result = await this.#processIdentifyJob(job, onProgress);
-          break;
-        case 'propagate':
-          result = await this.#processPropagateJob(job, onProgress);
-          break;
-        case 'push':
-          result = await this.#processPushJob(job, onProgress);
-          break;
-        case 'full':
-          result = await this.#processFullPipeline(job, onProgress);
-          break;
-        default:
-          throw new Error(`Unknown job type: ${job.type}`);
-      }
-
-      // Mark job as completed
-      await this.pipelineApi.completeJob(job.id, result);
-      logger.success(`✅ Job ${job.id} completed successfully`);
-    } catch (error) {
-      logger.error(`❌ Job ${job.id} failed: ${error.message}`);
-      await this.pipelineApi.failJob(job.id, error.message);
-    } finally {
-      clearInterval(heartbeatInterval);
-      this.currentJob = null;
-      // Reset API configuration
-      this.#resetApiConfig();
-    }
-  }
-
-  /**
-   * Configure API targets for cross-tenant operations
-   * @private
-   */
-  #configureApiTargets(job) {
-    if (job.sourceApi && job.targetApi) {
-      appConfig.setCrossTenantTargets(job.sourceApi, job.targetApi);
-    } else {
-      appConfig.setApiTarget(job.sourceApi || 'agencia');
-    }
-  }
-
-  /**
-   * Reset API configuration after job
-   * @private
-   */
-  #resetApiConfig() {
-    // Clear cross-tenant mode
-    appConfig.api.sourceTarget = null;
-    appConfig.api.targetTarget = null;
-  }
-
-  /**
-   * Override scan configuration from job data
-   * @private
-   */
-  #overrideScanConfig(job) {
-    if (job.scanConfig) {
-      if (job.scanConfig.companySlug) {
-        process.env.ARELA_COMPANY_SLUG = job.scanConfig.companySlug;
-      }
-      if (job.scanConfig.serverId) {
-        process.env.ARELA_SERVER_ID = job.scanConfig.serverId;
-      }
-      if (job.scanConfig.basePath) {
-        process.env.UPLOAD_BASE_PATH = job.scanConfig.basePath;
-        process.env.ARELA_BASE_PATH_LABEL = job.scanConfig.basePath;
-      }
-      if (job.scanConfig.directoryLevel !== undefined) {
-        process.env.SCAN_DIRECTORY_LEVEL = String(
-          job.scanConfig.directoryLevel,
-        );
-      }
-    }
-
-    // Override scan directories if provided
-    if (job.scanDirectories && job.scanDirectories.length > 0) {
-      const allAbsolute = job.scanDirectories.every((d) =>
-        PathNormalizer.isAbsolutePath(d),
-      );
-
-      if (allAbsolute) {
-        const ancestor = this.#commonAncestor(job.scanDirectories);
-        // Check if ancestor is meaningful (not just root or a drive letter)
-        const isUseful =
-          ancestor.length > 1 && !/^[a-zA-Z]:[/\\]?$/.test(ancestor);
-
-        if (isUseful) {
-          // Common ancestor found — set as base path, make sources relative
-          process.env.UPLOAD_BASE_PATH = ancestor;
-          process.env.ARELA_BASE_PATH_LABEL = ancestor;
-          const relativeSources = job.scanDirectories.map(
-            (d) => path.relative(ancestor, d) || '.',
-          );
-          process.env.UPLOAD_SOURCES = relativeSources.join('|');
-        } else {
-          // Cross-drive or no common ancestor — wildcard base, absolute sources
-          process.env.UPLOAD_BASE_PATH = '*';
-          process.env.ARELA_BASE_PATH_LABEL = '*';
-          process.env.UPLOAD_SOURCES = job.scanDirectories.join('|');
-        }
-      } else {
-        process.env.UPLOAD_SOURCES = job.scanDirectories.join('|');
-      }
-    }
-
-    // Override file extensions if provided
-    if (job.fileExtensions && job.fileExtensions.length > 0) {
-      process.env.UPLOAD_FILE_EXTENSIONS = job.fileExtensions.join(',');
-    }
-
-    // Reload cached config from the updated env vars
-    appConfig.reloadScanConfig();
-  }
-
-  /**
-   * Compute the longest common ancestor directory of a list of absolute paths.
-   * Uses '/' as separator (PathNormalizer normalizes Windows \\ to /).
-   * @param {string[]} paths
-   * @returns {string}
-   */
-  #commonAncestor(paths) {
-    if (paths.length === 0) return '/';
-    if (paths.length === 1) return paths[0];
-
-    // Normalize separators so O:\exp\... becomes O:/exp/...
-    const normalized = paths.map((p) => PathNormalizer.normalizeSeparators(p));
-    const split = normalized.map((p) => p.split('/').filter(Boolean));
-    const minLen = Math.min(...split.map((s) => s.length));
-    const common = [];
-
-    for (let i = 0; i < minLen; i++) {
-      const seg = split[0][i];
-      if (split.every((s) => s[i] === seg)) {
-        common.push(seg);
-      } else {
-        break;
-      }
-    }
-
-    // Preserve drive letter format (e.g., 'O:' → 'O:/')
-    if (common.length > 0 && /^[a-zA-Z]:$/.test(common[0])) {
-      return common[0] + '/' + common.slice(1).join('/');
-    }
-    return '/' + common.join('/');
-  }
-
-  /**
-   * Process a scan job
-   * @private
-   */
-  async #processScanJob(job, onProgress) {
-    const { ScanCommand } = await import('./ScanCommand.js');
-    const scanCommand = new ScanCommand();
-
-    this.#overrideScanConfig(job);
-
-    const options = {
-      api: job.sourceApi || 'agencia',
-      countFirst: false,
-      stream: true,
-      onProgress,
-    };
-
-    return scanCommand.execute(options);
-  }
-
-  /**
-   * Process an identify job
-   * @private
-   */
-  async #processIdentifyJob(job, onProgress) {
-    const { IdentifyCommand } = await import('./IdentifyCommand.js');
-    const identifyCommand = new IdentifyCommand();
-
-    this.#overrideScanConfig(job);
-
-    const options = {
-      api: job.sourceApi || 'agencia',
-      batchSize: 100,
-      showStats: false,
-      onProgress,
-      ...(job.fileId && { fileId: job.fileId }),
-      ...(job.table && { table: job.table }),
-    };
-
-    return identifyCommand.execute(options);
-  }
-
-  /**
-   * Process a propagate job
-   * @private
-   */
-  async #processPropagateJob(job, onProgress) {
-    const { PropagateCommand } = await import('./PropagateCommand.js');
-
-    this.#overrideScanConfig(job);
-
-    const options = {
-      api: job.sourceApi || 'agencia',
-      batchSize: 50,
-      showStats: false,
-      onProgress,
-    };
-
-    const propagateCommand = new PropagateCommand(options);
-    return propagateCommand.execute();
-  }
-
-  /**
-   * Process a push job
-   * @private
-   */
-  async #processPushJob(job, onProgress) {
-    const { PushCommand } = await import('./PushCommand.js');
-    const pushCommand = new PushCommand();
-
-    this.#overrideScanConfig(job);
-
-    const options = {
-      scanApi: job.sourceApi || 'agencia',
-      pushApi: job.targetApi || 'cliente',
-      rfcs: [job.rfc],
-      batchSize: 100,
-      uploadBatchSize: 10,
-      folderStructure: job.folderStructure || 'pedimento',
-      autoOrganize: true,
-      showStats: false,
-      onProgress,
-    };
-
-    return pushCommand.execute(options);
-  }
-
-  /**
-   * Process full pipeline (scan → identify → propagate → push)
-   * @private
-   */
-  async #processFullPipeline(job, onProgress) {
-    const results = {};
-
-    // Step 1: Scan (0-25%)
-    logger.info('📁 Step 1/4: Scanning files...');
-    const wrappedProgress1 = (pct, msg) =>
-      onProgress(pct * 0.25, `[Scan] ${msg}`);
-    results.scan = await this.#processScanJob(job, wrappedProgress1);
-
-    // Step 2: Identify (25-50%)
-    logger.info('🔍 Step 2/4: Identifying documents...');
-    const wrappedProgress2 = (pct, msg) =>
-      onProgress(25 + pct * 0.25, `[Identify] ${msg}`);
-    results.identify = await this.#processIdentifyJob(job, wrappedProgress2);
-
-    // Step 3: Propagate (50-75%)
-    logger.info('🔄 Step 3/4: Propagating paths...');
-    const wrappedProgress3 = (pct, msg) =>
-      onProgress(50 + pct * 0.25, `[Propagate] ${msg}`);
-    results.propagate = await this.#processPropagateJob(job, wrappedProgress3);
-
-    // Step 4: Push (75-100%)
-    logger.info('📤 Step 4/4: Pushing to storage...');
-    const wrappedProgress4 = (pct, msg) =>
-      onProgress(75 + pct * 0.25, `[Push] ${msg}`);
-    results.push = await this.#processPushJob(job, wrappedProgress4);
-
-    return results;
-  }
-
   /**
    * Sleep for specified milliseconds
    * @private