@teambit/ripple 0.0.0-00ad897e742f2a0c76f3f48e46d69e13bfc07a2e

package/dist/ripple.cmd.js

@@ -0,0 +1,635 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RippleStopCmd = exports.RippleRetryCmd = exports.RippleLogCmd = exports.RippleListCmd = exports.RippleErrorsCmd = exports.RippleCmd = void 0;
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _cliTable() {
+  const data = _interopRequireDefault(require("cli-table"));
+  _cliTable = function () {
+    return data;
+  };
+  return data;
+}
+function _rippleUtils() {
+  const data = require("./ripple-utils");
+  _rippleUtils = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * a last-export entry matches the target context when its saved lane equals the current lane
+ * (or both are undefined / "main"). this prevents using a stale last-export from a different lane
+ * after the user has switched lanes.
+ */
+function lastExportMatchesTarget(last, targetLane) {
+  const lastLaneStr = last.lane ? `${last.lane.scope}/${last.lane.name}` : undefined;
+  return lastLaneStr === targetLane;
+}
+function lastExportHeader(lastExport, job) {
+  const age = (0, _rippleUtils().formatAge)(lastExport.timestamp);
+  const target = lastExport.lane ? `lane "${lastExport.lane.scope}/${lastExport.lane.name}"` : 'main';
+  const phase = job.status?.phase?.toUpperCase();
+  if (phase === 'SUCCESS') {
+    return _chalk().default.green(`✓ Your last export (${age}) to ${target} succeeded.`);
+  }
+  if ((0, _rippleUtils().isFailedPhase)(phase)) {
+    return _chalk().default.red(`✗ Your last export (${age}) to ${target} failed.`);
+  }
+  return _chalk().default.gray(`Your last export (${age}) to ${target} — status: ${(0, _rippleUtils().colorPhase)(phase)}.`);
+}
+class RippleCmd {
+  constructor() {
+    _defineProperty(this, "name", 'ripple <sub-command>');
+    _defineProperty(this, "description", 'manage Ripple CI jobs on bit.cloud');
+    _defineProperty(this, "extendedDescription", 'view, retry, and manage Ripple CI jobs that build your components in the cloud after export.');
+    _defineProperty(this, "group", 'collaborate');
+    _defineProperty(this, "skipWorkspace", true);
+    _defineProperty(this, "remoteOp", true);
+    _defineProperty(this, "options", []);
+    _defineProperty(this, "commands", []);
+  }
+  async report() {
+    return {
+      code: 1,
+      data: '[ripple] please specify a subcommand. See --help for available commands.'
+    };
+  }
+}
+exports.RippleCmd = RippleCmd;
+class RippleListCmd {
+  constructor(ripple) {
+    this.ripple = ripple;
+    _defineProperty(this, "name", 'list');
+    _defineProperty(this, "description", 'list recent Ripple CI jobs (filtered by workspace owner by default)');
+    _defineProperty(this, "skipWorkspace", true);
+    _defineProperty(this, "remoteOp", true);
+    _defineProperty(this, "alias", '');
+    _defineProperty(this, "options", [['', 'all', 'show jobs from all owners, not just the workspace owner'], ['o', 'owner <owner>', 'filter by organization (default: detected from workspace defaultScope)'], ['s', 'scope <scope>', 'filter by scope (e.g. "teambit.cloud")'], ['', 'lane <lane>', 'filter by lane ID (e.g. "scope/lane-name")'], ['u', 'user <user>', 'filter by username'], ['', 'status <status>', 'filter by status (e.g. SUCCESS, FAILURE, RUNNING)'], ['l', 'limit <limit>', 'max number of jobs to show (default: 20)'], ['j', 'json', 'return the output as JSON']]);
+  }
+  async report(args, flags) {
+    const {
+      jobs,
+      ownerUsed
+    } = await this.getFilteredJobs(flags);
+    if (!jobs || jobs.length === 0) {
+      let hint = '';
+      if (flags.lane) hint = ` for lane "${flags.lane}"`;else if (flags.scope) hint = ` for scope "${flags.scope}"`;else if (ownerUsed) hint = ` for owner "${ownerUsed}"`;
+      const tip = ownerUsed ? ' Use --all to see jobs from all owners.' : '';
+      return _chalk().default.yellow(`No Ripple CI jobs found${hint}.${tip}`);
+    }
+    const table = new (_cliTable().default)({
+      head: [_chalk().default.cyan('Job ID'), _chalk().default.cyan('Name'), _chalk().default.cyan('Scope'), _chalk().default.cyan('Status'), _chalk().default.cyan('User'), _chalk().default.cyan('Started'), _chalk().default.cyan('Duration')],
+      chars: {
+        top: '',
+        'top-mid': '',
+        'top-left': '',
+        'top-right': '',
+        bottom: '',
+        'bottom-mid': '',
+        'bottom-left': '',
+        'bottom-right': '',
+        left: '',
+        'left-mid': '',
+        mid: '',
+        'mid-mid': '',
+        right: '',
+        'right-mid': '',
+        middle: ' '
+      },
+      style: {
+        'padding-left': 1,
+        'padding-right': 1
+      }
+    });
+    for (const job of jobs) {
+      table.push([job.id, truncate(job.name || '-', 40), getScopeFromLaneId(job.laneId), (0, _rippleUtils().colorPhase)(job.status?.phase), job.user?.username || '-', formatDate(job.status?.startedAt), formatDuration(job.status?.startedAt, job.status?.finishedAt)]);
+    }
+    const header = ownerUsed ? _chalk().default.gray(`showing jobs for owner "${ownerUsed}" (use --all for all jobs)`) : '';
+    return [header, table.toString()].filter(Boolean).join('\n');
+  }
+  async json(args, flags) {
+    const {
+      jobs
+    } = await this.getFilteredJobs(flags);
+    return {
+      jobs: jobs || []
+    };
+  }
+  async getFilteredJobs(flags) {
+    const requestedLimit = flags.limit ? parseInt(flags.limit, 10) : 20;
+    if (!Number.isFinite(requestedLimit) || requestedLimit < 1) {
+      throw new Error(`Invalid --limit value "${flags.limit}". Expected a positive integer.`);
+    }
+
+    // build server-side filters
+    const filters = {};
+
+    // determine owner for default filtering (skip when --lane or --scope is given explicitly)
+    let ownerUsed;
+    if (!flags.all && !flags.lane && !flags.scope) {
+      ownerUsed = flags.owner || this.ripple.getDefaultOwner();
+    } else if (flags.owner) {
+      ownerUsed = flags.owner;
+    }
+    if (ownerUsed) filters.owners = [ownerUsed];
+    if (flags.lane) filters.lanes = [flags.lane];
+    if (flags.scope) filters.scopes = [flags.scope];
+    if (flags.status) filters.status = flags.status.toUpperCase();
+
+    // user filter is not supported server-side, so overfetch if needed
+    const needsClientFilter = !!flags.user;
+    const fetchLimit = needsClientFilter ? Math.max(requestedLimit * 5, 100) : requestedLimit;
+    let jobs = await this.ripple.listJobs({
+      filters,
+      limit: fetchLimit
+    });
+
+    // apply client-side filters for fields not supported by FilterOptions
+    if (flags.user) {
+      const userFilter = flags.user.toLowerCase();
+      jobs = jobs.filter(j => j.user?.username?.toLowerCase().includes(userFilter));
+    }
+    jobs = jobs.slice(0, requestedLimit);
+    return {
+      jobs,
+      ownerUsed
+    };
+  }
+}
+exports.RippleListCmd = RippleListCmd;
+class RippleLogCmd {
+  constructor(ripple) {
+    this.ripple = ripple;
+    _defineProperty(this, "name", 'log [job-id]');
+    _defineProperty(this, "description", 'show job details and component build task summaries (auto-detects current lane, or your last export when on main)');
+    _defineProperty(this, "skipWorkspace", true);
+    _defineProperty(this, "remoteOp", true);
+    _defineProperty(this, "alias", '');
+    _defineProperty(this, "options", [['', 'lane <lane>', 'lane ID to find the latest job for (default: detected from .bitmap)'], ['c', 'component <component>', 'show build tasks for a specific component (full component ID)'], ['j', 'json', 'return the output as JSON']]);
+    _defineProperty(this, "arguments", [{
+      name: 'job-id',
+      description: 'the Ripple CI job ID (optional — auto-detects from current lane, or your last export when on main)'
+    }]);
+  }
+  async resolveJob(jobId, flags) {
+    const resolved = await (0, _rippleUtils().resolveJobId)(this.ripple, jobId, flags);
+    if ('error' in resolved) return {
+      job: null,
+      error: resolved.error,
+      source: undefined,
+      lastExport: undefined
+    };
+    // when resolved from last-export, the resolver already fetched the full job — reuse it
+    const job = resolved.job ?? (await this.ripple.getJob(resolved.id));
+    return {
+      job,
+      error: undefined,
+      source: resolved.source,
+      lastExport: resolved.lastExport
+    };
+  }
+  async report([jobId], flags) {
+    const {
+      job,
+      error,
+      source,
+      lastExport
+    } = await this.resolveJob(jobId, flags);
+    if (!job) {
+      if (jobId) return _chalk().default.red(`Job "${jobId}" not found.`);
+      return _chalk().default.red(error || 'Could not find a Ripple CI job.');
+    }
+    const lines = [];
+    if (source === 'last-export' && lastExport) {
+      lines.push(lastExportHeader(lastExport, job));
+      lines.push('');
+    }
+    lines.push(_chalk().default.bold('Job Details'));
+    lines.push(`  ${_chalk().default.cyan('ID:')}       ${job.id}`);
+    if (job.name) lines.push(`  ${_chalk().default.cyan('Name:')}     ${job.name}`);
+    lines.push(`  ${_chalk().default.cyan('Status:')}   ${(0, _rippleUtils().colorPhase)(job.status?.phase)}`);
+    if (job.laneId) lines.push(`  ${_chalk().default.cyan('Lane:')}     ${job.laneId}`);
+    if (job.user?.displayName) lines.push(`  ${_chalk().default.cyan('User:')}     ${job.user.displayName} (${job.user.username})`);
+    if (job.status?.startedAt) lines.push(`  ${_chalk().default.cyan('Started:')}  ${new Date(job.status.startedAt).toLocaleString()}`);
+    if (job.status?.finishedAt) lines.push(`  ${_chalk().default.cyan('Finished:')} ${new Date(job.status.finishedAt).toLocaleString()}`);
+    const jobUrl = this.ripple.getJobUrl(job);
+    lines.push(`  ${_chalk().default.cyan('URL:')}      ${jobUrl}`);
+    if (flags.component) {
+      await this.appendComponentDetail(lines, job.id, flags.component);
+    } else {
+      this.appendComponentList(lines, job);
+    }
+    return lines.join('\n');
+  }
+  async appendComponentDetail(lines, jobId, componentId) {
+    const summary = await this.ripple.getComponentBuildSummary(jobId, componentId);
+    if (!summary) {
+      lines.push('');
+      lines.push(_chalk().default.yellow(`No build summary found for component "${componentId}" in this job.`));
+      return;
+    }
+    lines.push('');
+    lines.push(_chalk().default.bold(`Build Tasks for ${summary.name || componentId}`));
+    if (!summary.tasks || summary.tasks.length === 0) {
+      lines.push(_chalk().default.gray('  No build tasks found.'));
+      return;
+    }
+    const table = new (_cliTable().default)({
+      head: [_chalk().default.cyan('Task'), _chalk().default.cyan('Status'), _chalk().default.cyan('Started'), _chalk().default.cyan('Warnings')],
+      chars: {
+        top: '',
+        'top-mid': '',
+        'top-left': '',
+        'top-right': '',
+        bottom: '',
+        'bottom-mid': '',
+        'bottom-left': '',
+        'bottom-right': '',
+        left: '',
+        'left-mid': '',
+        mid: '',
+        'mid-mid': '',
+        right: '',
+        'right-mid': '',
+        middle: ' '
+      },
+      style: {
+        'padding-left': 1,
+        'padding-right': 1
+      }
+    });
+    for (const task of summary.tasks) {
+      table.push([task.name || '-', (0, _rippleUtils().colorPhase)(task.status?.status), task.startTime ? new Date(task.startTime).toLocaleString() : '-', task.status?.warnings ? _chalk().default.yellow(String(task.status.warnings)) : '0']);
+    }
+    lines.push(table.toString());
+  }
+  appendComponentList(lines, job) {
+    const ciNodes = this.ripple.getCiGraphNodes(job);
+    if (ciNodes.length === 0) return;
+    const totalComponents = ciNodes.reduce((sum, n) => sum + n.componentIds.length, 0);
+    lines.push('');
+    lines.push(_chalk().default.bold(`Components (${totalComponents})`));
+    lines.push(_chalk().default.gray('  Use --component <id> to see build tasks for a specific component'));
+    let shown = 0;
+    for (const node of ciNodes) {
+      if (shown >= 30) {
+        lines.push(_chalk().default.gray(`  ... and ${totalComponents - shown} more`));
+        break;
+      }
+      for (const compId of node.componentIds) {
+        if (shown >= 30) break;
+        const icon = (0, _rippleUtils().isFailedPhase)(node.phase) ? _chalk().default.red('✗') : node.phase === 'SUCCESS' ? _chalk().default.green('✓') : _chalk().default.yellow('○');
+        lines.push(`  ${icon} ${compId}`);
+        shown++;
+      }
+    }
+  }
+  async json([jobId], flags) {
+    const {
+      job,
+      source,
+      lastExport
+    } = await this.resolveJob(jobId, flags);
+    if (flags.component && job) {
+      const summary = await this.ripple.getComponentBuildSummary(job.id, flags.component);
+      return {
+        job,
+        componentBuild: summary,
+        source,
+        lastExport
+      };
+    }
+    return {
+      job,
+      source,
+      lastExport
+    };
+  }
+}
+exports.RippleLogCmd = RippleLogCmd;
+class RippleErrorsCmd {
+  constructor(ripple) {
+    this.ripple = ripple;
+    _defineProperty(this, "name", 'errors [job-id]');
+    _defineProperty(this, "description", 'show build errors for a Ripple CI job (auto-detects current lane, or your last export when on main)');
+    _defineProperty(this, "skipWorkspace", true);
+    _defineProperty(this, "remoteOp", true);
+    _defineProperty(this, "alias", '');
+    _defineProperty(this, "options", [['', 'lane <lane>', 'lane ID to find the latest job for (default: detected from .bitmap)'], ['', 'log', 'show full build log for failed containers (not just the error summary)'], ['j', 'json', 'return the output as JSON']]);
+    _defineProperty(this, "arguments", [{
+      name: 'job-id',
+      description: 'the Ripple CI job ID (optional — auto-detects from current lane, or your last export when on main)'
+    }]);
+  }
+  async report([jobId], flags) {
+    const {
+      job,
+      ciNodes,
+      source,
+      lastExport,
+      error
+    } = await this.getErrors(jobId, flags);
+    if (!job) {
+      if (jobId) {
+        return _chalk().default.red(`Job "${jobId}" not found.`);
+      }
+      const laneId = flags.lane || this.ripple.getCurrentLaneId();
+      if (laneId) {
+        return _chalk().default.red(`No Ripple CI job found for lane "${laneId}".`);
+      }
+      return _chalk().default.red(error || 'Could not find a Ripple CI job. Provide a job ID, use --lane, or run from a workspace with a recent export.');
+    }
+    const lines = [];
+    if (source === 'last-export' && lastExport) {
+      lines.push(lastExportHeader(lastExport, job));
+      lines.push('');
+    }
+    lines.push(_chalk().default.bold(`Ripple CI Errors — ${job.name || job.id}`));
+    lines.push(`  ${_chalk().default.cyan('Job ID:')} ${job.id}`);
+    lines.push(`  ${_chalk().default.cyan('Status:')} ${(0, _rippleUtils().colorPhase)(job.status?.phase)}`);
+    if (job.laneId) lines.push(`  ${_chalk().default.cyan('Lane:')}   ${job.laneId}`);
+    lines.push(`  ${_chalk().default.cyan('URL:')}    ${this.ripple.getJobUrl(job)}`);
+    if (ciNodes.length === 0) {
+      lines.push('');
+      lines.push(_chalk().default.yellow('Could not determine which components are in this job.'));
+      return lines.join('\n');
+    }
+    const failedNodes = ciNodes.filter(n => (0, _rippleUtils().isFailedPhase)(n.phase));
+    const succeededNodes = ciNodes.filter(n => n.phase === 'SUCCESS');
+    const otherNodes = ciNodes.filter(n => !(0, _rippleUtils().isFailedPhase)(n.phase) && n.phase !== 'SUCCESS');
+    const totalComponents = ciNodes.reduce((sum, n) => sum + n.componentIds.length, 0);
+    const failedComponents = failedNodes.flatMap(n => n.componentIds);
+    const blockedComponents = otherNodes.flatMap(n => n.componentIds);
+    if (failedComponents.length === 0) {
+      if (job.status?.phase?.toUpperCase() === 'FAILURE') {
+        lines.push('');
+        lines.push(_chalk().default.yellow(`${totalComponents} component(s) in this job — no individual component failures found.`));
+        lines.push(_chalk().default.yellow('The failure may be in a pipeline-level step. Check the Ripple CI URL above.'));
+      } else {
+        lines.push('');
+        lines.push(_chalk().default.green(`All ${totalComponents} component(s) built successfully.`));
+      }
+      return lines.join('\n');
+    }
+    lines.push('');
+    lines.push(_chalk().default.red.bold(`${failedComponents.length} component(s) with build failures:`));
+
+    // fetch all build logs in parallel
+    const containerNames = failedNodes.map(n => n.containerName);
+    const logMap = await this.ripple.getContainerLogs(job.id, containerNames);
+    for (const node of failedNodes) {
+      const compList = node.componentIds.join(', ');
+      lines.push('');
+      lines.push(_chalk().default.bold(`  ${compList}`));
+      const logMessages = logMap.get(node.containerName);
+      if (logMessages && logMessages.length > 0) {
+        const errorLines = flags.log ? logMessages : this.ripple.extractErrorsFromLog(logMessages);
+        if (errorLines.length > 0) {
+          for (const msg of errorLines) {
+            const clean = (0, _rippleUtils().stripAnsi)(msg);
+            // skip stack trace lines (noisy) unless --log is used
+            if (!flags.log && /^\s+at\s/.test(clean)) continue;
+            if (clean.length > 0) {
+              lines.push(`    ${clean}`);
+            }
+          }
+        } else {
+          lines.push(_chalk().default.gray('    No error details found in build log.'));
+        }
+      } else {
+        lines.push(_chalk().default.gray('    Build log not available.'));
+      }
+    }
+    if (blockedComponents.length > 0) {
+      lines.push('');
+      lines.push(_chalk().default.yellow(`${blockedComponents.length} component(s) not built (blocked by failure):`));
+      for (const compId of blockedComponents) {
+        lines.push(`  ${_chalk().default.yellow('○')} ${compId}`);
+      }
+    }
+    if (succeededNodes.length > 0) {
+      const succeededCount = succeededNodes.reduce((sum, n) => sum + n.componentIds.length, 0);
+      lines.push('');
+      lines.push(_chalk().default.green(`${succeededCount} component(s) built successfully.`));
+    }
+    return lines.join('\n');
+  }
+  async json([jobId], flags) {
+    const {
+      job,
+      ciNodes,
+      source,
+      lastExport,
+      error
+    } = await this.getErrors(jobId, flags);
+    if (!job) {
+      return {
+        error: error || 'No job found',
+        job: null,
+        ciNodes: [],
+        containerLogs: {},
+        source,
+        lastExport
+      };
+    }
+
+    // fetch error logs for failed containers in parallel
+    const failedNodes = ciNodes.filter(n => (0, _rippleUtils().isFailedPhase)(n.phase));
+    const containerNames = failedNodes.map(n => n.containerName);
+    const logMap = await this.ripple.getContainerLogs(job.id, containerNames);
+    const containerLogs = {};
+    for (const [name, messages] of logMap) {
+      containerLogs[name] = flags.log ? messages : this.ripple.extractErrorsFromLog(messages);
+    }
+    return {
+      job,
+      ciNodes,
+      containerLogs,
+      source,
+      lastExport
+    };
+  }
+  async getErrors(jobId, flags) {
+    let job = null;
+    let source;
+    let lastExport;
+    if (jobId) {
+      job = await this.ripple.getJob(jobId);
+      source = 'arg';
+    } else {
+      const laneId = flags.lane || this.ripple.getCurrentLaneId();
+      const last = await this.ripple.getLastExport();
+      if (last?.rippleJobs?.length && lastExportMatchesTarget(last, laneId)) {
+        const slug = last.rippleJobs[last.rippleJobs.length - 1];
+        job = await this.ripple.getJobBySlug(slug);
+        source = 'last-export';
+        lastExport = last;
+        if (!job) {
+          return {
+            job: null,
+            ciNodes: [],
+            source: 'last-export',
+            lastExport: last,
+            error: `Could not find Ripple CI job for your last export "${slug}".`
+          };
+        }
+      } else if (laneId) {
+        const found = await this.ripple.findLatestJobForLane(laneId);
+        job = found ? await this.ripple.getJob(found.id) : null;
+        source = 'lane';
+      }
+    }
+    if (!job) {
+      return {
+        job: null,
+        ciNodes: [],
+        source,
+        lastExport
+      };
+    }
+
+    // use ciGraph (internal graph) for job-specific build status per container/component
+    const ciNodes = this.ripple.getCiGraphNodes(job);
+    return {
+      job,
+      ciNodes,
+      source,
+      lastExport
+    };
+  }
+}
+exports.RippleErrorsCmd = RippleErrorsCmd;
+class RippleRetryCmd {
+  constructor(ripple) {
+    this.ripple = ripple;
+    _defineProperty(this, "name", 'retry [job-id]');
+    _defineProperty(this, "description", 'retry a failed Ripple CI job (auto-detects current lane when no job-id given)');
+    _defineProperty(this, "skipWorkspace", true);
+    _defineProperty(this, "remoteOp", true);
+    _defineProperty(this, "alias", '');
+    _defineProperty(this, "options", [['', 'lane <lane>', 'lane ID to find the latest job for (default: detected from .bitmap)'], ['j', 'json', 'return the output as JSON']]);
+    _defineProperty(this, "arguments", [{
+      name: 'job-id',
+      description: 'the Ripple CI job ID to retry (optional — auto-detects from current lane)'
+    }]);
+  }
+  async report([jobId], flags) {
+    const resolved = await (0, _rippleUtils().resolveJobId)(this.ripple, jobId, flags, {
+      allowedPhases: ['FAILURE', 'FAILED'],
+      actionVerb: 'retry'
+    });
+    if ('error' in resolved) return _chalk().default.red(resolved.error);
+    const result = await this.ripple.retryJob(resolved.id);
+    if (!result) {
+      return _chalk().default.red(`Failed to retry job "${resolved.id}". Make sure the job exists and has failed.`);
+    }
+    const lines = [];
+    lines.push(_chalk().default.green(`Successfully retried job "${resolved.id}".`));
+    if (result.id) lines.push(`  ${_chalk().default.cyan('New Job ID:')} ${result.id}`);
+    if (result.status?.phase) lines.push(`  ${_chalk().default.cyan('Status:')}     ${result.status.phase}`);
+    const jobUrl = this.ripple.getJobUrl(result);
+    lines.push(`  ${_chalk().default.cyan('URL:')}        ${jobUrl}`);
+    return lines.join('\n');
+  }
+  async json([jobId], flags) {
+    const resolved = await (0, _rippleUtils().resolveJobId)(this.ripple, jobId, flags, {
+      allowedPhases: ['FAILURE', 'FAILED'],
+      actionVerb: 'retry'
+    });
+    if ('error' in resolved) return {
+      error: resolved.error
+    };
+    const result = await this.ripple.retryJob(resolved.id);
+    return {
+      job: result
+    };
+  }
+}
+exports.RippleRetryCmd = RippleRetryCmd;
+class RippleStopCmd {
+  constructor(ripple) {
+    this.ripple = ripple;
+    _defineProperty(this, "name", 'stop [job-id]');
+    _defineProperty(this, "description", 'stop a running Ripple CI job (auto-detects current lane when no job-id given)');
+    _defineProperty(this, "skipWorkspace", true);
+    _defineProperty(this, "remoteOp", true);
+    _defineProperty(this, "alias", '');
+    _defineProperty(this, "options", [['', 'lane <lane>', 'lane ID to find the latest job for (default: detected from .bitmap)'], ['j', 'json', 'return the output as JSON']]);
+    _defineProperty(this, "arguments", [{
+      name: 'job-id',
+      description: 'the Ripple CI job ID to stop (optional — auto-detects from current lane)'
+    }]);
+  }
+  async report([jobId], flags) {
+    const resolved = await (0, _rippleUtils().resolveJobId)(this.ripple, jobId, flags, {
+      allowedPhases: ['RUNNING', 'IN_PROGRESS', 'PROCESSING'],
+      actionVerb: 'stop'
+    });
+    if ('error' in resolved) return _chalk().default.red(resolved.error);
+    const result = await this.ripple.stopJob(resolved.id);
+    if (!result) {
+      return _chalk().default.red(`Failed to stop job "${resolved.id}". Make sure the job exists and is currently running.`);
+    }
+    return _chalk().default.green(`Successfully stopped job "${resolved.id}".`);
+  }
+  async json([jobId], flags) {
+    const resolved = await (0, _rippleUtils().resolveJobId)(this.ripple, jobId, flags, {
+      allowedPhases: ['RUNNING', 'IN_PROGRESS', 'PROCESSING'],
+      actionVerb: 'stop'
+    });
+    if ('error' in resolved) return {
+      error: resolved.error
+    };
+    const result = await this.ripple.stopJob(resolved.id);
+    return {
+      job: result
+    };
+  }
+}
+exports.RippleStopCmd = RippleStopCmd;
+function formatDate(dateStr) {
+  if (!dateStr) return '-';
+  try {
+    return new Date(dateStr).toLocaleString();
+  } catch {
+    return dateStr;
+  }
+}
+function formatDuration(startedAt, finishedAt) {
+  if (!startedAt) return '-';
+  const start = new Date(startedAt).getTime();
+  const end = finishedAt ? new Date(finishedAt).getTime() : Date.now();
+  const ms = end - start;
+  if (ms < 0) return '-';
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+function getScopeFromLaneId(laneId) {
+  if (!laneId) return '-';
+  return laneId.split('/')[0] || '-';
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return `${str.substring(0, max - 1)}…`;
+}
+
+//# sourceMappingURL=ripple.cmd.js.map