@output.ai/cli 0.4.1 → 0.4.2

package/dist/api/generated/api.d.ts

@@ -54,6 +54,39 @@ export interface TraceInfo {
     /** File destinations for trace data */
     destinations?: TraceInfoDestinations;
 }
+/**
+ * Current run status
+ */
+export type WorkflowRunInfoStatus = typeof WorkflowRunInfoStatus[keyof typeof WorkflowRunInfoStatus];
+export declare const WorkflowRunInfoStatus: {
+    readonly running: "running";
+    readonly completed: "completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+    readonly terminated: "terminated";
+    readonly timed_out: "timed_out";
+    readonly continued: "continued";
+};
+export interface WorkflowRunInfo {
+    /** Unique identifier for this run */
+    workflowId?: string;
+    /** Name of the workflow definition */
+    workflowType?: string;
+    /** Current run status */
+    status?: WorkflowRunInfoStatus;
+    /** ISO 8601 timestamp of run start */
+    startedAt?: string;
+    /**
+     * ISO 8601 timestamp of completion, or null if still running
+     * @nullable
+     */
+    completedAt?: string | null;
+}
+export interface WorkflowRunsResponse {
+    runs?: WorkflowRunInfo[];
+    /** Total number of runs returned */
+    count?: number;
+}
 export type PostWorkflowRunBody = {
     /** The name of the workflow to execute */
     workflowName: string;
@@ -124,6 +157,18 @@ export type GetWorkflowCatalog200 = {
     /** Each workflow available in this catalog */
     workflows?: Workflow[];
 };
+export type GetWorkflowRunsParams = {
+    /**
+     * Filter by workflow type/name
+     */
+    workflowType?: string;
+    /**
+     * Maximum number of runs to return
+     * @minimum 1
+     * @maximum 1000
+     */
+    limit?: number;
+};
 export type PostWorkflowIdFeedbackBody = {
     /** The payload to send to the workflow */
     payload?: unknown;
@@ -254,6 +299,27 @@ export type getWorkflowCatalogResponseSuccess = (getWorkflowCatalogResponse200)
 export type getWorkflowCatalogResponse = (getWorkflowCatalogResponseSuccess);
 export declare const getGetWorkflowCatalogUrl: () => string;
 export declare const getWorkflowCatalog: (options?: ApiRequestOptions) => Promise<getWorkflowCatalogResponse>;
+/**
+ * Returns a list of workflow runs with optional filtering by workflow type
+ * @summary List workflow runs
+ */
+export type getWorkflowRunsResponse200 = {
+    data: WorkflowRunsResponse;
+    status: 200;
+};
+export type getWorkflowRunsResponse400 = {
+    data: void;
+    status: 400;
+};
+export type getWorkflowRunsResponseSuccess = (getWorkflowRunsResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowRunsResponseError = (getWorkflowRunsResponse400) & {
+    headers: Headers;
+};
+export type getWorkflowRunsResponse = (getWorkflowRunsResponseSuccess | getWorkflowRunsResponseError);
+export declare const getGetWorkflowRunsUrl: (params?: GetWorkflowRunsParams) => string;
+export declare const getWorkflowRuns: (params?: GetWorkflowRunsParams, options?: ApiRequestOptions) => Promise<getWorkflowRunsResponse>;
 /**
  * @summary Send feedback to a payload
  */

package/dist/api/generated/api.js

@@ -7,6 +7,16 @@
  */
 import { customFetchInstance } from '../http_client.js';
 // eslint-disable-next-line @typescript-eslint/no-redeclare
+export const WorkflowRunInfoStatus = {
+    running: 'running',
+    completed: 'completed',
+    failed: 'failed',
+    canceled: 'canceled',
+    terminated: 'terminated',
+    timed_out: 'timed_out',
+    continued: 'continued',
+};
+// eslint-disable-next-line @typescript-eslint/no-redeclare
 export const GetWorkflowIdStatus200Status = {
     canceled: 'canceled',
     completed: 'completed',
@@ -98,6 +108,22 @@ export const getWorkflowCatalog = async (options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowRunsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/runs?${stringifiedParams}` : `/workflow/runs`;
+};
+export const getWorkflowRuns = async (params, options) => {
+    return customFetchInstance(getGetWorkflowRunsUrl(params), {
+        ...options,
+        method: 'GET'
+    });
+};
 ;
 export const getPostWorkflowIdFeedbackUrl = (id) => {
     return `/workflow/${id}/feedback`;

package/dist/assets/docker/docker-compose-dev.yml

@@ -80,7 +80,6 @@ services:
       temporal:
         condition: service_healthy
     image: growthxteam/output-api:latest
-    pull_policy: always
     networks:
       - main
     environment:

package/dist/commands/workflow/runs/list.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class WorkflowRunsList extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workflowName: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/runs/list.js

@@ -0,0 +1,104 @@
+import { Args, Command, Flags } from '@oclif/core';
+import Table from 'cli-table3';
+import { fetchWorkflowRuns } from '#services/workflow_runs.js';
+import { formatDate, formatDurationFromTimestamps } from '#utils/date_formatter.js';
+import { handleApiError } from '#utils/error_handler.js';
+const OUTPUT_FORMAT = {
+    TABLE: 'table',
+    JSON: 'json',
+    TEXT: 'text'
+};
+function createRunsTable(runs) {
+    const table = new Table({
+        head: ['Workflow ID', 'Type', 'Status', 'Started', 'Duration'],
+        colWidths: [40, 20, 12, 22, 10],
+        wordWrap: true,
+        style: {
+            head: ['cyan']
+        }
+    });
+    runs.forEach(run => {
+        table.push([
+            run.workflowId || '-',
+            run.workflowType || '-',
+            run.status || '-',
+            formatDate(run.startedAt),
+            formatDurationFromTimestamps(run.startedAt || '', run.completedAt)
+        ]);
+    });
+    return table.toString();
+}
+function formatRunsAsText(runs) {
+    if (runs.length === 0) {
+        return 'No workflow runs found.';
+    }
+    return runs.map(run => {
+        const duration = formatDurationFromTimestamps(run.startedAt || '', run.completedAt);
+        return `${run.workflowId} (${run.workflowType}) - ${run.status} [${duration}]`;
+    }).join('\n');
+}
+function formatRunsAsJson(runs) {
+    return JSON.stringify(runs, null, 2);
+}
+function formatRuns(runs, format) {
+    if (format === OUTPUT_FORMAT.JSON) {
+        return formatRunsAsJson(runs);
+    }
+    if (format === OUTPUT_FORMAT.TABLE) {
+        return createRunsTable(runs);
+    }
+    return formatRunsAsText(runs);
+}
+export default class WorkflowRunsList extends Command {
+    static description = 'List workflow runs with optional filtering by workflow type';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> simple',
+        '<%= config.bin %> <%= command.id %> simple --limit 10',
+        '<%= config.bin %> <%= command.id %> --format json',
+        '<%= config.bin %> <%= command.id %> --format table'
+    ];
+    static args = {
+        workflowName: Args.string({
+            description: 'Filter by workflow type/name',
+            required: false
+        })
+    };
+    static flags = {
+        limit: Flags.integer({
+            char: 'l',
+            description: 'Maximum number of runs to return',
+            default: 100
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
+            default: OUTPUT_FORMAT.TABLE
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowRunsList);
+        const { runs, count } = await fetchWorkflowRuns({
+            workflowType: args.workflowName,
+            limit: flags.limit
+        });
+        if (runs.length === 0) {
+            const filterMsg = args.workflowName ? ` for workflow type "${args.workflowName}"` : '';
+            this.log(`No workflow runs found${filterMsg}.`);
+            return;
+        }
+        const output = formatRuns(runs, flags.format);
+        this.log(output);
+        if (flags.format !== OUTPUT_FORMAT.JSON) {
+            const filterMsg = args.workflowName ? ` of type "${args.workflowName}"` : '';
+            this.log(`\nFound ${count} run(s)${filterMsg}`);
+        }
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            400: 'Invalid parameters provided.',
+            503: 'Workflow service temporarily unavailable.'
+        });
+    }
+}

package/dist/services/workflow_runs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Workflow runs service for fetching workflow run data from the API
+ */
+import { type WorkflowRunInfo } from '#api/generated/api.js';
+export type WorkflowRun = WorkflowRunInfo;
+export interface WorkflowRunsResult {
+    runs: WorkflowRun[];
+    count: number;
+}
+export interface FetchWorkflowRunsOptions {
+    workflowType?: string;
+    limit?: number;
+}
+export declare function fetchWorkflowRuns(options?: FetchWorkflowRunsOptions): Promise<WorkflowRunsResult>;

package/dist/services/workflow_runs.js

@@ -0,0 +1,24 @@
+/**
+ * Workflow runs service for fetching workflow run data from the API
+ */
+import { getWorkflowRuns } from '#api/generated/api.js';
+export async function fetchWorkflowRuns(options = {}) {
+    const params = {};
+    if (options.limit) {
+        params.limit = options.limit;
+    }
+    if (options.workflowType) {
+        params.workflowType = options.workflowType;
+    }
+    const response = await getWorkflowRuns(params);
+    if (!response) {
+        throw new Error('Failed to connect to API server. Is it running?');
+    }
+    if (!response.data) {
+        throw new Error('API returned invalid response (missing data)');
+    }
+    return {
+        runs: response.data.runs || [],
+        count: response.data.count || 0
+    };
+}

package/dist/utils/date_formatter.d.ts

@@ -6,3 +6,18 @@
  * @returns Formatted duration string (e.g., "150ms", "2.50s", "3 minutes 45 seconds")
  */
 export declare function formatDuration(ms: number): string;
+/**
+ * Format an ISO date string to a human-readable format
+ *
+ * @param isoString - ISO 8601 date string
+ * @returns Formatted date string (e.g., "Dec 3, 2025 10:30 AM")
+ */
+export declare function formatDate(isoString: string | null | undefined): string;
+/**
+ * Format a duration between two ISO timestamps
+ *
+ * @param startedAt - ISO 8601 start timestamp
+ * @param completedAt - ISO 8601 end timestamp (or null if still running)
+ * @returns Human-readable duration string (e.g., "5 seconds", "running")
+ */
+export declare function formatDurationFromTimestamps(startedAt: string, completedAt: string | null | undefined): string;

package/dist/utils/date_formatter.js

@@ -1,4 +1,7 @@
-import { formatDuration as formatDurationFns, intervalToDuration } from 'date-fns';
+/**
+ * Date and duration formatting utilities
+ */
+import { format, formatDistanceStrict, formatDuration as formatDurationFns, intervalToDuration, parseISO } from 'date-fns';
 /**
  * Format a duration in milliseconds to a human-readable string.
  * Uses date-fns for durations >= 1 minute, custom formatting for shorter durations.
@@ -17,3 +20,30 @@ export function formatDuration(ms) {
     }
     return formatDurationFns(duration, { format: ['minutes', 'seconds'] });
 }
+/**
+ * Format an ISO date string to a human-readable format
+ *
+ * @param isoString - ISO 8601 date string
+ * @returns Formatted date string (e.g., "Dec 3, 2025 10:30 AM")
+ */
+export function formatDate(isoString) {
+    if (!isoString) {
+        return '-';
+    }
+    return format(parseISO(isoString), 'MMM d, yyyy h:mm a');
+}
+/**
+ * Format a duration between two ISO timestamps
+ *
+ * @param startedAt - ISO 8601 start timestamp
+ * @param completedAt - ISO 8601 end timestamp (or null if still running)
+ * @returns Human-readable duration string (e.g., "5 seconds", "running")
+ */
+export function formatDurationFromTimestamps(startedAt, completedAt) {
+    if (!completedAt) {
+        return 'running';
+    }
+    const start = parseISO(startedAt);
+    const end = parseISO(completedAt);
+    return formatDistanceStrict(start, end, { addSuffix: false });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",