@arela/uploader 1.1.4 → 1.2.0

package/.claude/worktrees/agent-multi-profile/src/commands/AgentCommand.js

@@ -0,0 +1,229 @@
+import logger from '../services/LoggingService.js';
+import { PipelineApiService } from '../services/PipelineApiService.js';
+import { PipelineJobRunner } from '../services/PipelineJobRunner.js';
+import {
+  DEFAULT_PROFILES_PATH,
+  ProfileManager,
+} from '../services/ProfileManager.js';
+
+import appConfig from '../config/config.js';
+
+const BACKOFF_BASE_MS = 30_000;
+const BACKOFF_MAX_MS = 600_000;
+const SHUTDOWN_JOB_TIMEOUT_MS = 300_000;
+
+/**
+ * Agent Command Handler
+ * Multi-profile polling agent: ONE process (one terminal) replaces the N
+ * `arela worker --poll` terminals (one per RFC×source folder with its own .env).
+ * Profiles (tenant API url + token) come from profiles.json; everything else
+ * (scan directories, tuning, schedule) lives server-side in pipeline_config.
+ *
+ * Jobs are processed ONE AT A TIME globally: appConfig is a singleton and the
+ * job runner mutates process.env per job, so running two jobs concurrently
+ * would corrupt each other's configuration. If parallelism is ever needed,
+ * spawn child processes — never threads/promises inside this process.
+ *
+ * Usage:
+ *   arela agent
+ *   arela agent --config ./profiles.json --profile ktj,cem
+ */
+export class AgentCommand {
+  constructor() {
+    this.isShuttingDown = false;
+    this.activeJobPromise = null;
+    this.pollTimer = null;
+  }
+
+  /**
+   * Execute the agent command
+   * @param {Object} options - Command options
+   * @param {string} options.config - Path to profiles.json
+   * @param {string} options.interval - Base poll interval per round (ms)
+   * @param {string} options.profile - Comma-separated subset of profiles to run
+   */
+  async execute(options = {}) {
+    const agentConfig = ProfileManager.loadProfiles(
+      options.config || DEFAULT_PROFILES_PATH,
+    );
+
+    let profiles = agentConfig.profiles;
+    if (options.profile) {
+      const requested = options.profile
+        .split(',')
+        .map((name) => name.trim().toLowerCase())
+        .filter(Boolean);
+      const known = new Set(profiles.map((p) => p.name));
+      const unknown = requested.filter((name) => !known.has(name));
+      if (unknown.length > 0) {
+        throw new Error(
+          `Unknown profile(s): ${unknown.join(', ')}. Available: ${[...known].join(', ')}`,
+        );
+      }
+      profiles = profiles.filter((p) => requested.includes(p.name));
+    }
+
+    const interval =
+      parseInt(options.interval) > 0
+        ? parseInt(options.interval)
+        : agentConfig.pollIntervalMs;
+
+    logger.setLogFilePath(agentConfig.logFile);
+
+    logger.info('🤖 Starting Arela Agent (multi-profile poll worker)');
+    logger.info(`🖥️  Server ID: ${agentConfig.serverId}`);
+    logger.info(`⏱️  Poll Interval: ${interval}ms`);
+    logger.info(`📒 Log file: ${agentConfig.logFile}`);
+
+    // One API client + job runner per profile, built once. PipelineApiService
+    // copies baseUrl/token at construction, so each instance stays bound to its
+    // profile even while applyProfile() reconfigures the singleton for others.
+    for (const profile of profiles) {
+      appConfig.applyProfile(profile);
+      profile.api = new PipelineApiService(profile.name);
+      profile.runner = new PipelineJobRunner(profile.api, agentConfig.serverId);
+      profile.failures = 0;
+      profile.backoffUntil = 0;
+      logger.info(`📡 Profile '${profile.name}' → ${profile.url}`);
+    }
+
+    this.#setupShutdownHandlers(profiles);
+
+    logger.success('Agent is running. Press Ctrl+C to stop.');
+
+    await this.#runLoop(profiles, agentConfig.serverId, interval);
+  }
+
+  /**
+   * Round-robin polling loop over all profiles
+   * @private
+   */
+  async #runLoop(profiles, serverId, interval) {
+    let round = 0;
+
+    while (!this.isShuttingDown) {
+      let gotAnyJob = false;
+      let polled = 0;
+      let jobs = 0;
+      round += 1;
+
+      for (const profile of profiles) {
+        if (this.isShuttingDown) break;
+        if (Date.now() < profile.backoffUntil) continue;
+
+        try {
+          // Reconfigure the singleton for THIS profile before polling/processing
+          appConfig.applyProfile(profile);
+          logger.setContext(profile.name);
+
+          const job = await profile.api.getNextJob(serverId, {
+            throwOnError: true,
+          });
+          profile.failures = 0;
+          profile.backoffUntil = 0;
+          polled += 1;
+
+          if (job && job.id) {
+            gotAnyJob = true;
+            jobs += 1;
+            logger.info(
+              `📥 Got job: ${job.id} - ${job.type} for RFC ${job.rfc}`,
+            );
+            this.activeJobPromise = profile.runner.processJob(job);
+            await this.activeJobPromise;
+            this.activeJobPromise = null;
+          } else {
+            logger.debug('📭 No jobs available');
+          }
+        } catch (error) {
+          // A failing profile backs off exponentially but never kills the loop
+          profile.failures += 1;
+          const backoffMs = Math.min(
+            BACKOFF_BASE_MS * 2 ** (profile.failures - 1),
+            BACKOFF_MAX_MS,
+          );
+          profile.backoffUntil = Date.now() + backoffMs;
+          logger.error(
+            `Poll failed (attempt ${profile.failures}): ${error.message} — backing off ${Math.round(backoffMs / 1000)}s`,
+          );
+        } finally {
+          logger.setContext(null);
+        }
+      }
+
+      // Heartbeat line: first round always, then every ~5 min of idle rounds,
+      // so a quiet log is distinguishable from a stalled one
+      const summaryEvery = Math.max(1, Math.round(300_000 / interval));
+      if (round === 1 || jobs > 0 || round % summaryEvery === 0) {
+        const inBackoff = profiles.filter(
+          (p) => Date.now() < p.backoffUntil,
+        ).length;
+        logger.info(
+          `🔁 Round ${round}: polled ${polled}/${profiles.length} profiles, ${jobs} job(s), ${inBackoff} in backoff`,
+        );
+      }
+
+      // One sleep per idle round (not one per profile)
+      if (!gotAnyJob && !this.isShuttingDown) {
+        await this.#sleep(interval);
+      }
+    }
+  }
+
+  /**
+   * Sleep for specified milliseconds
+   * @private
+   */
+  #sleep(ms) {
+    return new Promise((resolve) => {
+      this.pollTimer = setTimeout(resolve, ms);
+    });
+  }
+
+  /**
+   * Setup graceful shutdown handlers
+   * @private
+   */
+  #setupShutdownHandlers(profiles) {
+    const shutdown = async (signal) => {
+      if (this.isShuttingDown) return;
+      this.isShuttingDown = true;
+
+      logger.setContext(null);
+      logger.info(`\n👋 Received ${signal}. Shutting down agent...`);
+
+      if (this.pollTimer) {
+        clearTimeout(this.pollTimer);
+      }
+
+      // Wait for the in-flight job so it ends COMPLETED/FAILED, never orphaned RUNNING
+      if (this.activeJobPromise) {
+        logger.info('⏳ Waiting for the current job to finish...');
+        await Promise.race([
+          this.activeJobPromise,
+          new Promise((resolve) =>
+            setTimeout(resolve, SHUTDOWN_JOB_TIMEOUT_MS),
+          ),
+        ]);
+      }
+
+      for (const profile of profiles) {
+        profile.api?.destroy();
+      }
+
+      logger.info('✅ Agent stopped gracefully');
+      logger.flush();
+      process.exit(0);
+    };
+
+    // The global SIGINT/SIGTERM handlers (index.js and LoggingService) call
+    // process.exit(0) immediately, which would kill the in-flight job mid-write.
+    // Agent mode owns shutdown: replace them with the graceful version.
+    process.removeAllListeners('SIGINT');
+    process.removeAllListeners('SIGTERM');
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+  }
+}
+
+export default new AgentCommand();

package/.claude/worktrees/agent-multi-profile/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/.claude/worktrees/agent-multi-profile/src/commands/DatastageCommand.js

@@ -0,0 +1,164 @@
+import fs from 'fs';
+import path from 'path';
+
+import { DatastageApiService } from '../services/DatastageApiService.js';
+import logger from '../services/LoggingService.js';
+
+import appConfig from '../config/config.js';
+import ErrorHandler from '../errors/ErrorHandler.js';
+
+/**
+ * Datastage Command Handler
+ * Uploads monthly Datastage *.zip files from a directory to the API.
+ * Sequential, idempotent via the cli `datastage_uploads` tracking table.
+ */
+export class DatastageCommand {
+  constructor() {
+    this.errorHandler = new ErrorHandler(logger);
+  }
+
+  /**
+   * @param {Object} options
+   * @param {string} options.dir - directory containing *.zip files (required)
+   * @param {string} [options.api] - 'default'|'agencia'|'cliente'
+   * @param {boolean} [options.retryFailed] - re-attempt files in 'failed' status
+   * @param {boolean} [options.showStats] - print final stats from API
+   */
+  async execute(options = {}) {
+    const startTime = Date.now();
+
+    if (!options.dir) {
+      throw new Error('--dir <path> is required');
+    }
+    const sourceDirectory = path.resolve(options.dir);
+    if (!fs.existsSync(sourceDirectory)) {
+      throw new Error(`Directory not found: ${sourceDirectory}`);
+    }
+    const dirStat = fs.statSync(sourceDirectory);
+    if (!dirStat.isDirectory()) {
+      throw new Error(`Not a directory: ${sourceDirectory}`);
+    }
+
+    const apiTarget = options.api || 'default';
+    const api = new DatastageApiService(apiTarget);
+
+    logger.info('📦 Starting arela datastage command');
+    logger.info(`🎯 API Target: ${apiTarget}`);
+    logger.info(`📂 Source: ${sourceDirectory}`);
+
+    // 1. Enumerate *.zip in root directory (non-recursive)
+    const entries = fs.readdirSync(sourceDirectory, { withFileTypes: true });
+    const zipFiles = entries
+      .filter((e) => e.isFile() && /\.zip$/i.test(e.name))
+      .map((e) => path.join(sourceDirectory, e.name));
+
+    if (zipFiles.length === 0) {
+      logger.warn('No *.zip files found in directory. Nothing to do.');
+      return { uploaded: 0, failed: 0, skipped: 0 };
+    }
+    logger.info(`🗂  Found ${zipFiles.length} zip file(s)`);
+
+    // 2. Register each file (idempotent upsert)
+    logger.info('📝 Registering files...');
+    for (const zipPath of zipFiles) {
+      const stats = fs.statSync(zipPath);
+      try {
+        await api.registerUpload({
+          absolutePath: zipPath,
+          fileName: path.basename(zipPath),
+          sizeBytes: stats.size,
+          fileModifiedAt: stats.mtime.toISOString(),
+          sourceDirectory,
+        });
+      } catch (err) {
+        logger.error(
+          `  ✗ register failed for ${path.basename(zipPath)}: ${err.message}`,
+        );
+        throw err;
+      }
+    }
+
+    // 3. Fetch pending list scoped to this directory
+    const pending = await api.getPending(sourceDirectory);
+    const pendingPaths = new Set(pending.map((p) => p.absolutePath));
+
+    const alreadyUploaded = zipFiles.length - pendingPaths.size;
+    if (alreadyUploaded > 0) {
+      logger.info(`⏭  Skipping ${alreadyUploaded} already uploaded file(s)`);
+    }
+
+    if (pending.length === 0) {
+      logger.success('✅ All files already uploaded. Nothing to do.');
+      if (options.showStats) {
+        const s = await api.getStats(sourceDirectory);
+        logger.info(`📊 Stats: ${JSON.stringify(s)}`);
+      }
+      return { uploaded: 0, failed: 0, skipped: alreadyUploaded };
+    }
+
+    // 4. Sequential upload loop
+    logger.info(`🚀 Uploading ${pending.length} file(s) sequentially...`);
+    let uploaded = 0;
+    let failed = 0;
+
+    for (let i = 0; i < pending.length; i++) {
+      const row = pending[i];
+      const localPath = row.absolutePath;
+      const label = `[${i + 1}/${pending.length}] ${row.fileName}`;
+
+      if (!fs.existsSync(localPath)) {
+        const err = `File missing on disk: ${localPath}`;
+        logger.error(`✗ ${label}: ${err}`);
+        try {
+          await api.markFailed(row.id, err);
+        } catch (e) {
+          logger.error(`  mark-failed error: ${e.message}`);
+        }
+        failed++;
+        continue;
+      }
+
+      try {
+        logger.info(`⬆  ${label}: uploading...`);
+        const result = await api.uploadZip(localPath);
+        const datastageId = result?.id || result?.data?.id;
+        const folio = result?.folio || result?.data?.folio;
+        if (!datastageId) {
+          throw new Error(
+            'API returned no datastage id in response: ' +
+              JSON.stringify(result).slice(0, 300),
+          );
+        }
+        await api.markUploaded(row.id, { datastageId, folio });
+        logger.success(
+          `✓ ${label}: folio=${folio || 'n/a'} datastageId=${datastageId}`,
+        );
+        uploaded++;
+      } catch (err) {
+        logger.error(`✗ ${label}: ${err.message}`);
+        try {
+          await api.markFailed(row.id, err.message);
+        } catch (e) {
+          logger.error(`  mark-failed error: ${e.message}`);
+        }
+        failed++;
+      }
+    }
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    logger.info('—'.repeat(60));
+    logger.info(
+      `Done in ${elapsed}s — uploaded=${uploaded} failed=${failed} skipped=${alreadyUploaded}`,
+    );
+
+    if (options.showStats) {
+      const s = await api.getStats(sourceDirectory);
+      logger.info(`📊 Final stats: ${JSON.stringify(s)}`);
+    }
+
+    return { uploaded, failed, skipped: alreadyUploaded };
+  }
+}
+
+const datastageCommand = new DatastageCommand();
+export default datastageCommand;