@workflow/cli 5.0.0-beta.3 → 5.0.0-beta.30

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=output.test.js.map
+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"}

package/dist/lib/inspect/pagination.js

@@ -78,6 +78,19 @@ export const showPaginationState = (state) => {
     parts.push('[q] Quit (or Ctrl+C)');
     logger.log(`\n${parts.join(' | ')}`);
 };
+export const getPageInfoUpgradeHint = (pageInfo) => {
+    if (!pageInfo?.upgradeAvailable ||
+        pageInfo.currentLookbackDays >= pageInfo.maxLookbackDays) {
+        return undefined;
+    }
+    return `Showing the last ${pageInfo.currentLookbackDays} days of workflow observability data. Upgrade Observability Plus to query up to ${pageInfo.maxLookbackDays} days.`;
+};
+const showPageInfoUpgradeHint = (pageInfo) => {
+    const hint = getPageInfoUpgradeHint(pageInfo);
+    if (hint) {
+        logger.info(hint);
+    }
+};
 /**
  * Setup pagination for list operations with page caching
  */
@@ -103,7 +116,8 @@ export async function setupListPagination(options) {
         if (enableInteractive) {
             console.clear();
         }
-        await displayPage(page.data, index);
+        await displayPage(page.data, index, page);
+        showPageInfoUpgradeHint(page.pageInfo);
         return page;
     };
     // Fetch and display first page
@@ -135,7 +149,8 @@ export async function setupListPagination(options) {
                 if (enableInteractive) {
                     console.clear();
                 }
-                await displayPage(cachedPage.data, pageIndex);
+                await displayPage(cachedPage.data, pageIndex, cachedPage);
+                showPageInfoUpgradeHint(cachedPage.pageInfo);
                 paginationState.cursor = cachedPage.cursor;
                 paginationState.hasMore = cachedPage.hasMore;
                 paginationState.hasPrevious = pageIndex > 0;
@@ -177,7 +192,8 @@ export async function setupListPagination(options) {
                 if (enableInteractive) {
                     console.clear();
                 }
-                await displayPage(prevPage.data, pageIndex);
+                await displayPage(prevPage.data, pageIndex, prevPage);
+                showPageInfoUpgradeHint(prevPage.pageInfo);
                 paginationState.cursor = prevPage.cursor;
                 paginationState.hasMore = prevPage.hasMore;
                 paginationState.hasPrevious = pageIndex > 0;
@@ -196,4 +212,4 @@ export async function setupListPagination(options) {
     // Keep process alive
     return new Promise(() => { });
 }
-//# sourceMappingURL=pagination.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.js","sourceRoot":"","sources":["../../../src/lib/inspect/pagination.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Interactive pagination for CLI tables\n */\nimport readline from 'node:readline';\nimport { logger } from '../config/log.js';\nimport { isInteractive } from './terminal-utils.js';\n\nexport interface PaginationState {\n  cursor: string | null | undefined;\n  hasMore: boolean;\n  hasPrevious: boolean;\n  currentPage: number;\n  totalPages: number;\n  hasMorePagesAvailable: boolean;\n}\n\nexport interface PaginationCallbacks {\n  onNext: () => Promise<void>;\n  onPrevious: () => Promise<void>;\n  onExit: () => void;\n}\n\n/**\n * Setup interactive pagination listener\n */\nexport const setupPaginationListener = (\n  state: PaginationState,\n  callbacks: PaginationCallbacks\n): (() => void) => {\n  if (!isInteractive()) {\n    return () => {}; // No-op cleanup function\n  }\n\n  // Enable raw mode for immediate key capture\n  if (process.stdin.isTTY) {\n    readline.emitKeypressEvents(process.stdin);\n    process.stdin.setRawMode(true);\n  }\n\n  const keypressHandler = async (_chunk: string, key: any) => {\n    if (!key) return;\n\n    // Handle exit\n    if (key.name === 'q' || (key.ctrl && key.name === 'c')) {\n      callbacks.onExit();\n      return;\n    }\n\n    // Handle next page\n    if (\n      (key.name === 'n' && !key.ctrl) ||\n      key.name === 'right' ||\n      key.name === 'down'\n    ) {\n      if (state.hasMore) {\n        await callbacks.onNext();\n      } else {\n        logger.warn('No more pages available');\n      }\n      return;\n    }\n\n    // Handle previous page\n    if (\n      (key.name === 'p' && !key.ctrl) ||\n      key.name === 'left' ||\n      key.name === 'up'\n    ) {\n      // Always allow going \"previous\" - on first page it reloads\n      await callbacks.onPrevious();\n      return;\n    }\n  };\n\n  process.stdin.on('keypress', keypressHandler);\n\n  // Return cleanup function\n  return () => {\n    process.stdin.off('keypress', keypressHandler);\n    if (process.stdin.isTTY && process.stdin.isRaw) {\n      process.stdin.setRawMode(false);\n    }\n    process.stdin.pause();\n  };\n};\n\n/**\n * Show pagination state info\n */\nexport const showPaginationState = (state: PaginationState) => {\n  const parts: string[] = [];\n\n  // Show page indicator\n  // Use hasMorePagesAvailable to determine if there are unknown pages beyond what we've loaded\n  const pageIndicator = state.hasMorePagesAvailable\n    ? `Page ${state.currentPage} of ${state.totalPages}+`\n    : `Page ${state.currentPage} of ${state.totalPages}`;\n  parts.push(pageIndicator);\n\n  if (state.hasPrevious) {\n    parts.push('[p] Previous');\n  } else {\n    parts.push('[p] Reload');\n  }\n\n  if (state.hasMore) {\n    parts.push('[n] Next');\n  }\n\n  parts.push('[q] Quit (or Ctrl+C)');\n  logger.log(`\\n${parts.join(' | ')}`);\n};\n\n/**\n * Page data structure for caching paginated results\n */\nexport interface PageData<T> {\n  data: T[];\n  cursor: string | null | undefined;\n  hasMore: boolean;\n  pageInfo?: AnalyticsPageInfo;\n}\n\nexport interface AnalyticsPageInfo {\n  currentLookbackDays: number;\n  maxLookbackDays: number;\n  currentWindowStart: Date | string;\n  maxWindowStart: Date | string;\n  upgradeAvailable: boolean;\n}\n\nexport const getPageInfoUpgradeHint = (\n  pageInfo: AnalyticsPageInfo | undefined\n): string | undefined => {\n  if (\n    !pageInfo?.upgradeAvailable ||\n    pageInfo.currentLookbackDays >= pageInfo.maxLookbackDays\n  ) {\n    return undefined;\n  }\n\n  return `Showing the last ${pageInfo.currentLookbackDays} days of workflow observability data. Upgrade Observability Plus to query up to ${pageInfo.maxLookbackDays} days.`;\n};\n\nconst showPageInfoUpgradeHint = (\n  pageInfo: AnalyticsPageInfo | undefined\n): void => {\n  const hint = getPageInfoUpgradeHint(pageInfo);\n  if (hint) {\n    logger.info(hint);\n  }\n};\n\n/**\n * Generic pagination handler for list operations\n */\nexport interface ListPaginationOptions<TData> {\n  /**\n   * Initial cursor from CLI options\n   */\n  initialCursor?: string;\n\n  /**\n   * Fetch function that returns paginated data\n   */\n  fetchPage: (cursor: string | undefined) => Promise<PageData<TData>>;\n\n  /**\n   * Display function that renders the current page\n   */\n  displayPage: (\n    data: TData[],\n    pageIndex: number,\n    page: PageData<TData>\n  ) => void | Promise<void>;\n\n  /**\n   * Optional callback for when fetching starts\n   */\n  onFetchStart?: (pageIndex: number) => void;\n\n  /**\n   * Enable interactive pagination with keyboard controls\n   */\n  interactive?: boolean;\n}\n\n/**\n * Setup pagination for list operations with page caching\n */\nexport async function setupListPagination<TData>(\n  options: ListPaginationOptions<TData>\n): Promise<void> {\n  const { initialCursor, fetchPage, displayPage, onFetchStart, interactive } =\n    options;\n\n  // Interactive mode requires both TTY support and explicit --interactive flag\n  const enableInteractive = interactive && isInteractive();\n\n  // Pages stack - stores all fetched pages\n  const pages: PageData<TData>[] = [];\n\n  // Current page index (0-based)\n  let pageIndex = 0;\n\n  /**\n   * Fetch and display a specific page\n   */\n  const showPage = async (index: number, cursor?: string) => {\n    if (onFetchStart) {\n      onFetchStart(index);\n    }\n\n    const page = await fetchPage(cursor);\n    pages[index] = page;\n    pageIndex = index;\n\n    // Clear screen for subsequent pages in interactive mode\n    if (enableInteractive) {\n      console.clear();\n    }\n\n    await displayPage(page.data, index, page);\n    showPageInfoUpgradeHint(page.pageInfo);\n    return page;\n  };\n\n  // Fetch and display first page\n  const firstPage = await showPage(0, initialCursor);\n\n  // In non-interactive mode, show info if there are more pages\n  if (!enableInteractive) {\n    if (firstPage.hasMore) {\n      logger.info(\n        '\\nMore results available. Use --interactive (-i) to paginate through results.'\n      );\n    }\n    return;\n  }\n\n  // Setup pagination state\n  const paginationState: PaginationState = {\n    cursor: firstPage.cursor,\n    hasMore: firstPage.hasMore,\n    hasPrevious: false,\n    currentPage: 1,\n    totalPages: 1,\n    hasMorePagesAvailable: firstPage.hasMore,\n  };\n\n  showPaginationState(paginationState);\n\n  const cleanup = setupPaginationListener(paginationState, {\n    onNext: async () => {\n      const newPageIndex = pageIndex + 1;\n\n      // Check if we already have this page cached\n      if (pages[newPageIndex]) {\n        pageIndex = newPageIndex;\n        const cachedPage = pages[newPageIndex];\n\n        if (enableInteractive) {\n          console.clear();\n        }\n\n        await displayPage(cachedPage.data, pageIndex, cachedPage);\n        showPageInfoUpgradeHint(cachedPage.pageInfo);\n\n        paginationState.cursor = cachedPage.cursor;\n        paginationState.hasMore = cachedPage.hasMore;\n        paginationState.hasPrevious = pageIndex > 0;\n        paginationState.currentPage = pageIndex + 1;\n        paginationState.totalPages = pages.length;\n        // Check if the last page in cache has more data\n        paginationState.hasMorePagesAvailable = pages[pages.length - 1].hasMore;\n      } else {\n        // Fetch new page using cursor from current page\n        const currentPage = pages[pageIndex];\n        const nextPage = await showPage(\n          newPageIndex,\n          currentPage.cursor || undefined\n        );\n\n        paginationState.cursor = nextPage.cursor;\n        paginationState.hasMore = nextPage.hasMore;\n        paginationState.hasPrevious = pageIndex > 0;\n        paginationState.currentPage = pageIndex + 1;\n        paginationState.totalPages = pages.length;\n        // Check if the last page in cache has more data\n        paginationState.hasMorePagesAvailable = pages[pages.length - 1].hasMore;\n      }\n\n      showPaginationState(paginationState);\n    },\n    onPrevious: async () => {\n      // Special case: on first page, reload\n      if (pageIndex === 0) {\n        pages.length = 0; // Clear cache\n        const reloadedPage = await showPage(0, initialCursor);\n\n        paginationState.cursor = reloadedPage.cursor;\n        paginationState.hasMore = reloadedPage.hasMore;\n        paginationState.hasPrevious = false;\n        paginationState.currentPage = 1;\n        paginationState.totalPages = 1;\n        paginationState.hasMorePagesAvailable = reloadedPage.hasMore;\n      } else {\n        // Go to previous cached page\n        pageIndex--;\n        const prevPage = pages[pageIndex];\n\n        if (enableInteractive) {\n          console.clear();\n        }\n\n        await displayPage(prevPage.data, pageIndex, prevPage);\n        showPageInfoUpgradeHint(prevPage.pageInfo);\n\n        paginationState.cursor = prevPage.cursor;\n        paginationState.hasMore = prevPage.hasMore;\n        paginationState.hasPrevious = pageIndex > 0;\n        paginationState.currentPage = pageIndex + 1;\n        paginationState.totalPages = pages.length;\n        // Check if the last page in cache has more data\n        paginationState.hasMorePagesAvailable = pages[pages.length - 1].hasMore;\n      }\n\n      showPaginationState(paginationState);\n    },\n    onExit: () => {\n      cleanup();\n      process.exit(0);\n    },\n  });\n\n  // Keep process alive\n  return new Promise(() => {});\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/run.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAe,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG1D,UAAU,aAAa;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAaD,eAAO,MAAM,QAAQ,GACnB,OAAO,KAAK,EACZ,qBAAqB,MAAM,EAC3B,MAAM,aAAa,EACnB,MAAM,MAAM,EAAE,kBA8Df,CAAC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/run.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAI7C,UAAU,aAAa;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAaD,eAAO,MAAM,QAAQ,GACnB,OAAO,KAAK,EACZ,qBAAqB,MAAM,EAC3B,MAAM,aAAa,EACnB,MAAM,MAAM,EAAE,kBAuFf,CAAC"}