@workflow/cli 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/lib/bulk-cancel.js

@@ -0,0 +1,197 @@
+import { cancelRuns } from '@workflow/core/runtime';
+import { parseWorkflowName } from '@workflow/utils/parse-name';
+import chalk from 'chalk';
+import Table from 'easy-table';
+import { planWindowStartFromResponse } from './inspect/time-window.js';
+export const BULK_CANCEL_MIN_LIMIT = 1;
+export const BULK_CANCEL_MAX_LIMIT = 500;
+export const CLI_CANCEL_REASON = 'Cancelled via Workflow CLI';
+/**
+ * Statuses a run can still be cancelled from. When the caller doesn't pin a
+ * `--status`, bulk cancel restricts matching to these so terminal runs
+ * (including the ones a prior batch just cancelled) don't crowd out reachable
+ * active runs. Otherwise, listing every status returns the same newest
+ * terminal page on each rerun and older active runs are never reached. The
+ * list API filters by a single status, so we fan out across these and merge.
+ */
+export const CANCELLABLE_STATUSES = [
+    'pending',
+    'running',
+];
+/**
+ * Guidance printed when more runs match the filters than were fetched. Bulk
+ * cancel is deliberately single-batch and user-paced — no cursors or async
+ * jobs — so the user re-runs to cancel the next batch.
+ */
+export const HAS_MORE_GUIDANCE = 'More runs match these filters. Re-run this command to cancel the next batch,\n' +
+    'or use --limit up to 500.';
+/**
+ * Validate the `--limit` flag. Returns an error message when invalid, or
+ * `undefined` when the value is an integer within [1, 500].
+ */
+export function validateBulkCancelLimit(limit) {
+    if (!Number.isInteger(limit) ||
+        limit < BULK_CANCEL_MIN_LIMIT ||
+        limit > BULK_CANCEL_MAX_LIMIT) {
+        return `--limit must be an integer between ${BULK_CANCEL_MIN_LIMIT} and ${BULK_CANCEL_MAX_LIMIT}.`;
+    }
+    return undefined;
+}
+/**
+ * Build the compact multi-line "Done:" summary block. Lists every outcome
+ * category so the counts add up to the number of runs requested; individual
+ * `not_found`, `not_cancellable`, and `failed` runs are additionally surfaced
+ * per-run via {@link bulkCancelFailureLines}.
+ */
+export function formatBulkCancelSummary(result) {
+    const { summary } = result;
+    return [
+        'Done:',
+        `  ${summary.cancelled} cancelled`,
+        `  ${summary.alreadyCancelled} already cancelled`,
+        `  ${summary.notCancellable} not cancellable`,
+        `  ${summary.notFound} not found`,
+        `  ${summary.failed} failed`,
+    ].join('\n');
+}
+/**
+ * Per-run lines for outcomes worth calling out individually: `not_found`,
+ * `not_cancellable`, and `failed`. Cancelled and already-cancelled runs are
+ * left to the summary.
+ */
+export function bulkCancelFailureLines(result) {
+    const lines = [];
+    for (const r of result.results) {
+        switch (r.outcome) {
+            case 'not_found':
+                lines.push(`  ✗ ${r.runId}: not found`);
+                break;
+            case 'not_cancellable':
+                lines.push(`  ✗ ${r.runId}: not cancellable (${r.status})`);
+                break;
+            case 'failed':
+                lines.push(`  ✗ ${r.runId}: failed (${r.code}${r.retryable ? ', retryable' : ''})`);
+                break;
+        }
+    }
+    return lines;
+}
+/**
+ * Fetch matching runs (up to `limit`), confirm, and cancel them in a single
+ * bulk operation. Prints a table of what will be cancelled, rerun guidance
+ * when more runs match than were fetched, a compact summary, and per-run
+ * lines for surfaced failures.
+ *
+ * Does not traverse pages: exactly one page of at most `limit` runs is
+ * cancelled per invocation.
+ */
+export async function performBulkCancel(params) {
+    const { world, status, workflowName, limit, confirm, logger, promptConfirm } = params;
+    // Fetch matching runs. Only metadata is needed to display and cancel, so
+    // prefer the analytics read path when the backend provides one.
+    //
+    // When the caller pins a status, match exactly that. Otherwise restrict to
+    // the cancellable statuses so rerunning makes progress instead of returning
+    // the same terminal page forever. The list API takes a single status, so
+    // fan out across the target statuses and merge the pages below.
+    const analytics = world.analytics;
+    const targetStatuses = status
+        ? [status]
+        : [...CANCELLABLE_STATUSES];
+    const fetchPage = async (pageStatus) => {
+        if (!analytics) {
+            return world.runs.list({
+                status: pageStatus,
+                workflowName,
+                pagination: { limit },
+                resolveData: 'none',
+            });
+        }
+        // The analytics backend defaults its listing to a recent window
+        // (trailing 24h on the Vercel backend), but bulk cancel must match
+        // across the plan's whole observability window — a run can sleep or
+        // wait on a hook for days without emitting recent events. Probe for
+        // the plan window bounds first, then match across them.
+        const probe = await analytics.runs.list({
+            status: pageStatus,
+            workflowName,
+            pagination: { limit: 1 },
+        });
+        const windowStart = planWindowStartFromResponse(probe);
+        return analytics.runs.list({
+            status: pageStatus,
+            workflowName,
+            ...(windowStart
+                ? { startTime: windowStart, endTime: new Date().toISOString() }
+                : {}),
+            pagination: { limit },
+        });
+    };
+    const pages = await Promise.all(targetStatuses.map(fetchPage));
+    // Merge the per-status pages round-robin so a full page of running runs
+    // cannot crowd pending runs (which do not have a startedAt timestamp) out
+    // of every batch. Preserve each page's backend order and dedupe by runId in
+    // case a run changes status while the pages are fetched.
+    const projectedPages = pages.map((page) => page.data.map((run) => ({
+        runId: run.runId,
+        workflowName: run.workflowName,
+        status: run.status,
+        startedAt: run.startedAt,
+    })));
+    const merged = [];
+    const seenRunIds = new Set();
+    const maxPageLength = Math.max(0, ...projectedPages.map((page) => page.length));
+    for (let index = 0; index < maxPageLength; index++) {
+        for (const page of projectedPages) {
+            const run = page[index];
+            if (run && !seenRunIds.has(run.runId)) {
+                seenRunIds.add(run.runId);
+                merged.push(run);
+            }
+        }
+    }
+    const runs = {
+        data: merged.slice(0, limit),
+        hasMore: pages.some((page) => page.hasMore) || merged.length > limit,
+    };
+    if (runs.data.length === 0) {
+        logger.warn('No matching runs found.');
+        return { exitCode: 0 };
+    }
+    // Display what will be cancelled.
+    const table = new Table();
+    for (const run of runs.data) {
+        const shortName = parseWorkflowName(run.workflowName)?.shortName || run.workflowName;
+        table.cell('runId', run.runId);
+        table.cell('workflow', chalk.blueBright(shortName));
+        table.cell('status', run.status);
+        table.cell('startedAt', run.startedAt ? new Date(run.startedAt).toISOString() : '-');
+        table.newRow();
+    }
+    logger.log(`\nFound ${chalk.bold(runs.data.length)} runs to cancel:\n`);
+    logger.log(table.toString());
+    if (runs.hasMore) {
+        logger.warn(HAS_MORE_GUIDANCE);
+    }
+    // Confirm unless --confirm/-y.
+    if (!confirm) {
+        const confirmed = promptConfirm
+            ? await promptConfirm(`Cancel ${runs.data.length} run${runs.data.length === 1 ? '' : 's'}?`)
+            : false;
+        if (!confirmed) {
+            logger.log('Aborted.');
+            return { exitCode: 0 };
+        }
+    }
+    // One bulk operation: a single backend request on Vercel, or bounded
+    // fallback concurrency on local / community worlds.
+    const result = await cancelRuns(world, runs.data.map((run) => run.runId), { cancelReason: CLI_CANCEL_REASON });
+    for (const line of bulkCancelFailureLines(result)) {
+        logger.warn(line);
+    }
+    logger.log(`\n${formatBulkCancelSummary(result)}`);
+    // Already-cancelled and terminal runs are valid partial outcomes; only a
+    // genuine failure is a nonzero exit.
+    return { exitCode: result.summary.failed > 0 ? 1 : 0, result };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bulk-cancel.js","sourceRoot":"","sources":["../../src/lib/bulk-cancel.ts"],"names":[],"mappings":"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","sourcesContent":["import { cancelRuns } from '@workflow/core/runtime';\nimport { parseWorkflowName } from '@workflow/utils/parse-name';\nimport type {\n  BulkCancelWorkflowRunsResult,\n  WorkflowRunStatus,\n  World,\n} from '@workflow/world';\nimport chalk from 'chalk';\nimport Table from 'easy-table';\nimport { planWindowStartFromResponse } from './inspect/time-window.js';\n\nexport const BULK_CANCEL_MIN_LIMIT = 1;\nexport const BULK_CANCEL_MAX_LIMIT = 500;\nexport const CLI_CANCEL_REASON = 'Cancelled via Workflow CLI';\n\n/**\n * Statuses a run can still be cancelled from. When the caller doesn't pin a\n * `--status`, bulk cancel restricts matching to these so terminal runs\n * (including the ones a prior batch just cancelled) don't crowd out reachable\n * active runs. Otherwise, listing every status returns the same newest\n * terminal page on each rerun and older active runs are never reached. The\n * list API filters by a single status, so we fan out across these and merge.\n */\nexport const CANCELLABLE_STATUSES = [\n  'pending',\n  'running',\n] as const satisfies readonly WorkflowRunStatus[];\n\n/**\n * Guidance printed when more runs match the filters than were fetched. Bulk\n * cancel is deliberately single-batch and user-paced — no cursors or async\n * jobs — so the user re-runs to cancel the next batch.\n */\nexport const HAS_MORE_GUIDANCE =\n  'More runs match these filters. Re-run this command to cancel the next batch,\\n' +\n  'or use --limit up to 500.';\n\nexport interface CancelLogger {\n  log(message: string): void;\n  warn(message: string): void;\n  error(message: string): void;\n}\n\n/**\n * Validate the `--limit` flag. Returns an error message when invalid, or\n * `undefined` when the value is an integer within [1, 500].\n */\nexport function validateBulkCancelLimit(limit: number): string | undefined {\n  if (\n    !Number.isInteger(limit) ||\n    limit < BULK_CANCEL_MIN_LIMIT ||\n    limit > BULK_CANCEL_MAX_LIMIT\n  ) {\n    return `--limit must be an integer between ${BULK_CANCEL_MIN_LIMIT} and ${BULK_CANCEL_MAX_LIMIT}.`;\n  }\n  return undefined;\n}\n\n/**\n * Build the compact multi-line \"Done:\" summary block. Lists every outcome\n * category so the counts add up to the number of runs requested; individual\n * `not_found`, `not_cancellable`, and `failed` runs are additionally surfaced\n * per-run via {@link bulkCancelFailureLines}.\n */\nexport function formatBulkCancelSummary(\n  result: BulkCancelWorkflowRunsResult\n): string {\n  const { summary } = result;\n  return [\n    'Done:',\n    `  ${summary.cancelled} cancelled`,\n    `  ${summary.alreadyCancelled} already cancelled`,\n    `  ${summary.notCancellable} not cancellable`,\n    `  ${summary.notFound} not found`,\n    `  ${summary.failed} failed`,\n  ].join('\\n');\n}\n\n/**\n * Per-run lines for outcomes worth calling out individually: `not_found`,\n * `not_cancellable`, and `failed`. Cancelled and already-cancelled runs are\n * left to the summary.\n */\nexport function bulkCancelFailureLines(\n  result: BulkCancelWorkflowRunsResult\n): string[] {\n  const lines: string[] = [];\n  for (const r of result.results) {\n    switch (r.outcome) {\n      case 'not_found':\n        lines.push(`  ✗ ${r.runId}: not found`);\n        break;\n      case 'not_cancellable':\n        lines.push(`  ✗ ${r.runId}: not cancellable (${r.status})`);\n        break;\n      case 'failed':\n        lines.push(\n          `  ✗ ${r.runId}: failed (${r.code}${r.retryable ? ', retryable' : ''})`\n        );\n        break;\n    }\n  }\n  return lines;\n}\n\nexport interface BulkCancelParams {\n  world: World;\n  status?: WorkflowRunStatus;\n  workflowName?: string;\n  /** Max runs to fetch and cancel in this batch (already validated). */\n  limit: number;\n  /** When true, skip the interactive confirmation prompt. */\n  confirm: boolean;\n  logger: CancelLogger;\n  /**\n   * Confirmation prompt. Omitted in non-interactive contexts (and tests),\n   * in which case an unconfirmed run aborts.\n   */\n  promptConfirm?: (message: string) => Promise<boolean>;\n}\n\nexport interface BulkCancelOutcome {\n  /** Process exit code: 1 when any run failed, otherwise 0. */\n  exitCode: number;\n  /** The structured result, or undefined when nothing matched / aborted. */\n  result?: BulkCancelWorkflowRunsResult;\n}\n\n/**\n * Fetch matching runs (up to `limit`), confirm, and cancel them in a single\n * bulk operation. Prints a table of what will be cancelled, rerun guidance\n * when more runs match than were fetched, a compact summary, and per-run\n * lines for surfaced failures.\n *\n * Does not traverse pages: exactly one page of at most `limit` runs is\n * cancelled per invocation.\n */\nexport async function performBulkCancel(\n  params: BulkCancelParams\n): Promise<BulkCancelOutcome> {\n  const { world, status, workflowName, limit, confirm, logger, promptConfirm } =\n    params;\n\n  // Fetch matching runs. Only metadata is needed to display and cancel, so\n  // prefer the analytics read path when the backend provides one.\n  //\n  // When the caller pins a status, match exactly that. Otherwise restrict to\n  // the cancellable statuses so rerunning makes progress instead of returning\n  // the same terminal page forever. The list API takes a single status, so\n  // fan out across the target statuses and merge the pages below.\n  const analytics = world.analytics;\n  const targetStatuses: WorkflowRunStatus[] = status\n    ? [status]\n    : [...CANCELLABLE_STATUSES];\n\n  const fetchPage = async (pageStatus: WorkflowRunStatus) => {\n    if (!analytics) {\n      return world.runs.list({\n        status: pageStatus,\n        workflowName,\n        pagination: { limit },\n        resolveData: 'none',\n      });\n    }\n    // The analytics backend defaults its listing to a recent window\n    // (trailing 24h on the Vercel backend), but bulk cancel must match\n    // across the plan's whole observability window — a run can sleep or\n    // wait on a hook for days without emitting recent events. Probe for\n    // the plan window bounds first, then match across them.\n    const probe = await analytics.runs.list({\n      status: pageStatus,\n      workflowName,\n      pagination: { limit: 1 },\n    });\n    const windowStart = planWindowStartFromResponse(probe);\n    return analytics.runs.list({\n      status: pageStatus,\n      workflowName,\n      ...(windowStart\n        ? { startTime: windowStart, endTime: new Date().toISOString() }\n        : {}),\n      pagination: { limit },\n    });\n  };\n\n  const pages = await Promise.all(targetStatuses.map(fetchPage));\n\n  // Merge the per-status pages round-robin so a full page of running runs\n  // cannot crowd pending runs (which do not have a startedAt timestamp) out\n  // of every batch. Preserve each page's backend order and dedupe by runId in\n  // case a run changes status while the pages are fetched.\n  const projectedPages = pages.map((page) =>\n    page.data.map((run) => ({\n      runId: run.runId,\n      workflowName: run.workflowName,\n      status: run.status,\n      startedAt: run.startedAt,\n    }))\n  );\n  const merged: (typeof projectedPages)[number][number][] = [];\n  const seenRunIds = new Set<string>();\n  const maxPageLength = Math.max(\n    0,\n    ...projectedPages.map((page) => page.length)\n  );\n  for (let index = 0; index < maxPageLength; index++) {\n    for (const page of projectedPages) {\n      const run = page[index];\n      if (run && !seenRunIds.has(run.runId)) {\n        seenRunIds.add(run.runId);\n        merged.push(run);\n      }\n    }\n  }\n  const runs = {\n    data: merged.slice(0, limit),\n    hasMore: pages.some((page) => page.hasMore) || merged.length > limit,\n  };\n\n  if (runs.data.length === 0) {\n    logger.warn('No matching runs found.');\n    return { exitCode: 0 };\n  }\n\n  // Display what will be cancelled.\n  const table = new Table();\n  for (const run of runs.data) {\n    const shortName =\n      parseWorkflowName(run.workflowName)?.shortName || run.workflowName;\n    table.cell('runId', run.runId);\n    table.cell('workflow', chalk.blueBright(shortName));\n    table.cell('status', run.status);\n    table.cell(\n      'startedAt',\n      run.startedAt ? new Date(run.startedAt).toISOString() : '-'\n    );\n    table.newRow();\n  }\n  logger.log(`\\nFound ${chalk.bold(runs.data.length)} runs to cancel:\\n`);\n  logger.log(table.toString());\n\n  if (runs.hasMore) {\n    logger.warn(HAS_MORE_GUIDANCE);\n  }\n\n  // Confirm unless --confirm/-y.\n  if (!confirm) {\n    const confirmed = promptConfirm\n      ? await promptConfirm(\n          `Cancel ${runs.data.length} run${runs.data.length === 1 ? '' : 's'}?`\n        )\n      : false;\n    if (!confirmed) {\n      logger.log('Aborted.');\n      return { exitCode: 0 };\n    }\n  }\n\n  // One bulk operation: a single backend request on Vercel, or bounded\n  // fallback concurrency on local / community worlds.\n  const result = await cancelRuns(\n    world,\n    runs.data.map((run) => run.runId),\n    { cancelReason: CLI_CANCEL_REASON }\n  );\n\n  for (const line of bulkCancelFailureLines(result)) {\n    logger.warn(line);\n  }\n  logger.log(`\\n${formatBulkCancelSummary(result)}`);\n\n  // Already-cancelled and terminal runs are valid partial outcomes; only a\n  // genuine failure is a nonzero exit.\n  return { exitCode: result.summary.failed > 0 ? 1 : 0, result };\n}\n"]}

package/dist/lib/bulk-cancel.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bulk-cancel.test.d.ts.map

package/dist/lib/bulk-cancel.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-cancel.test.d.ts","sourceRoot":"","sources":["../../src/lib/bulk-cancel.test.ts"],"names":[],"mappings":""}