@workflow/cli 4.0.1-beta.0

package/dist/lib/inspect/output.js

@@ -0,0 +1,899 @@
+import { hydrateResourceIO } from '@workflow/core/observability';
+import { parseStepName, parseWorkflowName } from '@workflow/core/parse-name';
+import { getRun } from '@workflow/core/runtime';
+import chalk from 'chalk';
+import { formatDistance } from 'date-fns';
+import Table from 'easy-table';
+import { logger } from '../config/log.js';
+import { setupListPagination } from './pagination.js';
+import { streamToConsole } from './stream.js';
+import { formatISODate, formatStatus as formatStatusAbbrev, getDisplaySettings, getTerminalWidth, isCI, } from './terminal-utils.js';
+const DEFAULT_PAGE_SIZE = 20;
+let TABLE_TRUNCATE_IO_LENGTH = 15; // Will be adjusted based on terminal width
+const WORKFLOW_RUN_IO_PROPS = ['input', 'output'];
+const STEP_IO_PROPS = ['input', 'output'];
+const WORKFLOW_RUN_LISTED_PROPS = [
+    'runId',
+    'workflowName',
+    'status',
+    'startedAt',
+    'completedAt',
+    ...WORKFLOW_RUN_IO_PROPS,
+];
+const STEP_LISTED_PROPS = [
+    'runId',
+    'stepId',
+    'stepName',
+    'status',
+    'startedAt',
+    'completedAt',
+    ...STEP_IO_PROPS,
+];
+const EVENT_IO_PROPS = ['eventData'];
+const EVENT_LISTED_PROPS = [
+    'eventId',
+    'eventType',
+    'correlationId',
+    'createdAt',
+    ...EVENT_IO_PROPS,
+];
+// const HOOK_DATA_PROPS: (keyof Hook | 'hasResponse')[] = ['hasResponse'];
+const HOOK_LISTED_PROPS = [
+    'runId',
+    'hookId',
+    'ownerId',
+    'createdAt',
+    // ...HOOK_DATA_PROPS,
+];
+const STATUS_COLORS = {
+    running: chalk.blue,
+    completed: chalk.green,
+    failed: chalk.red,
+    cancelled: chalk.strikethrough.yellow,
+    pending: chalk.blue,
+    paused: chalk.yellow,
+};
+const isStreamId = (value) => {
+    return typeof value === 'string' && value.startsWith('strm_');
+};
+const showStatusLegend = () => {
+    logger.log('\nStatus Legend:');
+    const statuses = [
+        'running',
+        'completed',
+        'failed',
+        'cancelled',
+        'pending',
+        'paused',
+    ];
+    const legendItems = statuses.map((status) => {
+        const colorFunc = STATUS_COLORS[status];
+        const abbrev = formatStatusAbbrev(status, true);
+        return `${colorFunc(abbrev)} = ${status}`;
+    });
+    logger.log(`  ${legendItems.join('  ')}`);
+    logger.log('');
+};
+const isSleepStep = (stepName) => {
+    return stepName.includes('-sleep');
+};
+const checkAndHandleVercelAccessError = (error, backend) => {
+    if (backend === 'vercel' && error && typeof error === 'object') {
+        const err = error;
+        if (err.status === 403) {
+            logger.error('Your current vercel account does not have access to this workflow run. Please use `vercel login` to login, or use `vercel switch` to ensure you can access the correct team.');
+            return true;
+        }
+    }
+    return false;
+};
+const extractErrorMessage = (err) => {
+    if (err.message && typeof err.message === 'string') {
+        return err.message;
+    }
+    if (err.body && typeof err.body === 'object') {
+        const body = err.body;
+        if (body.message && typeof body.message === 'string') {
+            return body.message;
+        }
+        if (body.error && typeof body.error === 'string') {
+            return body.error;
+        }
+    }
+    return undefined;
+};
+const handleApiError = (error, backend) => {
+    // First check for Vercel access errors
+    if (checkAndHandleVercelAccessError(error, backend)) {
+        return true;
+    }
+    // Handle other HTTP errors
+    if (error && typeof error === 'object') {
+        const err = error;
+        // Handle 400 Bad Request
+        if (err.status === 400) {
+            logger.error('Bad Request: The request was invalid.');
+            const message = extractErrorMessage(err);
+            if (message) {
+                logger.error(`Details: ${message}`);
+            }
+            return true;
+        }
+        // Handle other HTTP errors (404, 500, etc.)
+        if (typeof err.status === 'number' && err.status >= 400) {
+            logger.error(`HTTP Error ${err.status}: ${getStatusText(err.status)}`);
+            const message = extractErrorMessage(err);
+            if (message) {
+                logger.error(`Details: ${message}`);
+            }
+            return true;
+        }
+    }
+    return false;
+};
+const getStatusText = (status) => {
+    const statusTexts = {
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        403: 'Forbidden',
+        404: 'Not Found',
+        500: 'Internal Server Error',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+    };
+    return statusTexts[status] || 'Unknown Error';
+};
+const truncateNameIfNeeded = (name, maxLength) => {
+    return maxLength < name.length ? `${name.substring(0, maxLength)}...` : name;
+};
+const formatNameField = (nameNonUnique, truncateLength, isSleep) => {
+    const truncatedName = truncateNameIfNeeded(nameNonUnique, truncateLength);
+    if (isSleep) {
+        return chalk.yellowBright(truncatedName);
+    }
+    return chalk.blue.blueBright(truncatedName);
+};
+const formatIdField = (prop, value, shouldTruncateIds) => {
+    const valueStr = String(value);
+    const idStr = shouldTruncateIds ? truncateIdToLastChars(valueStr) : valueStr;
+    if (prop === 'streamId') {
+        return chalk.green(idStr);
+    }
+    return idStr;
+};
+const formatTableValue = (prop, value, opts = {}, displaySettings) => {
+    const namesTruncate = displaySettings?.namesTruncateLength ?? 40;
+    const shouldTruncateIds = displaySettings?.truncateIdsToLastChars ?? false;
+    // Handle IDs with potential truncation
+    if ([
+        'streamId',
+        'runId',
+        'stepId',
+        'hookId',
+        'eventId',
+        'correlationId',
+        'ownerId',
+    ].includes(prop)) {
+        return formatIdField(prop, value, shouldTruncateIds);
+    }
+    // Handle names with truncation
+    if (prop === 'stepName') {
+        const nameNonUnique = parseStepName(String(value))?.shortName || '?';
+        return formatNameField(nameNonUnique, namesTruncate, isSleepStep(String(value)));
+    }
+    if (prop === 'workflowName') {
+        const nameNonUnique = parseWorkflowName(String(value))?.shortName || '?';
+        const truncatedName = truncateNameIfNeeded(nameNonUnique, namesTruncate);
+        return chalk.blue.blueBright(truncatedName);
+    }
+    if (prop === 'output' || prop === 'input') {
+        return inlineFormatIO(value);
+    }
+    if (prop === 'status') {
+        const status = value;
+        const colorFunc = STATUS_COLORS[status];
+        const formattedStatus = displaySettings?.abbreviateStatus
+            ? formatStatusAbbrev(status, true)
+            : status;
+        return colorFunc(formattedStatus);
+    }
+    if (prop === 'eventData') {
+        return truncateString(JSON.stringify(value));
+    }
+    if (prop === 'hasResponse') {
+        return value ? chalk.green('true') : chalk.gray('false');
+    }
+    if (value instanceof Date) {
+        return formatTableTimestamp(value, opts, displaySettings);
+    }
+    return value;
+};
+const getVisibleProps = (props, displaySettings) => {
+    if (displaySettings.hideCompletedAt) {
+        return props.filter((prop) => prop !== 'completedAt');
+    }
+    return props;
+};
+const showTable = (data, props, opts = {}) => {
+    // Get display settings based on terminal width
+    const terminalWidth = getTerminalWidth();
+    const displaySettings = getDisplaySettings(terminalWidth, opts.withData || false, props.includes('runName'));
+    // Filter out completedAt column if needed
+    const visibleProps = getVisibleProps(props, displaySettings);
+    // Update truncate length for IO fields
+    const originalTruncateLength = TABLE_TRUNCATE_IO_LENGTH;
+    TABLE_TRUNCATE_IO_LENGTH = displaySettings.dataFieldWidth;
+    // Show status legend if using abbreviated status
+    if (displaySettings.abbreviateStatus && visibleProps.includes('status')) {
+        showStatusLegend();
+    }
+    // Create header mapping for abbreviated status
+    const headerMap = {};
+    if (displaySettings.abbreviateStatus && visibleProps.includes('status')) {
+        headerMap['status'] = 'S';
+    }
+    // Add a blank line before any table
+    const table = new Table();
+    if (data && data.length === 0) {
+        logger.warn('No data found for this query and resource.\n');
+        for (const prop of visibleProps) {
+            const header = headerMap[prop] || prop;
+            table.cell(header, 'N/A');
+        }
+        table.newRow();
+        // Restore original truncate length
+        TABLE_TRUNCATE_IO_LENGTH = originalTruncateLength;
+        return table.toString();
+    }
+    else if (!data) {
+        logger.warn('Expecting an array of data, but got null.\n');
+    }
+    logger.log('');
+    for (const item of data) {
+        for (const prop of visibleProps) {
+            const header = headerMap[prop] || prop;
+            const value = item[prop];
+            table.cell(header, formatTableValue(prop, value, opts, displaySettings));
+        }
+        table.newRow();
+    }
+    // Restore original truncate length
+    TABLE_TRUNCATE_IO_LENGTH = originalTruncateLength;
+    return table.toString();
+};
+const showJson = (data) => {
+    const json = JSON.stringify(data, null, 2);
+    process.stdout.write(`${json}\n`);
+};
+const getCursorHint = ({ hasMore, cursor, }) => {
+    // Only show cursor hint in non-interactive mode (e.g., CI or when piped)
+    if (!isCI() && process.stdout.isTTY) {
+        return undefined;
+    }
+    if (hasMore && cursor) {
+        return `More results available. Append\n--cursor "${cursor}"\nto this command to fetch the next page.`;
+    }
+};
+/**
+ * In tables, we want to show a shorter timestamp, YYYY-MM-DD HH:MM:SS
+ */
+const formatTableTimestamp = (value, opts = {}, displaySettings) => {
+    // Format ISO time without T and Z
+    const isoTime = formatISODate(value);
+    // Show relative time only if:
+    // - Not in CI mode
+    // - Display settings allow it (based on terminal width)
+    // - withData is disabled (more space available)
+    // - Not in JSON mode
+    const shouldShowRelative = !isCI() &&
+        displaySettings?.showRelativeDates !== false &&
+        !opts.withData &&
+        !opts.json;
+    if (shouldShowRelative) {
+        const relative = formatDistance(value, new Date(), { addSuffix: true });
+        return `${isoTime} (${relative})`;
+    }
+    return isoTime;
+};
+const truncateString = (str, maxLength = TABLE_TRUNCATE_IO_LENGTH) => {
+    return str && str.length > maxLength
+        ? `${str.substring(0, maxLength)}...`
+        : str;
+};
+const truncateIdToLastChars = (id, chars = 4) => {
+    if (!id || id.length <= chars)
+        return id;
+    return `...${id.substring(id.length - chars)}`;
+};
+const showInspectInfoBox = (resource) => {
+    logger.info(`To view details for a ${resource}, use \`wf i ${resource}\` <id>`);
+    logger.info(`To view the content of any stream, use \`wf i stream <stream-id>\``);
+};
+/**
+ * Takes hydrated step/workflow input/output and serializes it for inline display.
+ */
+const inlineFormatIO = (io, topLevel = true) => {
+    const type = typeof io;
+    let value = '';
+    if (io === undefined) {
+        value = '<empty>';
+    }
+    else if (io === null) {
+        value = '<null>';
+    }
+    else if (io && Array.isArray(io)) {
+        if (io.length === 0) {
+            value = '<empty>';
+        }
+        else {
+            const stringified = io
+                .map((item) => inlineFormatIO(item, false))
+                .join(',');
+            if (stringified.length > TABLE_TRUNCATE_IO_LENGTH && topLevel) {
+                value = chalk.yellow(`${io.length} args`);
+            }
+            else {
+                value = stringified;
+            }
+        }
+    }
+    else if (type === 'object') {
+        if (isStreamId(io)) {
+            value = io.toString();
+        }
+        else if (io instanceof Date) {
+            value = io.toISOString();
+        }
+        else {
+            value = truncateString(JSON.stringify(io));
+        }
+    }
+    else if (['string', 'number', 'boolean'].includes(type)) {
+        if (type === 'string' && io.includes('strm_')) {
+            value = io;
+        }
+        value = truncateString(String(io));
+    }
+    else {
+        value = `<${type}>`;
+    }
+    return value;
+};
+export const listRuns = async (world, opts = {}) => {
+    if (opts.stepId || opts.runId) {
+        logger.warn('Filtering by step-id or run-id is not supported in list calls, ignoring filter.');
+    }
+    const resolveData = opts.withData ? 'all' : 'none';
+    // Determine which props to show based on withData flag
+    const props = opts.withData
+        ? WORKFLOW_RUN_LISTED_PROPS
+        : WORKFLOW_RUN_LISTED_PROPS.filter((prop) => !WORKFLOW_RUN_IO_PROPS.includes(prop));
+    // For JSON output, just fetch once and return
+    if (opts.json) {
+        try {
+            const runs = await world.runs.list({
+                workflowName: opts.workflowName,
+                pagination: {
+                    sortOrder: opts.sort || 'desc',
+                    cursor: opts.cursor,
+                    limit: opts.limit || DEFAULT_PAGE_SIZE,
+                },
+                resolveData,
+            });
+            const runsWithHydratedIO = runs.data.map(hydrateResourceIO);
+            showJson({ ...runs, data: runsWithHydratedIO });
+            return;
+        }
+        catch (error) {
+            if (handleApiError(error, opts.backend)) {
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    await setupListPagination({
+        initialCursor: opts.cursor,
+        fetchPage: async (cursor) => {
+            try {
+                const runs = await world.runs.list({
+                    workflowName: opts.workflowName,
+                    pagination: {
+                        sortOrder: opts.sort || 'desc',
+                        cursor,
+                        limit: opts.limit || DEFAULT_PAGE_SIZE,
+                    },
+                    resolveData,
+                });
+                return {
+                    data: runs.data,
+                    cursor: runs.cursor,
+                    hasMore: runs.hasMore,
+                };
+            }
+            catch (error) {
+                if (handleApiError(error, opts.backend)) {
+                    process.exit(1);
+                }
+                throw error;
+            }
+        },
+        displayPage: async (runs) => {
+            const runsWithHydratedIO = runs.map(hydrateResourceIO);
+            logger.log(showTable(runsWithHydratedIO, props, opts));
+        },
+    });
+};
+export const getRecentRun = async (world, opts = {}) => {
+    logger.warn(`No runId provided, fetching data for latest run instead.`);
+    try {
+        const runs = await world.runs.list({
+            pagination: { limit: 1, sortOrder: opts.sort || 'desc' },
+            resolveData: 'none', // Don't need data for just getting the ID
+        });
+        runs.data = runs.data.map(hydrateResourceIO);
+        return runs.data[0];
+    }
+    catch (error) {
+        if (handleApiError(error, opts.backend)) {
+            process.exit(1);
+        }
+        throw error;
+    }
+};
+export const showRun = async (world, runId, opts = {}) => {
+    if (opts.withData) {
+        logger.warn('`withData` flag is ignored when showing individual resources');
+    }
+    try {
+        const run = await world.runs.get(runId, { resolveData: 'all' });
+        const runWithHydratedIO = hydrateResourceIO(run);
+        if (opts.json) {
+            showJson(runWithHydratedIO);
+            return;
+        }
+        else {
+            logger.log(runWithHydratedIO);
+        }
+    }
+    catch (error) {
+        if (handleApiError(error, opts.backend)) {
+            process.exit(1);
+        }
+        throw error;
+    }
+};
+export const listSteps = async (world, opts = {
+    runId: undefined,
+}) => {
+    if (opts.stepId) {
+        logger.warn('Filtering by step-id is not supported in list calls, ignoring filter.');
+    }
+    if (opts.workflowName) {
+        logger.warn('Filtering by workflow-name is not supported for steps, ignoring filter.');
+    }
+    const runId = opts.runId
+        ? opts.runId
+        : (await getRecentRun(world, opts))?.runId;
+    if (!runId) {
+        logger.error('No run found.');
+        return;
+    }
+    const resolveData = opts.withData ? 'all' : 'none';
+    // Determine which props to show based on withData flag
+    const props = opts.withData
+        ? STEP_LISTED_PROPS
+        : STEP_LISTED_PROPS.filter((prop) => !STEP_IO_PROPS.includes(prop));
+    // For JSON output, just fetch once and return
+    if (opts.json) {
+        logger.debug(`Fetching steps for run ${runId}`);
+        try {
+            const stepChunks = await world.steps.list({
+                runId,
+                pagination: {
+                    sortOrder: opts.sort || 'desc',
+                    cursor: opts.cursor,
+                    limit: opts.limit || DEFAULT_PAGE_SIZE,
+                },
+                resolveData,
+            });
+            showJson(stepChunks.data);
+            return;
+        }
+        catch (error) {
+            if (handleApiError(error, opts.backend)) {
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    await setupListPagination({
+        initialCursor: opts.cursor,
+        fetchPage: async (cursor) => {
+            logger.debug(`Fetching steps for run ${runId}`);
+            try {
+                const stepChunks = await world.steps.list({
+                    runId,
+                    pagination: {
+                        sortOrder: opts.sort || 'desc',
+                        cursor,
+                        limit: opts.limit || DEFAULT_PAGE_SIZE,
+                    },
+                    resolveData,
+                });
+                return {
+                    data: stepChunks.data,
+                    cursor: stepChunks.cursor,
+                    hasMore: stepChunks.hasMore,
+                };
+            }
+            catch (error) {
+                if (handleApiError(error, opts.backend)) {
+                    process.exit(1);
+                }
+                throw error;
+            }
+        },
+        displayPage: async (steps) => {
+            const stepsWithHydratedIO = steps.map(hydrateResourceIO);
+            logger.log(showTable(stepsWithHydratedIO, props, opts));
+            showInspectInfoBox('step');
+        },
+    });
+};
+export const showStep = async (world, stepId, opts = {}) => {
+    if (opts.withData) {
+        logger.warn('`withData` flag is ignored when showing individual resources');
+    }
+    if (opts.stepId) {
+        logger.warn('Filtering by step-id is not supported in get calls, ignoring filter.');
+    }
+    try {
+        const step = await world.steps.get(opts.runId, stepId, {
+            resolveData: 'all',
+        });
+        const stepWithHydratedIO = hydrateResourceIO(step);
+        if (opts.json) {
+            showJson(stepWithHydratedIO);
+            return;
+        }
+        else {
+            logger.log(stepWithHydratedIO);
+        }
+    }
+    catch (error) {
+        if (handleApiError(error, opts.backend)) {
+            process.exit(1);
+        }
+        throw error;
+    }
+};
+export const showStream = async (_, streamId, opts = {}) => {
+    if (opts.runId || opts.stepId) {
+        logger.warn('Filtering by run-id or step-id is not supported in get calls, ignoring filter.');
+    }
+    const run = getRun(streamId);
+    const stream = run.readable;
+    logger.info('Streaming to stdout, press CTRL+C to abort.');
+    logger.info('Use --json to output the stream as newline-delimited JSON without info logs.\n');
+    await streamToConsole(stream, streamId, opts);
+};
+/**
+ * Listing streams only lists available stream IDs based on run/step passed,
+ * and doesn't read any data from the streams.
+ */
+export const listStreams = async (world, opts = {}) => {
+    if (opts.withData) {
+        logger.warn('`withData` flag is ignored when listing streams');
+    }
+    if (opts.workflowName) {
+        logger.warn('Filtering by workflow-name is not supported for streams, ignoring filter.');
+    }
+    const steps = [];
+    const runs = [];
+    if (opts.stepId) {
+        try {
+            const step = await world.steps.get(undefined, opts.stepId, {
+                resolveData: 'all',
+            });
+            steps.push(step);
+        }
+        catch (error) {
+            if (handleApiError(error, opts.backend)) {
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    else if (opts.runId) {
+        try {
+            const run = await world.runs.get(opts.runId, { resolveData: 'all' });
+            runs.push(run);
+            const runsSteps = await world.steps.list({
+                runId: opts.runId,
+                pagination: {
+                    sortOrder: opts.sort || 'desc',
+                    cursor: opts.cursor,
+                    limit: opts.limit || DEFAULT_PAGE_SIZE,
+                },
+                resolveData: 'all', // Need data to find stream IDs
+            });
+            runsSteps.data.forEach((step) => {
+                steps.push(step);
+            });
+            logger.info(getCursorHint(runsSteps));
+        }
+        catch (error) {
+            if (handleApiError(error, opts.backend)) {
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    else {
+        logger.warn('No run-id or step-id provided. Listing streams for latest run instead.', 'Use --run=<run-id> or --step=<step-id> to filter streams by run or step.');
+        const run = await getRecentRun(world, opts);
+        if (!run) {
+            logger.warn('No runs found.');
+            return;
+        }
+        try {
+            const fullRun = await world.runs.get(run.runId, { resolveData: 'all' });
+            runs.push(fullRun);
+            const runsSteps = await world.steps.list({
+                runId: runs[0].runId,
+                pagination: {
+                    sortOrder: opts.sort || 'desc',
+                    cursor: opts.cursor,
+                    limit: opts.limit || DEFAULT_PAGE_SIZE,
+                },
+                resolveData: 'all', // Need data to find stream IDs
+            });
+            runsSteps.data.forEach((step) => {
+                steps.push(step);
+            });
+            logger.info(getCursorHint(runsSteps));
+        }
+        catch (error) {
+            if (handleApiError(error, opts.backend)) {
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    const runIds = runs.map((item) => item.runId);
+    const stepIds = steps.map((item) => item.stepId);
+    logger.debug(`Found IO for runs/steps: ${runIds.concat(stepIds).join(', ')}`);
+    const runsWithHydratedIO = runs.map(hydrateResourceIO);
+    const stepsWithHydratedIO = steps.map(hydrateResourceIO);
+    const matchingStreams = [
+        ...runsWithHydratedIO,
+        ...stepsWithHydratedIO,
+    ].flatMap((item) => findAllStreamIdsForObjectWithIO({
+        input: item.input,
+        output: item.output,
+        runId: item.runId,
+        stepId: 'stepId' in item ? item.stepId : undefined,
+    }));
+    if (opts.json) {
+        showJson(matchingStreams);
+        return;
+    }
+    logger.log(showTable(matchingStreams, ['runId', 'stepId', 'streamId']));
+};
+const findAllStreamIdsForObjectWithIO = (obj) => {
+    const matchingStreams = [];
+    const inputStreams = getStreamIdsFromHydratedObject(obj.input);
+    for (const streamId of inputStreams) {
+        matchingStreams.push({
+            runId: obj.runId,
+            stepId: obj.stepId || '/',
+            streamId,
+        });
+    }
+    const outputStreams = getStreamIdsFromHydratedObject(obj.output);
+    for (const streamId of outputStreams) {
+        matchingStreams.push({
+            runId: obj.runId,
+            stepId: obj.stepId || '/',
+            streamId,
+        });
+    }
+    return matchingStreams;
+};
+const getStreamIdsFromHydratedObject = (io) => {
+    const streamIds = [];
+    const traverse = (obj) => {
+        if (!obj || typeof obj !== 'object')
+            return;
+        if (isStreamId(obj)) {
+            streamIds.push(obj);
+        }
+        else if (Array.isArray(obj)) {
+            obj.forEach(traverse);
+        }
+        else {
+            Object.values(obj).forEach(traverse);
+        }
+    };
+    traverse(io);
+    return streamIds;
+};
+export const listEvents = async (world, opts = {}) => {
+    if (opts.workflowName) {
+        logger.warn('Filtering by workflow-name is not supported for events, ignoring filter.');
+    }
+    let filterId = opts.hookId || opts.stepId || opts.runId;
+    if (!filterId) {
+        filterId = (await getRecentRun(world, opts))?.runId;
+        if (!filterId) {
+            logger.error('No run found.');
+            return;
+        }
+    }
+    const isCorrelationId = Boolean(opts.hookId || opts.stepId);
+    const params = {
+        pagination: {
+            sortOrder: opts.sort || 'desc',
+            cursor: opts.cursor,
+            limit: opts.limit || DEFAULT_PAGE_SIZE,
+        },
+        resolveData: opts.withData ? 'all' : 'none',
+    };
+    const listCall = isCorrelationId
+        ? (correlationId, pagination) => world.events.listByCorrelationId({
+            ...params,
+            correlationId,
+            pagination: { ...params.pagination, ...pagination },
+        })
+        : (runId, pagination) => world.events.list({
+            ...params,
+            runId,
+            pagination: { ...params.pagination, ...pagination },
+        });
+    // Determine which props to show based on withData flag
+    const props = opts.withData
+        ? EVENT_LISTED_PROPS
+        : EVENT_LISTED_PROPS.filter((prop) => !EVENT_IO_PROPS.includes(prop));
+    // For JSON output, just fetch once and return
+    if (opts.json) {
+        logger.debug(`Fetching events for run ${filterId}`);
+        try {
+            const events = await listCall(filterId, {});
+            showJson(events.data);
+            return;
+        }
+        catch (error) {
+            if (handleApiError(error, opts.backend)) {
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    await setupListPagination({
+        initialCursor: opts.cursor,
+        fetchPage: async (cursor) => {
+            logger.debug(`Fetching events for run ${filterId}`);
+            try {
+                const events = await listCall(filterId, { cursor });
+                return {
+                    data: events.data,
+                    cursor: events.cursor,
+                    hasMore: events.hasMore,
+                };
+            }
+            catch (error) {
+                if (handleApiError(error, opts.backend)) {
+                    process.exit(1);
+                }
+                throw error;
+            }
+        },
+        displayPage: async (events) => {
+            logger.log(showTable(events, props, opts));
+            showInspectInfoBox('event');
+        },
+    });
+};
+export const listHooks = async (world, opts = {}) => {
+    if (opts.workflowName) {
+        logger.warn('Filtering by workflow-name is not supported for hooks, ignoring filter.');
+    }
+    if (opts.stepId) {
+        logger.warn('Filtering by step-id is not supported for hooks, ignoring filter.');
+    }
+    const runId = opts.runId;
+    const resolveData = opts.withData ? 'all' : 'none';
+    // For JSON output, just fetch once and return
+    if (opts.json) {
+        if (!runId) {
+            logger.debug('Fetching all hooks');
+        }
+        else {
+            logger.debug(`Fetching hooks for run ${runId}`);
+        }
+        try {
+            const hooks = await world.hooks.list({
+                runId,
+                pagination: {
+                    sortOrder: opts.sort || 'desc',
+                    cursor: opts.cursor,
+                    limit: opts.limit || DEFAULT_PAGE_SIZE,
+                },
+                resolveData,
+            });
+            const hydratedHooks = hooks.data.map(hydrateResourceIO);
+            showJson({ ...hooks, data: hydratedHooks });
+            return;
+        }
+        catch (error) {
+            if (handleApiError(error, opts.backend)) {
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    // Setup pagination with new mechanism
+    await setupListPagination({
+        initialCursor: opts.cursor,
+        fetchPage: async (cursor) => {
+            if (!runId) {
+                logger.debug('Fetching all hooks');
+            }
+            else {
+                logger.debug(`Fetching hooks for run ${runId}`);
+            }
+            try {
+                const hooks = await world.hooks.list({
+                    runId,
+                    pagination: {
+                        sortOrder: opts.sort || 'desc',
+                        cursor,
+                        limit: opts.limit || DEFAULT_PAGE_SIZE,
+                    },
+                    resolveData,
+                });
+                return {
+                    data: hooks.data,
+                    cursor: hooks.cursor,
+                    hasMore: hooks.hasMore,
+                };
+            }
+            catch (error) {
+                if (handleApiError(error, opts.backend)) {
+                    process.exit(1);
+                }
+                throw error;
+            }
+        },
+        displayPage: async (hooks) => {
+            const hydratedHooks = hooks.map(hydrateResourceIO);
+            logger.log(showTable(hydratedHooks, HOOK_LISTED_PROPS, opts));
+            showInspectInfoBox('hook');
+        },
+    });
+};
+export const showHook = async (world, hookId, opts = {}) => {
+    if (opts.withData) {
+        logger.warn('`withData` flag is ignored when showing individual resources');
+    }
+    try {
+        const hook = await world.hooks.get(hookId, {
+            resolveData: 'all',
+        });
+        const hydratedHook = hydrateResourceIO(hook);
+        if (opts.json) {
+            showJson(hydratedHook);
+            return;
+        }
+        else {
+            logger.log(hydratedHook);
+        }
+    }
+    catch (error) {
+        if (handleApiError(error, opts.backend)) {
+            process.exit(1);
+        }
+        throw error;
+    }
+};
+//# sourceMappingURL=output.js.map