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

package/dist/lib/bulk-cancel.test.js

@@ -0,0 +1,366 @@
+import { describe, expect, it, vi } from 'vitest';
+import { bulkCancelFailureLines, CLI_CANCEL_REASON, formatBulkCancelSummary, HAS_MORE_GUIDANCE, performBulkCancel, validateBulkCancelLimit, } from './bulk-cancel.js';
+/** Collects logger output so assertions can inspect what the user saw. */
+function makeLogger() {
+    const logs = [];
+    const warns = [];
+    const errors = [];
+    return {
+        logger: {
+            log: (m) => logs.push(m),
+            warn: (m) => warns.push(m),
+            error: (m) => errors.push(m),
+        },
+        logs,
+        warns,
+        errors,
+    };
+}
+/**
+ * Build a minimal fake world. `cancelMany` is attached only when provided,
+ * which is how {@link performBulkCancel} (via `cancelRuns`) decides between
+ * the single-request fast path and the per-run fallback.
+ */
+function makeWorld(opts) {
+    const runsById = new Map(opts.runs.map((r) => [r.runId, r]));
+    const world = {
+        analytics: undefined,
+        runs: {
+            // Status-aware so tests can seed mixed-status runs and assert that only
+            // the requested status is matched. performBulkCancel always passes a
+            // concrete status per call (the pinned one, or each cancellable status).
+            list: vi.fn(async (params = {}) => ({
+                data: params.status
+                    ? opts.runs.filter((r) => r.status === params.status)
+                    : opts.runs,
+                hasMore: opts.hasMore ?? false,
+            })),
+            get: vi.fn(async (runId) => {
+                const run = runsById.get(runId);
+                if (!run)
+                    throw new Error(`run ${runId} not found`);
+                return run;
+            }),
+        },
+        events: {
+            create: vi.fn(async (runId) => opts.eventsCreate?.(runId)),
+        },
+    };
+    if (opts.cancelMany) {
+        world.runs.cancelMany = vi.fn(opts.cancelMany);
+    }
+    return world;
+}
+describe('validateBulkCancelLimit', () => {
+    it('accepts integers within [1, 500]', () => {
+        expect(validateBulkCancelLimit(1)).toBeUndefined();
+        expect(validateBulkCancelLimit(50)).toBeUndefined();
+        expect(validateBulkCancelLimit(500)).toBeUndefined();
+    });
+    it('rejects out-of-range and non-integer values', () => {
+        expect(validateBulkCancelLimit(0)).toMatch(/between 1 and 500/);
+        expect(validateBulkCancelLimit(501)).toMatch(/between 1 and 500/);
+        expect(validateBulkCancelLimit(-5)).toMatch(/between 1 and 500/);
+        expect(validateBulkCancelLimit(1.5)).toMatch(/between 1 and 500/);
+    });
+});
+describe('formatBulkCancelSummary', () => {
+    it('renders every outcome category so counts add up to requested', () => {
+        const summary = formatBulkCancelSummary({
+            summary: {
+                requested: 7,
+                cancelled: 2,
+                alreadyCancelled: 1,
+                notCancellable: 1,
+                notFound: 3,
+                failed: 0,
+            },
+            results: [],
+        });
+        expect(summary).toBe([
+            'Done:',
+            '  2 cancelled',
+            '  1 already cancelled',
+            '  1 not cancellable',
+            '  3 not found',
+            '  0 failed',
+        ].join('\n'));
+    });
+});
+describe('bulkCancelFailureLines', () => {
+    it('surfaces only not_found, not_cancellable, and failed runs', () => {
+        const lines = bulkCancelFailureLines({
+            summary: {
+                requested: 5,
+                cancelled: 1,
+                alreadyCancelled: 1,
+                notCancellable: 1,
+                notFound: 1,
+                failed: 1,
+            },
+            results: [
+                { runId: 'a', outcome: 'cancelled' },
+                { runId: 'b', outcome: 'already_cancelled' },
+                { runId: 'c', outcome: 'not_cancellable', status: 'completed' },
+                { runId: 'd', outcome: 'not_found' },
+                {
+                    runId: 'e',
+                    outcome: 'failed',
+                    code: 'internal_error',
+                    retryable: true,
+                },
+            ],
+        });
+        expect(lines).toEqual([
+            '  ✗ c: not cancellable (completed)',
+            '  ✗ d: not found',
+            '  ✗ e: failed (internal_error, retryable)',
+        ]);
+    });
+});
+describe('performBulkCancel', () => {
+    it('warns and exits 0 when no runs match', async () => {
+        const { logger, warns } = makeLogger();
+        const world = makeWorld({ runs: [] });
+        const { exitCode, result } = await performBulkCancel({
+            world,
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(0);
+        expect(result).toBeUndefined();
+        expect(warns).toContain('No matching runs found.');
+    });
+    it('restricts to cancellable statuses and excludes terminal runs when no status is pinned', async () => {
+        const { logger } = makeLogger();
+        const cancelMany = vi.fn(async (req) => ({
+            summary: {
+                requested: req.runIds.length,
+                cancelled: req.runIds.length,
+                alreadyCancelled: 0,
+                notCancellable: 0,
+                notFound: 0,
+                failed: 0,
+            },
+            results: req.runIds.map((runId) => ({
+                runId,
+                outcome: 'cancelled',
+            })),
+        }));
+        const world = makeWorld({
+            runs: [
+                { runId: 'p1', workflowName: 'wf', status: 'pending' },
+                { runId: 'r1', workflowName: 'wf', status: 'running' },
+                // Terminal — must never be fetched or cancelled.
+                { runId: 'done', workflowName: 'wf', status: 'completed' },
+            ],
+            cancelMany,
+        });
+        const { exitCode } = await performBulkCancel({
+            world,
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(0);
+        const requestedStatuses = world.runs.list.mock.calls.map((c) => c[0]?.status);
+        expect(requestedStatuses).toContain('pending');
+        expect(requestedStatuses).toContain('running');
+        expect(requestedStatuses).not.toContain('completed');
+        // Only the cancellable runs reach cancelMany; the completed run is excluded.
+        expect(cancelMany).toHaveBeenCalledTimes(1);
+        expect([...cancelMany.mock.calls[0][0].runIds].sort()).toEqual([
+            'p1',
+            'r1',
+        ]);
+    });
+    it('round-robins status pages before applying the batch limit', async () => {
+        const { logger } = makeLogger();
+        const cancelMany = vi.fn(async (req) => ({
+            summary: {
+                requested: req.runIds.length,
+                cancelled: req.runIds.length,
+                alreadyCancelled: 0,
+                notCancellable: 0,
+                notFound: 0,
+                failed: 0,
+            },
+            results: req.runIds.map((runId) => ({
+                runId,
+                outcome: 'cancelled',
+            })),
+        }));
+        const world = makeWorld({
+            runs: [
+                ...Array.from({ length: 5 }, (_, index) => ({
+                    runId: `r${index + 1}`,
+                    workflowName: 'wf',
+                    status: 'running',
+                    startedAt: new Date(2026, 0, index + 1).toISOString(),
+                })),
+                ...Array.from({ length: 3 }, (_, index) => ({
+                    runId: `p${index + 1}`,
+                    workflowName: 'wf',
+                    status: 'pending',
+                })),
+            ],
+            cancelMany,
+        });
+        await performBulkCancel({
+            world,
+            limit: 5,
+            confirm: true,
+            logger,
+        });
+        expect(cancelMany).toHaveBeenCalledWith({
+            runIds: ['p1', 'r1', 'p2', 'r2', 'p3'],
+            cancelReason: CLI_CANCEL_REASON,
+        });
+    });
+    it('uses the cancelMany fast path in a single call and skips per-run events', async () => {
+        const { logger } = makeLogger();
+        const cancelMany = vi.fn(async () => ({
+            summary: {
+                requested: 2,
+                cancelled: 2,
+                alreadyCancelled: 0,
+                notCancellable: 0,
+                notFound: 0,
+                failed: 0,
+            },
+            results: [
+                { runId: 'r1', outcome: 'cancelled' },
+                { runId: 'r2', outcome: 'cancelled' },
+            ],
+        }));
+        const world = makeWorld({
+            runs: [
+                { runId: 'r1', workflowName: 'wf', status: 'running' },
+                { runId: 'r2', workflowName: 'wf', status: 'running' },
+            ],
+            cancelMany,
+        });
+        const { exitCode } = await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(0);
+        expect(cancelMany).toHaveBeenCalledTimes(1);
+        expect(cancelMany).toHaveBeenCalledWith({
+            runIds: ['r1', 'r2'],
+            cancelReason: CLI_CANCEL_REASON,
+        });
+        // Fast path must not fall back to per-run event creation.
+        expect(world.events.create).not.toHaveBeenCalled();
+    });
+    it('falls back to per-run cancellation when cancelMany is absent', async () => {
+        const { logger, logs } = makeLogger();
+        const world = makeWorld({
+            runs: [
+                { runId: 'r1', workflowName: 'wf', status: 'running' },
+                { runId: 'r2', workflowName: 'wf', status: 'running' },
+            ],
+        });
+        const { exitCode, result } = await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(0);
+        expect(world.events.create).toHaveBeenCalledTimes(2);
+        expect(world.events.create).toHaveBeenCalledWith('r1', expect.objectContaining({
+            eventData: { cancelReason: CLI_CANCEL_REASON },
+        }), expect.anything());
+        expect(result?.summary.cancelled).toBe(2);
+        expect(logs.join('\n')).toContain('2 cancelled');
+    });
+    it('prints rerun guidance when more runs match than were fetched', async () => {
+        const { logger, warns } = makeLogger();
+        const world = makeWorld({
+            runs: [{ runId: 'r1', workflowName: 'wf', status: 'running' }],
+            hasMore: true,
+            cancelMany: async () => ({
+                summary: {
+                    requested: 1,
+                    cancelled: 1,
+                    alreadyCancelled: 0,
+                    notCancellable: 0,
+                    notFound: 0,
+                    failed: 0,
+                },
+                results: [{ runId: 'r1', outcome: 'cancelled' }],
+            }),
+        });
+        await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 1,
+            confirm: true,
+            logger,
+        });
+        expect(warns).toContain(HAS_MORE_GUIDANCE);
+    });
+    it('exits 1 and surfaces per-run failures when a run fails', async () => {
+        const { logger, warns } = makeLogger();
+        const world = makeWorld({
+            runs: [
+                { runId: 'r1', workflowName: 'wf', status: 'running' },
+                { runId: 'r2', workflowName: 'wf', status: 'running' },
+            ],
+            cancelMany: async () => ({
+                summary: {
+                    requested: 2,
+                    cancelled: 1,
+                    alreadyCancelled: 0,
+                    notCancellable: 0,
+                    notFound: 0,
+                    failed: 1,
+                },
+                results: [
+                    { runId: 'r1', outcome: 'cancelled' },
+                    {
+                        runId: 'r2',
+                        outcome: 'failed',
+                        code: 'internal_error',
+                        retryable: true,
+                    },
+                ],
+            }),
+        });
+        const { exitCode } = await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(1);
+        expect(warns).toContain('  ✗ r2: failed (internal_error, retryable)');
+    });
+    it('aborts without cancelling when confirmation is declined', async () => {
+        const { logger, logs } = makeLogger();
+        const cancelMany = vi.fn();
+        const world = makeWorld({
+            runs: [{ runId: 'r1', workflowName: 'wf', status: 'running' }],
+            cancelMany: cancelMany,
+        });
+        const { exitCode } = await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 50,
+            confirm: false,
+            logger,
+            promptConfirm: async () => false,
+        });
+        expect(exitCode).toBe(0);
+        expect(logs).toContain('Aborted.');
+        expect(cancelMany).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bulk-cancel.test.js","sourceRoot":"","sources":["../../src/lib/bulk-cancel.test.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  BulkCancelWorkflowRunsRequest,\n  BulkCancelWorkflowRunsResult,\n  World,\n} from '@workflow/world';\nimport { describe, expect, it, vi } from 'vitest';\nimport {\n  bulkCancelFailureLines,\n  CLI_CANCEL_REASON,\n  formatBulkCancelSummary,\n  HAS_MORE_GUIDANCE,\n  performBulkCancel,\n  validateBulkCancelLimit,\n} from './bulk-cancel.js';\n\ninterface FakeRun {\n  runId: string;\n  workflowName: string;\n  status: string;\n  startedAt?: string;\n}\n\n/** Collects logger output so assertions can inspect what the user saw. */\nfunction makeLogger() {\n  const logs: string[] = [];\n  const warns: string[] = [];\n  const errors: string[] = [];\n  return {\n    logger: {\n      log: (m: string) => logs.push(m),\n      warn: (m: string) => warns.push(m),\n      error: (m: string) => errors.push(m),\n    },\n    logs,\n    warns,\n    errors,\n  };\n}\n\n/**\n * Build a minimal fake world. `cancelMany` is attached only when provided,\n * which is how {@link performBulkCancel} (via `cancelRuns`) decides between\n * the single-request fast path and the per-run fallback.\n */\nfunction makeWorld(opts: {\n  runs: FakeRun[];\n  hasMore?: boolean;\n  cancelMany?: (\n    request: BulkCancelWorkflowRunsRequest\n  ) => Promise<BulkCancelWorkflowRunsResult>;\n  eventsCreate?: (runId: string) => Promise<unknown>;\n}): World {\n  const runsById = new Map(opts.runs.map((r) => [r.runId, r]));\n  const world: any = {\n    analytics: undefined,\n    runs: {\n      // Status-aware so tests can seed mixed-status runs and assert that only\n      // the requested status is matched. performBulkCancel always passes a\n      // concrete status per call (the pinned one, or each cancellable status).\n      list: vi.fn(async (params: { status?: string } = {}) => ({\n        data: params.status\n          ? opts.runs.filter((r) => r.status === params.status)\n          : opts.runs,\n        hasMore: opts.hasMore ?? false,\n      })),\n      get: vi.fn(async (runId: string) => {\n        const run = runsById.get(runId);\n        if (!run) throw new Error(`run ${runId} not found`);\n        return run;\n      }),\n    },\n    events: {\n      create: vi.fn(async (runId: string) => opts.eventsCreate?.(runId)),\n    },\n  };\n  if (opts.cancelMany) {\n    world.runs.cancelMany = vi.fn(opts.cancelMany);\n  }\n  return world as World;\n}\n\ndescribe('validateBulkCancelLimit', () => {\n  it('accepts integers within [1, 500]', () => {\n    expect(validateBulkCancelLimit(1)).toBeUndefined();\n    expect(validateBulkCancelLimit(50)).toBeUndefined();\n    expect(validateBulkCancelLimit(500)).toBeUndefined();\n  });\n\n  it('rejects out-of-range and non-integer values', () => {\n    expect(validateBulkCancelLimit(0)).toMatch(/between 1 and 500/);\n    expect(validateBulkCancelLimit(501)).toMatch(/between 1 and 500/);\n    expect(validateBulkCancelLimit(-5)).toMatch(/between 1 and 500/);\n    expect(validateBulkCancelLimit(1.5)).toMatch(/between 1 and 500/);\n  });\n});\n\ndescribe('formatBulkCancelSummary', () => {\n  it('renders every outcome category so counts add up to requested', () => {\n    const summary = formatBulkCancelSummary({\n      summary: {\n        requested: 7,\n        cancelled: 2,\n        alreadyCancelled: 1,\n        notCancellable: 1,\n        notFound: 3,\n        failed: 0,\n      },\n      results: [],\n    });\n    expect(summary).toBe(\n      [\n        'Done:',\n        '  2 cancelled',\n        '  1 already cancelled',\n        '  1 not cancellable',\n        '  3 not found',\n        '  0 failed',\n      ].join('\\n')\n    );\n  });\n});\n\ndescribe('bulkCancelFailureLines', () => {\n  it('surfaces only not_found, not_cancellable, and failed runs', () => {\n    const lines = bulkCancelFailureLines({\n      summary: {\n        requested: 5,\n        cancelled: 1,\n        alreadyCancelled: 1,\n        notCancellable: 1,\n        notFound: 1,\n        failed: 1,\n      },\n      results: [\n        { runId: 'a', outcome: 'cancelled' },\n        { runId: 'b', outcome: 'already_cancelled' },\n        { runId: 'c', outcome: 'not_cancellable', status: 'completed' },\n        { runId: 'd', outcome: 'not_found' },\n        {\n          runId: 'e',\n          outcome: 'failed',\n          code: 'internal_error',\n          retryable: true,\n        },\n      ],\n    });\n    expect(lines).toEqual([\n      '  ✗ c: not cancellable (completed)',\n      '  ✗ d: not found',\n      '  ✗ e: failed (internal_error, retryable)',\n    ]);\n  });\n});\n\ndescribe('performBulkCancel', () => {\n  it('warns and exits 0 when no runs match', async () => {\n    const { logger, warns } = makeLogger();\n    const world = makeWorld({ runs: [] });\n\n    const { exitCode, result } = await performBulkCancel({\n      world,\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(0);\n    expect(result).toBeUndefined();\n    expect(warns).toContain('No matching runs found.');\n  });\n\n  it('restricts to cancellable statuses and excludes terminal runs when no status is pinned', async () => {\n    const { logger } = makeLogger();\n    const cancelMany = vi.fn(\n      async (\n        req: BulkCancelWorkflowRunsRequest\n      ): Promise<BulkCancelWorkflowRunsResult> => ({\n        summary: {\n          requested: req.runIds.length,\n          cancelled: req.runIds.length,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 0,\n        },\n        results: req.runIds.map((runId) => ({\n          runId,\n          outcome: 'cancelled' as const,\n        })),\n      })\n    );\n    const world = makeWorld({\n      runs: [\n        { runId: 'p1', workflowName: 'wf', status: 'pending' },\n        { runId: 'r1', workflowName: 'wf', status: 'running' },\n        // Terminal — must never be fetched or cancelled.\n        { runId: 'done', workflowName: 'wf', status: 'completed' },\n      ],\n      cancelMany,\n    });\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(0);\n    const requestedStatuses = (world.runs.list as any).mock.calls.map(\n      (c: [{ status?: string }]) => c[0]?.status\n    );\n    expect(requestedStatuses).toContain('pending');\n    expect(requestedStatuses).toContain('running');\n    expect(requestedStatuses).not.toContain('completed');\n    // Only the cancellable runs reach cancelMany; the completed run is excluded.\n    expect(cancelMany).toHaveBeenCalledTimes(1);\n    expect([...cancelMany.mock.calls[0][0].runIds].sort()).toEqual([\n      'p1',\n      'r1',\n    ]);\n  });\n\n  it('round-robins status pages before applying the batch limit', async () => {\n    const { logger } = makeLogger();\n    const cancelMany = vi.fn(\n      async (\n        req: BulkCancelWorkflowRunsRequest\n      ): Promise<BulkCancelWorkflowRunsResult> => ({\n        summary: {\n          requested: req.runIds.length,\n          cancelled: req.runIds.length,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 0,\n        },\n        results: req.runIds.map((runId) => ({\n          runId,\n          outcome: 'cancelled' as const,\n        })),\n      })\n    );\n    const world = makeWorld({\n      runs: [\n        ...Array.from({ length: 5 }, (_, index) => ({\n          runId: `r${index + 1}`,\n          workflowName: 'wf',\n          status: 'running',\n          startedAt: new Date(2026, 0, index + 1).toISOString(),\n        })),\n        ...Array.from({ length: 3 }, (_, index) => ({\n          runId: `p${index + 1}`,\n          workflowName: 'wf',\n          status: 'pending',\n        })),\n      ],\n      cancelMany,\n    });\n\n    await performBulkCancel({\n      world,\n      limit: 5,\n      confirm: true,\n      logger,\n    });\n\n    expect(cancelMany).toHaveBeenCalledWith({\n      runIds: ['p1', 'r1', 'p2', 'r2', 'p3'],\n      cancelReason: CLI_CANCEL_REASON,\n    });\n  });\n\n  it('uses the cancelMany fast path in a single call and skips per-run events', async () => {\n    const { logger } = makeLogger();\n    const cancelMany = vi.fn(\n      async (): Promise<BulkCancelWorkflowRunsResult> => ({\n        summary: {\n          requested: 2,\n          cancelled: 2,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 0,\n        },\n        results: [\n          { runId: 'r1', outcome: 'cancelled' },\n          { runId: 'r2', outcome: 'cancelled' },\n        ],\n      })\n    );\n    const world = makeWorld({\n      runs: [\n        { runId: 'r1', workflowName: 'wf', status: 'running' },\n        { runId: 'r2', workflowName: 'wf', status: 'running' },\n      ],\n      cancelMany,\n    });\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(0);\n    expect(cancelMany).toHaveBeenCalledTimes(1);\n    expect(cancelMany).toHaveBeenCalledWith({\n      runIds: ['r1', 'r2'],\n      cancelReason: CLI_CANCEL_REASON,\n    });\n    // Fast path must not fall back to per-run event creation.\n    expect(world.events.create as any).not.toHaveBeenCalled();\n  });\n\n  it('falls back to per-run cancellation when cancelMany is absent', async () => {\n    const { logger, logs } = makeLogger();\n    const world = makeWorld({\n      runs: [\n        { runId: 'r1', workflowName: 'wf', status: 'running' },\n        { runId: 'r2', workflowName: 'wf', status: 'running' },\n      ],\n    });\n\n    const { exitCode, result } = await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(0);\n    expect(world.events.create as any).toHaveBeenCalledTimes(2);\n    expect(world.events.create as any).toHaveBeenCalledWith(\n      'r1',\n      expect.objectContaining({\n        eventData: { cancelReason: CLI_CANCEL_REASON },\n      }),\n      expect.anything()\n    );\n    expect(result?.summary.cancelled).toBe(2);\n    expect(logs.join('\\n')).toContain('2 cancelled');\n  });\n\n  it('prints rerun guidance when more runs match than were fetched', async () => {\n    const { logger, warns } = makeLogger();\n    const world = makeWorld({\n      runs: [{ runId: 'r1', workflowName: 'wf', status: 'running' }],\n      hasMore: true,\n      cancelMany: async () => ({\n        summary: {\n          requested: 1,\n          cancelled: 1,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 0,\n        },\n        results: [{ runId: 'r1', outcome: 'cancelled' }],\n      }),\n    });\n\n    await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 1,\n      confirm: true,\n      logger,\n    });\n\n    expect(warns).toContain(HAS_MORE_GUIDANCE);\n  });\n\n  it('exits 1 and surfaces per-run failures when a run fails', async () => {\n    const { logger, warns } = makeLogger();\n    const world = makeWorld({\n      runs: [\n        { runId: 'r1', workflowName: 'wf', status: 'running' },\n        { runId: 'r2', workflowName: 'wf', status: 'running' },\n      ],\n      cancelMany: async () => ({\n        summary: {\n          requested: 2,\n          cancelled: 1,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 1,\n        },\n        results: [\n          { runId: 'r1', outcome: 'cancelled' },\n          {\n            runId: 'r2',\n            outcome: 'failed',\n            code: 'internal_error',\n            retryable: true,\n          },\n        ],\n      }),\n    });\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(1);\n    expect(warns).toContain('  ✗ r2: failed (internal_error, retryable)');\n  });\n\n  it('aborts without cancelling when confirmation is declined', async () => {\n    const { logger, logs } = makeLogger();\n    const cancelMany = vi.fn();\n    const world = makeWorld({\n      runs: [{ runId: 'r1', workflowName: 'wf', status: 'running' }],\n      cancelMany: cancelMany as any,\n    });\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 50,\n      confirm: false,\n      logger,\n      promptConfirm: async () => false,\n    });\n\n    expect(exitCode).toBe(0);\n    expect(logs).toContain('Aborted.');\n    expect(cancelMany).not.toHaveBeenCalled();\n  });\n});\n"]}

package/dist/lib/config/log.js

@@ -93,4 +93,4 @@ class Logger {
     };
 }
 export const logger = new Logger();
-//# sourceMappingURL=log.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log.js","sourceRoot":"","sources":["../../../src/lib/config/log.ts"],"names":[],"mappings":"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","sourcesContent":["import boxen from 'boxen';\nimport chalk from 'chalk';\n\nexport const LOGGING_CONFIG = {\n  JSON_MODE: false,\n  VERBOSE_MODE: false,\n};\n\nexport const setJsonMode = (value: boolean) => {\n  LOGGING_CONFIG.JSON_MODE = Boolean(value);\n  process.env.WORKFLOW_JSON_MODE = value ? '1' : '';\n};\n\nexport const setVerboseMode = (value: boolean) => {\n  LOGGING_CONFIG.VERBOSE_MODE = Boolean(value);\n};\n\n/**\n * This Logger should be unified with `core/src/logger.ts`. The main difference\n * is that the CLI logger has internal handling on JSON/VERBOSE modes, but\n * does not implement per-module logging and debug levels.\n *\n * There are four modes of operation:\n * - Regular (both JSON and VERBOSE modes are off)\n * - JSON mode (JSON mode is on, VERBOSE mode is off)\n * - verbose mode (JSON mode is off, VERBOSE mode is on)\n * - verbose JSON mode (JSON and VERBOSE modes are on)\n *\n * Generally, we want to hide debug logs unless verbose mode is on,\n * and during JSON mode, we want to ensure no logs end up in stdout,\n * because we assume the user might be piping the output to a JSON parser.\n * However, during verbose JSON mode, we want to keep debug information\n * without breaking the JSON output, so we redirect all logs to stderr.\n */\nclass Logger {\n  constructor() {}\n\n  shouldLogToStderr = () => {\n    return LOGGING_CONFIG.JSON_MODE;\n  };\n\n  shouldSkipDebugLogs = () => {\n    return !LOGGING_CONFIG.VERBOSE_MODE;\n  };\n\n  private logPlain = (...args: any[]) => {\n    if (this.shouldLogToStderr()) {\n      console.error(...args);\n      return;\n    }\n    console.log(...args);\n  };\n\n  private logDebug = (...args: any[]) => {\n    if (this.shouldLogToStderr()) {\n      console.error(...args);\n      return;\n    }\n    if (this.shouldSkipDebugLogs()) {\n      return;\n    }\n    console.debug(...args);\n  };\n\n  private logWarn = (...args: any[]) => {\n    if (this.shouldLogToStderr()) {\n      console.error(...args);\n      return;\n    }\n    console.warn(...args);\n  };\n\n  private logError = (...args: any[]) => {\n    console.error(...args);\n  };\n\n  log = (...args: any[]) => {\n    this.logPlain(...args);\n  };\n\n  info = (...args: any[]) => {\n    this.logPlain(chalk.white(`[Info]`, ...args));\n  };\n\n  success = (...args: any[]) => {\n    this.logPlain(chalk.green(`[Success]`, ...args));\n  };\n\n  debug = (...args: any[]) => {\n    this.logDebug(chalk.gray(`[Debug]`, ...args));\n  };\n\n  warn = (...args: any[]) => {\n    this.logWarn(chalk.yellow(`[Warn]`, ...args));\n  };\n\n  error = (...args: any[]) => {\n    this.logError(chalk.red(`[Error]`, ...args));\n  };\n\n  showBox = (\n    color: 'yellow' | 'green' | 'white',\n    ...lines: (string | undefined)[]\n  ) => {\n    const borderColor =\n      color === 'yellow' ? 'yellow' : color === 'green' ? 'green' : 'white';\n    const content = lines.filter((line) => line !== undefined).join('\\n');\n    const box = boxen(content, {\n      padding: 1,\n      borderColor: borderColor as any,\n      textAlignment: 'center',\n    });\n    this.logPlain(box);\n  };\n}\n\nexport const logger = new Logger();\n"]}

package/dist/lib/config/types.d.ts

@@ -1,3 +1,4 @@
+import type { WorkflowRunStatus } from '@workflow/world';
 export type { BuildTarget, WorkflowConfig, } from '@workflow/builders';
 export { isValidBuildTarget, validBuildTargets, } from '@workflow/builders';
 export type InspectCLIOptions = {
@@ -10,7 +11,11 @@ export type InspectCLIOptions = {
     sort?: 'asc' | 'desc';
     limit?: number;
     workflowName?: string;
-    status?: string;
+    status?: WorkflowRunStatus;
+    /** Listing window start: relative duration (12h, 7d) or timestamp (runs only) */
+    since?: string;
+    /** Listing window end: relative duration or timestamp; requires --since */
+    until?: string;
     withData?: boolean;
     backend?: string;
     disableRelativeDates?: boolean;

package/dist/lib/config/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/config/types.ts"],"names":[],"mappings":"AACA,YAAY,EACV,WAAW,EACX,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/config/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,YAAY,EACV,WAAW,EACX,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC"}

package/dist/lib/config/types.js

@@ -1,2 +1,2 @@
 export { isValidBuildTarget, validBuildTargets, } from '@workflow/builders';
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NvbmZpZy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFPQSxPQUFPLEVBQ0wsa0JBQWtCLEVBQ2xCLGlCQUFpQixHQUNsQixNQUFNLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gUmUtZXhwb3J0IGJ1aWxkZXIgdHlwZXMgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5XG5pbXBvcnQgdHlwZSB7IFdvcmtmbG93UnVuU3RhdHVzIH0gZnJvbSAnQHdvcmtmbG93L3dvcmxkJztcblxuZXhwb3J0IHR5cGUge1xuICBCdWlsZFRhcmdldCxcbiAgV29ya2Zsb3dDb25maWcsXG59IGZyb20gJ0B3b3JrZmxvdy9idWlsZGVycyc7XG5leHBvcnQge1xuICBpc1ZhbGlkQnVpbGRUYXJnZXQsXG4gIHZhbGlkQnVpbGRUYXJnZXRzLFxufSBmcm9tICdAd29ya2Zsb3cvYnVpbGRlcnMnO1xuXG5leHBvcnQgdHlwZSBJbnNwZWN0Q0xJT3B0aW9ucyA9IHtcbiAganNvbj86IGJvb2xlYW47XG4gIHdhdGNoPzogYm9vbGVhbjtcbiAgcnVuSWQ/OiBzdHJpbmc7XG4gIHN0ZXBJZD86IHN0cmluZztcbiAgaG9va0lkPzogc3RyaW5nO1xuICBjdXJzb3I/OiBzdHJpbmc7XG4gIHNvcnQ/OiAnYXNjJyB8ICdkZXNjJztcbiAgbGltaXQ/OiBudW1iZXI7XG4gIHdvcmtmbG93TmFtZT86IHN0cmluZztcbiAgc3RhdHVzPzogV29ya2Zsb3dSdW5TdGF0dXM7XG4gIC8qKiBMaXN0aW5nIHdpbmRvdyBzdGFydDogcmVsYXRpdmUgZHVyYXRpb24gKDEyaCwgN2QpIG9yIHRpbWVzdGFtcCAocnVucyBvbmx5KSAqL1xuICBzaW5jZT86IHN0cmluZztcbiAgLyoqIExpc3Rpbmcgd2luZG93IGVuZDogcmVsYXRpdmUgZHVyYXRpb24gb3IgdGltZXN0YW1wOyByZXF1aXJlcyAtLXNpbmNlICovXG4gIHVudGlsPzogc3RyaW5nO1xuICB3aXRoRGF0YT86IGJvb2xlYW47XG4gIGJhY2tlbmQ/OiBzdHJpbmc7XG4gIGRpc2FibGVSZWxhdGl2ZURhdGVzPzogYm9vbGVhbjtcbiAgaW50ZXJhY3RpdmU/OiBib29sZWFuO1xuICAvKiogV2hlbiB0cnVlLCBkZWNyeXB0IGVuY3J5cHRlZCB2YWx1ZXMgKHRyaWdnZXJzIGF1ZGl0LWxvZ2dlZCBrZXkgcmV0cmlldmFsKSAqL1xuICBkZWNyeXB0PzogYm9vbGVhbjtcbn07XG4iXX0=

package/dist/lib/config/workflow-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-config.d.ts","sourceRoot":"","sources":["../../../src/lib/config/workflow-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAa9D,eAAO,MAAM,iBAAiB,GAC5B,qCAGG;IACD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAG3B,mBAeF,CAAC"}
+{"version":3,"file":"workflow-config.d.ts","sourceRoot":"","sources":["../../../src/lib/config/workflow-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAY9D,eAAO,MAAM,iBAAiB,GAC5B,qCAGG;IACD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAG3B,mBAeF,CAAC"}

package/dist/lib/config/workflow-config.js

@@ -15,7 +15,7 @@ export const getWorkflowConfig = ({ buildTarget, workflowManifest, } = {
         dirs: ['./workflows'],
         workingDir: resolveObservabilityCwd(),
         buildTarget: buildTarget,
-        stepsBundlePath: './.well-known/workflow/v1/step.mjs',
+        stepsBundlePath: './.well-known/workflow/v1/__step_registrations.mjs',
         workflowsBundlePath: './.well-known/workflow/v1/flow.mjs',
         webhookBundlePath: './.well-known/workflow/v1/webhook.mjs',
         workflowManifestPath: workflowManifest,
@@ -24,4 +24,4 @@ export const getWorkflowConfig = ({ buildTarget, workflowManifest, } = {
     };
     return config;
 };
-//# sourceMappingURL=workflow-config.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/inspect/auth.js

@@ -74,4 +74,4 @@ export async function getAuthToken() {
         return null;
     }
 }
-//# sourceMappingURL=auth.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/inspect/env.d.ts

@@ -4,7 +4,7 @@
  * Used by the CLI to configure environment variables that are read by
  * various subsystems (e.g., WORKFLOW_TARGET_WORLD, WORKFLOW_LOCAL_DATA_DIR).
  * Note: WORKFLOW_VERCEL_* env vars are read back via getEnvVars() and passed
- * to createVercelWorld() explicitly — they are NOT read by createWorld().
+ * to @workflow/world-vercel's createWorld() explicitly — they are NOT read by runtime createWorld().
  */
 export declare const writeEnvVars: (envVars: Record<string, string>) => void;
 export declare const getEnvVars: () => Record<string, string>;

package/dist/lib/inspect/env.js

@@ -12,7 +12,7 @@ import { findRepoRoot, getProjectLink, isOneOfErrNoExceptions, } from './vercel-
  * Used by the CLI to configure environment variables that are read by
  * various subsystems (e.g., WORKFLOW_TARGET_WORLD, WORKFLOW_LOCAL_DATA_DIR).
  * Note: WORKFLOW_VERCEL_* env vars are read back via getEnvVars() and passed
- * to createVercelWorld() explicitly — they are NOT read by createWorld().
+ * to @workflow/world-vercel's createWorld() explicitly — they are NOT read by runtime createWorld().
  */
 export const writeEnvVars = (envVars) => {
     Object.entries(envVars).forEach(([key, value]) => {
@@ -223,4 +223,4 @@ export const inferVercelEnvVars = async () => {
         teamId: envVars.WORKFLOW_VERCEL_TEAM || undefined,
     };
 };
-//# sourceMappingURL=env.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env.js","sourceRoot":"","sources":["../../../src/lib/inspect/env.ts"],"names":[],"mappings":"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","sourcesContent":["import { access } from 'node:fs/promises';\nimport { join, resolve } from 'node:path';\nimport { findWorkflowDataDir } from '@workflow/utils/check-data-dir';\nimport { logger } from '../config/log.js';\nimport { getWorkflowConfig } from '../config/workflow-config.js';\nimport { getAuthToken } from './auth.js';\nimport { fetchTeamInfo } from './vercel-api.js';\nimport {\n  findRepoRoot,\n  getProjectLink,\n  isOneOfErrNoExceptions,\n  type ProjectLink,\n} from './vercel-link.js';\n\n/**\n * Overwrite values on process.env with the given values (if not undefined)\n *\n * Used by the CLI to configure environment variables that are read by\n * various subsystems (e.g., WORKFLOW_TARGET_WORLD, WORKFLOW_LOCAL_DATA_DIR).\n * Note: WORKFLOW_VERCEL_* env vars are read back via getEnvVars() and passed\n * to @workflow/world-vercel's createWorld() explicitly — they are NOT read by runtime createWorld().\n */\nexport const writeEnvVars = (envVars: Record<string, string>) => {\n  Object.entries(envVars).forEach(([key, value]) => {\n    if (\n      value === undefined ||\n      value === null ||\n      value === '' ||\n      value === 'undefined'\n    ) {\n      return;\n    }\n    process.env[key] = value;\n  });\n};\n\nexport const getEnvVars = (): Record<string, string> => {\n  const env = process.env;\n  return {\n    WORKFLOW_TARGET_WORLD: env.WORKFLOW_TARGET_WORLD || '',\n    WORKFLOW_VERCEL_ENV: env.WORKFLOW_VERCEL_ENV || '',\n    WORKFLOW_VERCEL_AUTH_TOKEN: env.WORKFLOW_VERCEL_AUTH_TOKEN || '',\n    WORKFLOW_VERCEL_PROJECT: env.WORKFLOW_VERCEL_PROJECT || '',\n    WORKFLOW_VERCEL_PROJECT_NAME: env.WORKFLOW_VERCEL_PROJECT_NAME || '',\n    WORKFLOW_VERCEL_TEAM: env.WORKFLOW_VERCEL_TEAM || '',\n    WORKFLOW_LOCAL_BASE_URL: env.WORKFLOW_LOCAL_BASE_URL || '',\n    WORKFLOW_LOCAL_UI: env.WORKFLOW_LOCAL_UI || '',\n    PORT: env.PORT || '',\n    WORKFLOW_LOCAL_DATA_DIR: env.WORKFLOW_LOCAL_DATA_DIR || '',\n    WORKFLOW_MANIFEST_PATH: env.WORKFLOW_MANIFEST_PATH || '',\n  };\n};\n\nconst possibleManifestPaths = [\n  'app/.well-known/workflow/v1/manifest.json',\n  'src/app/.well-known/workflow/v1/manifest.json',\n  '.well-known/workflow/v1/manifest.json',\n];\n\nasync function findManifestPath(cwd: string) {\n  for (const path of possibleManifestPaths) {\n    const fullPath = join(cwd, path);\n    if (\n      await access(fullPath)\n        .then(() => true)\n        .catch(() => false)\n    ) {\n      const absolutePath = resolve(fullPath);\n      logger.debug('Found workflow manifest:', absolutePath);\n      return absolutePath;\n    }\n  }\n}\n\n/**\n * Overwrites process.env variables related to local world configuration,\n * if relevant environment variables aren't set already.\n *\n * Throws if the workflow data directory can not be found.\n */\nexport const inferLocalWorldEnvVars = async () => {\n  const envVars = getEnvVars();\n  const cwd = getWorkflowConfig().workingDir;\n  let repoRoot: string | undefined;\n\n  // Always expose the effective working directory to the web UI/server-side helpers.\n  // This is especially useful when developing the web UI from the workflow repo\n  // while targeting another project directory.\n  if (!process.env.WORKFLOW_OBSERVABILITY_CWD) {\n    writeEnvVars({ WORKFLOW_OBSERVABILITY_CWD: cwd });\n  }\n\n  // Set default base URL for local queue if not already configured\n  // We use WORKFLOW_LOCAL_BASE_URL instead of PORT to avoid conflicts\n  // with other tools (like Next.js) that also use the PORT env var\n  if (!envVars.WORKFLOW_LOCAL_BASE_URL && !envVars.PORT) {\n    logger.debug(\n      'Using default queue target http://localhost:3000, set WORKFLOW_LOCAL_BASE_URL or PORT to override.'\n    );\n    envVars.WORKFLOW_LOCAL_BASE_URL = 'http://localhost:3000';\n    writeEnvVars(envVars);\n  }\n\n  // Infer workflow data directory\n  if (!envVars.WORKFLOW_LOCAL_DATA_DIR) {\n    const localResult = await findWorkflowDataDir(cwd);\n    if (localResult.dataDir) {\n      logger.debug('Found workflow data directory:', localResult.dataDir);\n      envVars.WORKFLOW_LOCAL_DATA_DIR = localResult.dataDir;\n      writeEnvVars(envVars);\n    } else {\n      // As a fallback, find the repo root, and try to infer the data dir from there\n      repoRoot = await findRepoRoot(cwd, cwd);\n      if (repoRoot) {\n        const repoResult = await findWorkflowDataDir(repoRoot);\n        if (repoResult.dataDir) {\n          logger.debug('Found workflow data directory:', repoResult.dataDir);\n          envVars.WORKFLOW_LOCAL_DATA_DIR = repoResult.dataDir;\n          writeEnvVars(envVars);\n        }\n      }\n      if (!envVars.WORKFLOW_LOCAL_DATA_DIR) {\n        const message = `No workflow data directory found in \"${cwd}\". Have you run any workflows yet?`;\n        throw new Error(message);\n      }\n    }\n  }\n\n  // Infer workflow manifest path (for Graph tab in web UI)\n  if (!envVars.WORKFLOW_MANIFEST_PATH) {\n    const localManifest = await findManifestPath(cwd);\n    if (localManifest) {\n      envVars.WORKFLOW_MANIFEST_PATH = localManifest;\n      writeEnvVars(envVars);\n      logger.debug(`Found workflow manifest at: ${localManifest}`);\n    } else {\n      // As a fallback, find the repo root, and try to infer the manifest from there\n      if (!repoRoot) {\n        repoRoot = await findRepoRoot(cwd, cwd);\n      }\n      if (repoRoot) {\n        const repoManifest = await findManifestPath(repoRoot);\n        if (repoManifest) {\n          envVars.WORKFLOW_MANIFEST_PATH = repoManifest;\n          writeEnvVars(envVars);\n          logger.debug(`Found workflow manifest at: ${repoManifest}`);\n        }\n      }\n\n      // It's okay if manifest is not found - the web UI will just show empty workflows\n      if (!envVars.WORKFLOW_MANIFEST_PATH) {\n        logger.debug(\n          'No workflow manifest found. Workflows tab will be empty.'\n        );\n      }\n    }\n  }\n};\n\nexport const inferVercelProjectAndTeam = async () => {\n  const cwd = getWorkflowConfig().workingDir;\n  let project: ProjectLink | null = null;\n  try {\n    logger.debug(`Inferring project and team from CWD: ${cwd}`);\n    project = await getProjectLink(cwd);\n  } catch (error) {\n    if (!isOneOfErrNoExceptions(error, ['ENOENT'])) {\n      throw error;\n    }\n  }\n  if (!project) {\n    logger.debug('Could not find project link folder');\n    return;\n  }\n  logger.debug(`Found project ${project.projectId} and team ${project.orgId}`);\n  return {\n    projectId: project.projectId,\n    projectName: project.projectName,\n    teamId: project.orgId,\n  };\n};\n\nexport interface VercelEnvVars {\n  token?: string;\n  environment?: string;\n  projectId?: string;\n  projectName?: string;\n  teamId?: string;\n}\n\n/**\n * Infers Vercel World configuration from the local environment (`.vercel`\n * folder, CLI auth file, Vercel API) and returns a resolved config object.\n *\n * Also writes the resolved values to `process.env` so the embedded web UI\n * (which reads `process.env` as a fallback) can pick them up.\n */\nexport const inferVercelEnvVars = async (): Promise<VercelEnvVars> => {\n  const envVars = getEnvVars();\n\n  // Infer project/team from .vercel folder when:\n  // - WORKFLOW_VERCEL_PROJECT or WORKFLOW_VERCEL_TEAM is missing, OR\n  // - WORKFLOW_VERCEL_PROJECT is set but doesn't look like a real project ID\n  //   (e.g., user passed a slug via --project flag), OR\n  // - WORKFLOW_VERCEL_PROJECT_NAME is missing (need to populate the slug)\n  const needsInference =\n    !envVars.WORKFLOW_VERCEL_PROJECT ||\n    !envVars.WORKFLOW_VERCEL_TEAM ||\n    !envVars.WORKFLOW_VERCEL_PROJECT_NAME ||\n    !envVars.WORKFLOW_VERCEL_PROJECT.startsWith('prj_');\n\n  if (needsInference) {\n    logger.debug('Inferring vercel project and team from .vercel folder');\n    const inferredProject = await inferVercelProjectAndTeam();\n    if (inferredProject) {\n      const { projectId, projectName, teamId } = inferredProject;\n      // WORKFLOW_VERCEL_PROJECT is the real project ID (e.g., prj_xxx)\n      envVars.WORKFLOW_VERCEL_PROJECT = projectId;\n      // WORKFLOW_VERCEL_PROJECT_NAME is the project slug (e.g., my-app)\n      envVars.WORKFLOW_VERCEL_PROJECT_NAME = projectName || projectId;\n      envVars.WORKFLOW_VERCEL_TEAM = envVars.WORKFLOW_VERCEL_TEAM || teamId;\n    } else {\n      logger.warn(\n        'Could not infer vercel project and team from .vercel folder, server authentication might fail.'\n      );\n    }\n  }\n\n  if (!envVars.WORKFLOW_VERCEL_AUTH_TOKEN) {\n    logger.debug('Inferring vercel auth token from CLI auth file');\n    const token = await getAuthToken();\n    if (!token) {\n      throw new Error('Could not find credentials. Run `vc login` to log in.');\n    }\n    envVars.WORKFLOW_VERCEL_AUTH_TOKEN = token;\n  }\n\n  // Fetch team information from Vercel API to get the team slug\n  // TODO: Sadly, in order to redirect to Vercel dashboard correctly, we need to\n  // resolve the team name, which is a whole API request. The alternative would be to\n  // change front to allow passing in the team slug directly, or add some generic redirect.\n  if (envVars.WORKFLOW_VERCEL_TEAM && envVars.WORKFLOW_VERCEL_AUTH_TOKEN) {\n    logger.info('Vercel project detected. Loading project data...');\n    logger.debug('Fetching team information from Vercel API');\n    const teamInfo = await fetchTeamInfo(\n      envVars.WORKFLOW_VERCEL_TEAM,\n      envVars.WORKFLOW_VERCEL_AUTH_TOKEN\n    );\n    if (teamInfo) {\n      envVars.WORKFLOW_VERCEL_TEAM = teamInfo.teamSlug;\n      logger.debug(`Found team slug: ${teamInfo.teamSlug}`);\n    }\n  }\n\n  // Write resolved values to process.env for the embedded web UI, which\n  // reads them as fallbacks in its server actions.\n  writeEnvVars(envVars);\n\n  return {\n    token: envVars.WORKFLOW_VERCEL_AUTH_TOKEN || undefined,\n    environment: envVars.WORKFLOW_VERCEL_ENV || undefined,\n    projectId: envVars.WORKFLOW_VERCEL_PROJECT || undefined,\n    projectName: envVars.WORKFLOW_VERCEL_PROJECT_NAME || undefined,\n    teamId: envVars.WORKFLOW_VERCEL_TEAM || undefined,\n  };\n};\n"]}

package/dist/lib/inspect/errors.d.ts

@@ -0,0 +1,3 @@
+export declare const isObservabilityUpgradeRequiredError: (error: unknown) => boolean;
+export declare const getObservabilityUpgradeRequiredMessage: () => string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/inspect/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/errors.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,mCAAmC,GAC9C,OAAO,OAAO,KACb,OAUF,CAAC;AAEF,eAAO,MAAM,sCAAsC,QAAO,MAClB,CAAC"}