@workflow/cli 5.0.0-beta.27 → 5.0.0-beta.29

package/dist/lib/inspect/output.test.js

@@ -1,5 +1,6 @@
-import { describe, expect, it } from 'vitest';
-import { formatTableValue, hasExpiredData } from './output.js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getObservabilityUpgradeRequiredMessage, isObservabilityUpgradeRequiredError, } from './errors.js';
+import { formatTableValue, hasExpiredData, listEvents, listRuns, listSleeps, listSteps, } from './output.js';
 const makeRun = (overrides = {}) => ({
     runId: 'run-1',
     status: 'running',
@@ -17,6 +18,9 @@ const makeRun = (overrides = {}) => ({
     executionContext: {},
     ...overrides,
 });
+afterEach(() => {
+    vi.restoreAllMocks();
+});
 describe('hasExpiredData', () => {
     it('returns false when expiredAt is undefined', () => {
         expect(hasExpiredData(makeRun({ expiredAt: undefined }))).toBe(false);
@@ -49,4 +53,400 @@ describe('formatTableValue expired data handling', () => {
         expect(String(result)).not.toContain('expired');
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+describe('isObservabilityUpgradeRequiredError', () => {
+    it('detects workflow analytics 402 errors by top-level code', () => {
+        expect(isObservabilityUpgradeRequiredError({
+            status: 402,
+            code: 'observability-upgrade-required',
+        })).toBe(true);
+    });
+    it('detects workflow analytics 402 errors by response body error', () => {
+        expect(isObservabilityUpgradeRequiredError({
+            status: 402,
+            body: { error: 'observability-upgrade-required' },
+        })).toBe(true);
+    });
+    it('does not treat 404s as upgrade prompts', () => {
+        expect(isObservabilityUpgradeRequiredError({
+            status: 404,
+            code: 'observability-upgrade-required',
+        })).toBe(false);
+    });
+    it('uses an upgrade prompt message', () => {
+        expect(getObservabilityUpgradeRequiredMessage()).toContain('Upgrade Observability Plus');
+    });
+});
+describe('listRuns', () => {
+    it('preserves analytics page metadata in JSON output', async () => {
+        const run = {
+            runId: 'run-1',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const pageInfo = {
+            currentLookbackDays: 2,
+            maxLookbackDays: 30,
+            currentWindowStart: new Date('2026-06-28T00:00:00.000Z'),
+            maxWindowStart: new Date('2026-06-01T00:00:00.000Z'),
+            upgradeAvailable: true,
+        };
+        const world = {
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                        pageInfo,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listRuns(world, { json: true });
+        expect(world.analytics?.runs.list).toHaveBeenCalledWith({
+            workflowName: undefined,
+            status: undefined,
+            pagination: {
+                sortOrder: 'desc',
+                cursor: undefined,
+                limit: 20,
+            },
+        });
+        expect(write).toHaveBeenCalledTimes(1);
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual({
+            data: [
+                {
+                    ...run,
+                    createdAt: '2026-06-30T00:00:00.000Z',
+                    updatedAt: '2026-06-30T00:00:00.000Z',
+                    startedAt: '2026-06-30T00:00:01.000Z',
+                },
+            ],
+            cursor: null,
+            hasMore: false,
+            pageInfo: {
+                currentLookbackDays: 2,
+                maxLookbackDays: 30,
+                currentWindowStart: '2026-06-28T00:00:00.000Z',
+                maxWindowStart: '2026-06-01T00:00:00.000Z',
+                upgradeAvailable: true,
+            },
+        });
+    });
+});
+describe('listSteps', () => {
+    it('passes cursors and preserves the JSON array output', async () => {
+        const step = {
+            runId: 'run-1',
+            stepId: 'step-1',
+            stepName: 'doWork',
+            status: 'completed',
+            attempt: 1,
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:02.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: new Date('2026-06-30T00:00:02.000Z'),
+            retryAfter: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            analytics: {
+                steps: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [step],
+                        cursor: 'next-step-cursor',
+                        hasMore: true,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listSteps(world, {
+            json: true,
+            runId: 'run-1',
+            cursor: 'step-cursor',
+            limit: 1,
+        });
+        expect(world.analytics?.steps.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            pagination: {
+                sortOrder: 'desc',
+                cursor: 'step-cursor',
+                limit: 1,
+            },
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...step,
+                createdAt: '2026-06-30T00:00:00.000Z',
+                updatedAt: '2026-06-30T00:00:02.000Z',
+                startedAt: '2026-06-30T00:00:01.000Z',
+                completedAt: '2026-06-30T00:00:02.000Z',
+            },
+        ]);
+    });
+    it('falls back to storage when the first analytics page is empty', async () => {
+        const step = {
+            runId: 'run-1',
+            stepId: 'step-1',
+            stepName: 'step//./src/workflows/test//doWork',
+            status: 'completed',
+            attempt: 1,
+            input: undefined,
+            output: undefined,
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:02.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: new Date('2026-06-30T00:00:02.000Z'),
+        };
+        const world = {
+            analytics: {
+                steps: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+            steps: {
+                list: vi.fn().mockResolvedValue({
+                    data: [step],
+                    cursor: null,
+                    hasMore: false,
+                }),
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listSteps(world, { json: true, runId: 'run-1' });
+        expect(world.analytics?.steps.list).toHaveBeenCalled();
+        expect(world.steps.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            pagination: {
+                sortOrder: 'desc',
+                cursor: undefined,
+                limit: 20,
+            },
+            resolveData: 'none',
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...step,
+                createdAt: '2026-06-30T00:00:00.000Z',
+                updatedAt: '2026-06-30T00:00:02.000Z',
+                startedAt: '2026-06-30T00:00:01.000Z',
+                completedAt: '2026-06-30T00:00:02.000Z',
+            },
+        ]);
+    });
+});
+describe('listEvents', () => {
+    it('passes cursors and preserves the JSON array output', async () => {
+        const event = {
+            runId: 'run-1',
+            eventId: 'event-1',
+            eventType: 'step_completed',
+            correlationId: 'step-1',
+            entityId: 'step-1',
+            stepName: 'doWork',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            deploymentId: 'dep-1',
+            specVersion: 2,
+            runCreatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            createdAt: new Date('2026-06-30T00:00:02.000Z'),
+            region: null,
+            vercelId: null,
+            requestId: null,
+            resumeAt: null,
+            retryAfter: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            isWebhook: false,
+            isSystem: false,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            analytics: {
+                events: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [event],
+                        cursor: 'next-event-cursor',
+                        hasMore: true,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listEvents(world, {
+            json: true,
+            runId: 'run-1',
+            cursor: 'event-cursor',
+            limit: 1,
+        });
+        expect(world.analytics?.events.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            correlationId: undefined,
+            pagination: {
+                sortOrder: 'desc',
+                cursor: 'event-cursor',
+                limit: 1,
+            },
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...event,
+                runCreatedAt: '2026-06-30T00:00:00.000Z',
+                createdAt: '2026-06-30T00:00:02.000Z',
+            },
+        ]);
+    });
+    it('falls back to storage when the first analytics page is empty', async () => {
+        const event = {
+            runId: 'run-1',
+            eventId: 'event-1',
+            eventType: 'step_completed',
+            correlationId: 'step-1',
+            eventData: {
+                stepName: 'doWork',
+                result: undefined,
+            },
+            createdAt: new Date('2026-06-30T00:00:02.000Z'),
+        };
+        const world = {
+            analytics: {
+                events: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+            events: {
+                list: vi.fn().mockResolvedValue({
+                    data: [event],
+                    cursor: null,
+                    hasMore: false,
+                }),
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listEvents(world, { json: true, runId: 'run-1' });
+        expect(world.analytics?.events.list).toHaveBeenCalled();
+        expect(world.events.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            pagination: {
+                sortOrder: 'desc',
+                cursor: undefined,
+                limit: 20,
+            },
+            resolveData: 'none',
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...event,
+                createdAt: '2026-06-30T00:00:02.000Z',
+            },
+        ]);
+    });
+});
+describe('listSleeps', () => {
+    const wait = {
+        runId: 'run-1',
+        waitId: 'wait-1',
+        status: 'waiting',
+        resumeAt: new Date('2026-06-30T00:01:00.000Z'),
+        createdAt: new Date('2026-06-30T00:00:00.000Z'),
+        updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+        completedAt: null,
+        workflowCoreVersion: null,
+        workflowEncryptionEnabled: false,
+    };
+    const pageInfo = {
+        currentLookbackDays: 2,
+        maxLookbackDays: 30,
+        currentWindowStart: new Date('2026-06-28T00:00:00.000Z'),
+        maxWindowStart: new Date('2026-06-01T00:00:00.000Z'),
+        upgradeAvailable: true,
+    };
+    it('passes cursors and preserves the JSON array output through analytics', async () => {
+        const world = {
+            analytics: {
+                waits: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [wait],
+                        cursor: 'next-wait-cursor',
+                        hasMore: true,
+                        pageInfo,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listSleeps(world, {
+            json: true,
+            runId: 'run-1',
+            cursor: 'wait-cursor',
+            limit: 1,
+        });
+        expect(world.analytics?.waits.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            pagination: {
+                sortOrder: 'desc',
+                cursor: 'wait-cursor',
+                limit: 1,
+            },
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...wait,
+                resumeAt: '2026-06-30T00:01:00.000Z',
+                createdAt: '2026-06-30T00:00:00.000Z',
+                updatedAt: '2026-06-30T00:00:00.000Z',
+            },
+        ]);
+    });
+    it('surfaces the observability upgrade hint in table mode', async () => {
+        const world = {
+            analytics: {
+                waits: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [wait],
+                        cursor: null,
+                        hasMore: false,
+                        pageInfo,
+                    }),
+                },
+            },
+        };
+        const log = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        await listSleeps(world, { runId: 'run-1' });
+        expect(log.mock.calls.flat().join('\n')).toContain('Upgrade Observability Plus');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"output.test.js","sourceRoot":"","sources":["../../../src/lib/inspect/output.test.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  AnalyticsEvent,\n  AnalyticsRun,\n  AnalyticsStep,\n  AnalyticsWait,\n  Event,\n  Step,\n  WorkflowRun,\n  World,\n} from '@workflow/world';\nimport { afterEach, describe, expect, it, vi } from 'vitest';\nimport {\n  getObservabilityUpgradeRequiredMessage,\n  isObservabilityUpgradeRequiredError,\n} from './errors.js';\nimport {\n  formatTableValue,\n  hasExpiredData,\n  listEvents,\n  listRuns,\n  listSleeps,\n  listSteps,\n} from './output.js';\n\nconst makeRun = (overrides: Partial<WorkflowRun> = {}): WorkflowRun =>\n  ({\n    runId: 'run-1',\n    status: 'running',\n    deploymentId: 'dep-1',\n    workflowName: 'workflow//./src/workflows/test//myWorkflow',\n    input: undefined,\n    output: undefined,\n    error: undefined,\n    createdAt: new Date('2025-01-01'),\n    updatedAt: new Date('2025-01-01'),\n    completedAt: undefined,\n    startedAt: undefined,\n    expiredAt: undefined,\n    specVersion: 2,\n    executionContext: {},\n    ...overrides,\n  }) as unknown as WorkflowRun;\n\nafterEach(() => {\n  vi.restoreAllMocks();\n});\n\ndescribe('hasExpiredData', () => {\n  it('returns false when expiredAt is undefined', () => {\n    expect(hasExpiredData(makeRun({ expiredAt: undefined }))).toBe(false);\n  });\n\n  it('returns false when expiredAt is in the future', () => {\n    const future = new Date(Date.now() + 24 * 60 * 60 * 1000);\n    expect(hasExpiredData(makeRun({ expiredAt: future }))).toBe(false);\n  });\n\n  it('returns true when expiredAt is in the past', () => {\n    const past = new Date(Date.now() - 24 * 60 * 60 * 1000);\n    expect(hasExpiredData(makeRun({ expiredAt: past }))).toBe(true);\n  });\n});\n\ndescribe('formatTableValue expired data handling', () => {\n  it('returns input value when expiredAt is in the future', () => {\n    const future = new Date(Date.now() + 24 * 60 * 60 * 1000);\n    const item = { expiredAt: future.toISOString(), input: 'hello' };\n    const result = formatTableValue('input', 'hello', {}, undefined, item);\n    expect(result).not.toContain('expired');\n  });\n\n  it('returns expired message when expiredAt is in the past', () => {\n    const past = new Date(Date.now() - 24 * 60 * 60 * 1000);\n    const item = { expiredAt: past.toISOString(), output: 'hello' };\n    const result = formatTableValue('output', 'hello', {}, undefined, item);\n    expect(String(result)).toContain('data expired');\n  });\n\n  it('returns input value when expiredAt is not present', () => {\n    const item = { input: 'hello' };\n    const result = formatTableValue('input', 'hello', {}, undefined, item);\n    expect(String(result)).not.toContain('expired');\n  });\n});\n\ndescribe('isObservabilityUpgradeRequiredError', () => {\n  it('detects workflow analytics 402 errors by top-level code', () => {\n    expect(\n      isObservabilityUpgradeRequiredError({\n        status: 402,\n        code: 'observability-upgrade-required',\n      })\n    ).toBe(true);\n  });\n\n  it('detects workflow analytics 402 errors by response body error', () => {\n    expect(\n      isObservabilityUpgradeRequiredError({\n        status: 402,\n        body: { error: 'observability-upgrade-required' },\n      })\n    ).toBe(true);\n  });\n\n  it('does not treat 404s as upgrade prompts', () => {\n    expect(\n      isObservabilityUpgradeRequiredError({\n        status: 404,\n        code: 'observability-upgrade-required',\n      })\n    ).toBe(false);\n  });\n\n  it('uses an upgrade prompt message', () => {\n    expect(getObservabilityUpgradeRequiredMessage()).toContain(\n      'Upgrade Observability Plus'\n    );\n  });\n});\n\ndescribe('listRuns', () => {\n  it('preserves analytics page metadata in JSON output', async () => {\n    const run = {\n      runId: 'run-1',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const pageInfo = {\n      currentLookbackDays: 2,\n      maxLookbackDays: 30,\n      currentWindowStart: new Date('2026-06-28T00:00:00.000Z'),\n      maxWindowStart: new Date('2026-06-01T00:00:00.000Z'),\n      upgradeAvailable: true,\n    };\n    const world = {\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n            pageInfo,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listRuns(world, { json: true });\n\n    expect(world.analytics?.runs.list).toHaveBeenCalledWith({\n      workflowName: undefined,\n      status: undefined,\n      pagination: {\n        sortOrder: 'desc',\n        cursor: undefined,\n        limit: 20,\n      },\n    });\n    expect(write).toHaveBeenCalledTimes(1);\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual({\n      data: [\n        {\n          ...run,\n          createdAt: '2026-06-30T00:00:00.000Z',\n          updatedAt: '2026-06-30T00:00:00.000Z',\n          startedAt: '2026-06-30T00:00:01.000Z',\n        },\n      ],\n      cursor: null,\n      hasMore: false,\n      pageInfo: {\n        currentLookbackDays: 2,\n        maxLookbackDays: 30,\n        currentWindowStart: '2026-06-28T00:00:00.000Z',\n        maxWindowStart: '2026-06-01T00:00:00.000Z',\n        upgradeAvailable: true,\n      },\n    });\n  });\n});\n\ndescribe('listSteps', () => {\n  it('passes cursors and preserves the JSON array output', async () => {\n    const step = {\n      runId: 'run-1',\n      stepId: 'step-1',\n      stepName: 'doWork',\n      status: 'completed',\n      attempt: 1,\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:02.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: new Date('2026-06-30T00:00:02.000Z'),\n      retryAfter: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsStep;\n    const world = {\n      analytics: {\n        steps: {\n          list: vi.fn().mockResolvedValue({\n            data: [step],\n            cursor: 'next-step-cursor',\n            hasMore: true,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listSteps(world, {\n      json: true,\n      runId: 'run-1',\n      cursor: 'step-cursor',\n      limit: 1,\n    });\n\n    expect(world.analytics?.steps.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      pagination: {\n        sortOrder: 'desc',\n        cursor: 'step-cursor',\n        limit: 1,\n      },\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...step,\n        createdAt: '2026-06-30T00:00:00.000Z',\n        updatedAt: '2026-06-30T00:00:02.000Z',\n        startedAt: '2026-06-30T00:00:01.000Z',\n        completedAt: '2026-06-30T00:00:02.000Z',\n      },\n    ]);\n  });\n\n  it('falls back to storage when the first analytics page is empty', async () => {\n    const step = {\n      runId: 'run-1',\n      stepId: 'step-1',\n      stepName: 'step//./src/workflows/test//doWork',\n      status: 'completed',\n      attempt: 1,\n      input: undefined,\n      output: undefined,\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:02.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: new Date('2026-06-30T00:00:02.000Z'),\n    } satisfies Step;\n    const world = {\n      analytics: {\n        steps: {\n          list: vi.fn().mockResolvedValue({\n            data: [],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n      steps: {\n        list: vi.fn().mockResolvedValue({\n          data: [step],\n          cursor: null,\n          hasMore: false,\n        }),\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listSteps(world, { json: true, runId: 'run-1' });\n\n    expect(world.analytics?.steps.list).toHaveBeenCalled();\n    expect(world.steps.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      pagination: {\n        sortOrder: 'desc',\n        cursor: undefined,\n        limit: 20,\n      },\n      resolveData: 'none',\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...step,\n        createdAt: '2026-06-30T00:00:00.000Z',\n        updatedAt: '2026-06-30T00:00:02.000Z',\n        startedAt: '2026-06-30T00:00:01.000Z',\n        completedAt: '2026-06-30T00:00:02.000Z',\n      },\n    ]);\n  });\n});\n\ndescribe('listEvents', () => {\n  it('passes cursors and preserves the JSON array output', async () => {\n    const event = {\n      runId: 'run-1',\n      eventId: 'event-1',\n      eventType: 'step_completed',\n      correlationId: 'step-1',\n      entityId: 'step-1',\n      stepName: 'doWork',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      deploymentId: 'dep-1',\n      specVersion: 2,\n      runCreatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      createdAt: new Date('2026-06-30T00:00:02.000Z'),\n      region: null,\n      vercelId: null,\n      requestId: null,\n      resumeAt: null,\n      retryAfter: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      isWebhook: false,\n      isSystem: false,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsEvent;\n    const world = {\n      analytics: {\n        events: {\n          list: vi.fn().mockResolvedValue({\n            data: [event],\n            cursor: 'next-event-cursor',\n            hasMore: true,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listEvents(world, {\n      json: true,\n      runId: 'run-1',\n      cursor: 'event-cursor',\n      limit: 1,\n    });\n\n    expect(world.analytics?.events.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      correlationId: undefined,\n      pagination: {\n        sortOrder: 'desc',\n        cursor: 'event-cursor',\n        limit: 1,\n      },\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...event,\n        runCreatedAt: '2026-06-30T00:00:00.000Z',\n        createdAt: '2026-06-30T00:00:02.000Z',\n      },\n    ]);\n  });\n\n  it('falls back to storage when the first analytics page is empty', async () => {\n    const event = {\n      runId: 'run-1',\n      eventId: 'event-1',\n      eventType: 'step_completed',\n      correlationId: 'step-1',\n      eventData: {\n        stepName: 'doWork',\n        result: undefined,\n      },\n      createdAt: new Date('2026-06-30T00:00:02.000Z'),\n    } as unknown as Event;\n    const world = {\n      analytics: {\n        events: {\n          list: vi.fn().mockResolvedValue({\n            data: [],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n      events: {\n        list: vi.fn().mockResolvedValue({\n          data: [event],\n          cursor: null,\n          hasMore: false,\n        }),\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listEvents(world, { json: true, runId: 'run-1' });\n\n    expect(world.analytics?.events.list).toHaveBeenCalled();\n    expect(world.events.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      pagination: {\n        sortOrder: 'desc',\n        cursor: undefined,\n        limit: 20,\n      },\n      resolveData: 'none',\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...event,\n        createdAt: '2026-06-30T00:00:02.000Z',\n      },\n    ]);\n  });\n});\n\ndescribe('listSleeps', () => {\n  const wait = {\n    runId: 'run-1',\n    waitId: 'wait-1',\n    status: 'waiting',\n    resumeAt: new Date('2026-06-30T00:01:00.000Z'),\n    createdAt: new Date('2026-06-30T00:00:00.000Z'),\n    updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n    completedAt: null,\n    workflowCoreVersion: null,\n    workflowEncryptionEnabled: false,\n  } satisfies AnalyticsWait;\n  const pageInfo = {\n    currentLookbackDays: 2,\n    maxLookbackDays: 30,\n    currentWindowStart: new Date('2026-06-28T00:00:00.000Z'),\n    maxWindowStart: new Date('2026-06-01T00:00:00.000Z'),\n    upgradeAvailable: true,\n  };\n\n  it('passes cursors and preserves the JSON array output through analytics', async () => {\n    const world = {\n      analytics: {\n        waits: {\n          list: vi.fn().mockResolvedValue({\n            data: [wait],\n            cursor: 'next-wait-cursor',\n            hasMore: true,\n            pageInfo,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listSleeps(world, {\n      json: true,\n      runId: 'run-1',\n      cursor: 'wait-cursor',\n      limit: 1,\n    });\n\n    expect(world.analytics?.waits.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      pagination: {\n        sortOrder: 'desc',\n        cursor: 'wait-cursor',\n        limit: 1,\n      },\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...wait,\n        resumeAt: '2026-06-30T00:01:00.000Z',\n        createdAt: '2026-06-30T00:00:00.000Z',\n        updatedAt: '2026-06-30T00:00:00.000Z',\n      },\n    ]);\n  });\n\n  it('surfaces the observability upgrade hint in table mode', async () => {\n    const world = {\n      analytics: {\n        waits: {\n          list: vi.fn().mockResolvedValue({\n            data: [wait],\n            cursor: null,\n            hasMore: false,\n            pageInfo,\n          }),\n        },\n      },\n    } as unknown as World;\n    const log = vi.spyOn(console, 'log').mockImplementation(() => undefined);\n\n    await listSleeps(world, { runId: 'run-1' });\n\n    expect(log.mock.calls.flat().join('\\n')).toContain(\n      'Upgrade Observability Plus'\n    );\n  });\n});\n"]}

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

@@ -26,7 +26,16 @@ export interface PageData<T> {
     data: T[];
     cursor: string | null | undefined;
     hasMore: boolean;
+    pageInfo?: AnalyticsPageInfo;
 }
+export interface AnalyticsPageInfo {
+    currentLookbackDays: number;
+    maxLookbackDays: number;
+    currentWindowStart: Date | string;
+    maxWindowStart: Date | string;
+    upgradeAvailable: boolean;
+}
+export declare const getPageInfoUpgradeHint: (pageInfo: AnalyticsPageInfo | undefined) => string | undefined;
 /**
  * Generic pagination handler for list operations
  */
@@ -42,7 +51,7 @@ export interface ListPaginationOptions<TData> {
     /**
      * Display function that renders the current page
      */
-    displayPage: (data: TData[], pageIndex: number) => void | Promise<void>;
+    displayPage: (data: TData[], pageIndex: number, page: PageData<TData>) => void | Promise<void>;
     /**
      * Optional callback for when fetching starts
      */

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

@@ -1 +1 @@
-{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/pagination.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,eAAe,EACtB,WAAW,mBAAmB,KAC7B,CAAC,MAAM,IAAI,CAwDb,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,eAAe,SAsBzD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,KAAK;IAC1C;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;IAEpE;;OAEG;IACH,WAAW,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExE;;OAEG;IACH,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAE3C;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAC7C,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CA8If"}
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/pagination.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,eAAe,EACtB,WAAW,mBAAmB,KAC7B,CAAC,MAAM,IAAI,CAwDb,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,eAAe,SAsBzD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CAC9B;AAED,MAAM,WAAW,iBAAiB;IAChC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,IAAI,GAAG,MAAM,CAAC;IAClC,cAAc,EAAE,IAAI,GAAG,MAAM,CAAC;IAC9B,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,eAAO,MAAM,sBAAsB,GACjC,UAAU,iBAAiB,GAAG,SAAS,KACtC,MAAM,GAAG,SASX,CAAC;AAWF;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,KAAK;IAC1C;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;IAEpE;;OAEG;IACH,WAAW,EAAE,CACX,IAAI,EAAE,KAAK,EAAE,EACb,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,KAClB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B;;OAEG;IACH,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAE3C;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAC7C,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAiJf"}