@outputai/cli 0.7.1-next.be9352c.0 → 0.7.1-next.db8ddd7.0

package/bin/run.js

@@ -7,7 +7,7 @@ import { loadCredentialRefs } from '../dist/utils/credentials_loader.js';
 
 // Load environment variables from .env files before executing CLI
 loadEnvironment();
-bootstrapProxy();
+await bootstrapProxy();
 loadCredentialRefs();
 
 await execute( { dir: import.meta.url } );

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

@@ -157,7 +157,7 @@ export declare const WorkflowRunInfoStatus: {
     readonly canceled: "canceled";
     readonly terminated: "terminated";
     readonly timed_out: "timed_out";
-    readonly continued: "continued";
+    readonly continued_as_new: "continued_as_new";
 };
 export interface WorkflowRunInfo {
     /** Unique identifier for this run */
@@ -224,8 +224,41 @@ export declare const WorkflowResultResponseStatus: {
     readonly canceled: "canceled";
     readonly terminated: "terminated";
     readonly timed_out: "timed_out";
-    readonly continued: "continued";
+    readonly continued_as_new: "continued_as_new";
 };
+/**
+ * Structured failure details if the workflow failed, null otherwise
+ * @nullable
+ */
+export type WorkflowResultResponseErrorDetails = {
+    /**
+       * Friendly failure message (from the underlying application error)
+       * @nullable
+       */
+    message?: string | null;
+    /**
+       * Error name/type (the original error's class)
+       * @nullable
+       */
+    name?: string | null;
+    /**
+       * Whether Temporal flagged the failure retryable; null if unknown
+       * @nullable
+       */
+    retryable?: boolean | null;
+    /**
+       * Failing activity key ("workflow#step"); null if no activity failed
+       * @nullable
+       */
+    activityId?: string | null;
+    /**
+       * Sanitized error cause chain (name/message per level, no stack)
+       * @nullable
+       */
+    cause?: {
+        [key: string]: unknown;
+    } | null;
+} | null | null;
 export interface WorkflowResultResponse {
     /** The workflow execution id */
     workflowId?: string;
@@ -248,6 +281,11 @@ export interface WorkflowResultResponse {
        * @nullable
        */
     error?: string | null;
+    /**
+       * Structured failure details if the workflow failed, null otherwise
+       * @nullable
+       */
+    errorDetails?: WorkflowResultResponseErrorDetails;
 }
 export interface StopWorkflowResponse {
     workflowId?: string;

package/dist/api/generated/api.js

@@ -22,7 +22,7 @@ export const WorkflowRunInfoStatus = {
     canceled: 'canceled',
     terminated: 'terminated',
     timed_out: 'timed_out',
-    continued: 'continued',
+    continued_as_new: 'continued_as_new',
 };
 export const WorkflowStatusResponseStatus = {
     canceled: 'canceled',
@@ -40,7 +40,7 @@ export const WorkflowResultResponseStatus = {
     canceled: 'canceled',
     terminated: 'terminated',
     timed_out: 'timed_out',
-    continued: 'continued',
+    continued_as_new: 'continued_as_new',
 };
 ;
 export const getGetHealthUrl = () => {

package/dist/api/workflow_catalog.d.ts

@@ -0,0 +1,7 @@
+import { type Workflow } from './generated/api.js';
+/**
+ * Resolve the workflows in a catalog. When `catalog` is provided (e.g. from
+ * `--catalog`/`OUTPUT_CATALOG_ID`) it resolves that specific catalog, otherwise
+ * the API server's default catalog. Returns `[]` when the catalog has no workflows.
+ */
+export declare function fetchWorkflowCatalog(catalog?: string): Promise<Workflow[]>;

package/dist/api/workflow_catalog.js

@@ -0,0 +1,11 @@
+import { getWorkflowCatalog, getWorkflowCatalogId } from './generated/api.js';
+/**
+ * Resolve the workflows in a catalog. When `catalog` is provided (e.g. from
+ * `--catalog`/`OUTPUT_CATALOG_ID`) it resolves that specific catalog, otherwise
+ * the API server's default catalog. Returns `[]` when the catalog has no workflows.
+ */
+export async function fetchWorkflowCatalog(catalog) {
+    const response = catalog ? await getWorkflowCatalogId(catalog) : await getWorkflowCatalog();
+    const data = response?.data;
+    return data?.workflows ?? [];
+}

package/dist/api/workflow_catalog.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/workflow_catalog.spec.js

@@ -0,0 +1,30 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as api from './generated/api.js';
+import { fetchWorkflowCatalog } from './workflow_catalog.js';
+vi.mock('./generated/api.js', () => ({
+    getWorkflowCatalog: vi.fn(),
+    getWorkflowCatalogId: vi.fn()
+}));
+describe('fetchWorkflowCatalog', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('fetches the default catalog when no catalog id is provided', async () => {
+        vi.mocked(api.getWorkflowCatalog).mockResolvedValue({ data: { workflows: [{ name: 'a' }] } });
+        const result = await fetchWorkflowCatalog();
+        expect(api.getWorkflowCatalog).toHaveBeenCalledTimes(1);
+        expect(api.getWorkflowCatalogId).not.toHaveBeenCalled();
+        expect(result).toEqual([{ name: 'a' }]);
+    });
+    it('fetches a specific catalog by id when one is provided', async () => {
+        vi.mocked(api.getWorkflowCatalogId).mockResolvedValue({ data: { workflows: [{ name: 'b' }] } });
+        const result = await fetchWorkflowCatalog('my-catalog');
+        expect(api.getWorkflowCatalogId).toHaveBeenCalledWith('my-catalog');
+        expect(api.getWorkflowCatalog).not.toHaveBeenCalled();
+        expect(result).toEqual([{ name: 'b' }]);
+    });
+    it('returns an empty array when the catalog response has no workflows', async () => {
+        vi.mocked(api.getWorkflowCatalog).mockResolvedValue({ data: {} });
+        expect(await fetchWorkflowCatalog()).toEqual([]);
+    });
+});

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

@@ -80,7 +80,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.7.1-next.be9352c.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.7.1-next.db8ddd7.0}
     init: true
     networks:
       - main

package/dist/commands/update.js

@@ -31,7 +31,7 @@ export default class Update extends Command {
     async updateCli() {
         const latest = await fetchLatestVersion();
         if (!latest) {
-            this.error('Could not fetch the latest version from npm. Check your network connection.');
+            this.error('Could not fetch the latest version from the npm registry. Run with DEBUG=output-cli:npm-update for details.');
         }
         this.log(`\nLatest @outputai/cli version: v${latest}\n`);
         await this.handleGlobalUpdate(latest);

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

@@ -9,10 +9,12 @@ interface WorkflowDisplay {
     aliases: string;
 }
 export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDisplay;
+export declare function formatWorkflowsAsList(workflows: Workflow[]): string;
 export default class WorkflowList extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         detailed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         filter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/workflow/list.js

@@ -1,6 +1,6 @@
 import { Command, Flags } from '@oclif/core';
 import Table from 'cli-table3';
-import { getWorkflowCatalog } from '#api/generated/api.js';
+import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
 import { parseWorkflowDefinition, formatParameters } from '#api/parser.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { listScenariosForWorkflow } from '#utils/scenario_resolver.js';
@@ -65,10 +65,13 @@ function createWorkflowTable(workflows, detailed) {
     });
     return table.toString();
 }
-function formatWorkflowsAsList(workflows) {
-    const sortedWorkflows = sortWorkflowsByName(workflows);
-    const names = sortedWorkflows.map(w => parseWorkflowForDisplay(w).name);
-    return `\nWorkflows:\n\n${names.map(name => `- ${name}`).join('\n')}`;
+function formatWorkflowAsListItem(workflow) {
+    const { name, aliases } = parseWorkflowForDisplay(workflow);
+    return aliases === 'none' ? `- ${name}` : `- ${name} (aliases: ${aliases})`;
+}
+export function formatWorkflowsAsList(workflows) {
+    const lines = sortWorkflowsByName(workflows).map(formatWorkflowAsListItem);
+    return `\nWorkflows:\n\n${lines.join('\n')}`;
 }
 function formatWorkflowsAsJson(workflows) {
     const output = {
@@ -103,9 +106,18 @@ export default class WorkflowList extends Command {
         '<%= config.bin %> <%= command.id %> --format table',
         '<%= config.bin %> <%= command.id %> --format json',
         '<%= config.bin %> <%= command.id %> --detailed',
-        '<%= config.bin %> <%= command.id %> --filter simple'
+        '<%= config.bin %> <%= command.id %> --filter simple',
+        '<%= config.bin %> <%= command.id %> --catalog my-catalog'
     ];
     static flags = {
+        catalog: Flags.string({
+            char: 'c',
+            aliases: ['task-queue'],
+            charAliases: ['q'],
+            deprecateAliases: true,
+            description: 'Catalog to list workflows from (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
+        }),
         format: Flags.string({
             char: 'f',
             description: 'Output format',
@@ -123,25 +135,15 @@ export default class WorkflowList extends Command {
     };
     async run() {
         const { flags } = await this.parse(WorkflowList);
-        this.log('Fetching workflow catalog...');
-        const response = await getWorkflowCatalog();
-        if (!response) {
-            this.error('Failed to connect to API server. Is it running?', { exit: 1 });
-        }
-        if (!response.data) {
-            this.error('API returned invalid response (missing data)', { exit: 1 });
-        }
-        const data = response.data;
-        if (!data.workflows) {
-            this.error('API returned invalid response (missing workflows)', { exit: 1 });
-        }
-        if (data.workflows.length === 0) {
+        this.log(flags.catalog ? `Fetching workflow catalog: ${flags.catalog}...` : 'Fetching workflow catalog...');
+        const catalogWorkflows = await fetchWorkflowCatalog(flags.catalog);
+        if (catalogWorkflows.length === 0) {
             this.log('No workflows found in catalog.');
             return;
         }
         const workflows = flags.filter ?
-            data.workflows.filter(matchName(flags.filter)) :
-            data.workflows;
+            catalogWorkflows.filter(matchName(flags.filter)) :
+            catalogWorkflows;
         if (workflows.length === 0 && flags.filter) {
             this.log(`No workflows matching filter: ${flags.filter}`);
             return;

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

@@ -1,8 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 const mockListScenarios = vi.fn().mockReturnValue([]);
 vi.mock('#utils/scenario_resolver.js', () => ({
     listScenariosForWorkflow: mockListScenarios
 }));
+vi.mock('#api/workflow_catalog.js', () => ({
+    fetchWorkflowCatalog: vi.fn()
+}));
 describe('workflow list command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -15,6 +19,12 @@ describe('workflow list command', () => {
             expect(WorkflowList.flags).toHaveProperty('format');
             expect(WorkflowList.flags).toHaveProperty('detailed');
             expect(WorkflowList.flags).toHaveProperty('filter');
+            expect(WorkflowList.flags).toHaveProperty('catalog');
+        });
+        it('reads the catalog flag from OUTPUT_CATALOG_ID', async () => {
+            const WorkflowList = (await import('./list.js')).default;
+            expect(WorkflowList.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(WorkflowList.flags.catalog.char).toBe('c');
         });
         it('should have correct flag configuration', async () => {
             const WorkflowList = (await import('./list.js')).default;
@@ -118,3 +128,50 @@ describe('workflow list parsing', () => {
         expect(parsed.inputs).toContain('user.email: string');
     });
 });
+describe('formatWorkflowsAsList', () => {
+    it('appends aliases to the default list when present', async () => {
+        const { formatWorkflowsAsList } = await import('./list.js');
+        const output = formatWorkflowsAsList([
+            { name: 'galileoExtractKeyword', aliases: ['seoContentExtractKeywordWorkflow'] }
+        ]);
+        expect(output).toContain('- galileoExtractKeyword (aliases: seoContentExtractKeywordWorkflow)');
+    });
+    it('omits the aliases segment when a workflow has none', async () => {
+        const { formatWorkflowsAsList } = await import('./list.js');
+        const output = formatWorkflowsAsList([{ name: 'simple' }]);
+        expect(output).toContain('- simple');
+        expect(output).not.toContain('aliases:');
+    });
+});
+describe('run() catalog resolution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    const catalogWorkflows = [{ name: 'simple' }];
+    const createCommand = async (flagOverrides) => {
+        const WorkflowList = (await import('./list.js')).default;
+        const cmd = new WorkflowList([], {});
+        cmd.log = vi.fn();
+        cmd.error = vi.fn(() => {
+            throw new Error('error called');
+        });
+        cmd.parse = vi.fn().mockResolvedValue({
+            flags: { format: 'list', detailed: false, filter: undefined, catalog: undefined, ...flagOverrides }
+        });
+        return cmd;
+    };
+    it('fetches a specific catalog by id when a catalog is provided', async () => {
+        const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
+        vi.mocked(fetchWorkflowCatalog).mockResolvedValue(catalogWorkflows);
+        const cmd = await createCommand({ catalog: 'my-catalog' });
+        await cmd.run();
+        expect(fetchWorkflowCatalog).toHaveBeenCalledWith('my-catalog');
+    });
+    it('falls back to the default catalog when no catalog is provided', async () => {
+        const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
+        vi.mocked(fetchWorkflowCatalog).mockResolvedValue(catalogWorkflows);
+        const cmd = await createCommand({ catalog: undefined });
+        await cmd.run();
+        expect(fetchWorkflowCatalog).toHaveBeenCalledWith(undefined);
+    });
+});

package/dist/commands/workflow/status.js

@@ -3,6 +3,7 @@ import { getWorkflowIdStatus } from '#api/generated/api.js';
 import { OUTPUT_FORMAT } from '#utils/constants.js';
 import { formatOutput } from '#utils/output_formatter.js';
 import { handleApiError } from '#utils/error_handler.js';
+import { normalizeWorkflowStatus } from '#utils/normalize_workflow_status.js';
 export default class WorkflowStatus extends Command {
     static description = 'Get workflow execution status';
     static examples = [
@@ -30,7 +31,11 @@ export default class WorkflowStatus extends Command {
         if (!response || !response.data) {
             this.error('API returned invalid response', { exit: 1 });
         }
-        const data = response.data;
+        const rawData = response.data;
+        const data = {
+            ...rawData,
+            status: normalizeWorkflowStatus(rawData.status)
+        };
         const output = formatOutput(data, flags.format, (result) => {
             const lines = [
                 `Workflow ID: ${result.workflowId || 'unknown'}`,

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.7.1-next.be9352c.0"
+    "framework": "0.7.1-next.db8ddd7.0"
 }

package/dist/hooks/init.js

@@ -1,6 +1,8 @@
 import { ux } from '@oclif/core';
-import { checkForUpdate } from '#services/version_check.js';
+import debugFactory from 'debug';
+import { readCachedResult, spawnBackgroundRefresh } from '#services/version_check.js';
 import { setNonInteractive } from '#utils/interactive.js';
+const debug = debugFactory('output-cli:init');
 export const INTERACTIVE_FLAGS = ['--yes', '--non-interactive'];
 export const GLOBAL_FLAGS = new Set(INTERACTIVE_FLAGS);
 export const hasInteractiveFlag = (argv) => argv.some(arg => INTERACTIVE_FLAGS.includes(arg));
@@ -18,7 +20,13 @@ const hook = async function (opts) {
         setNonInteractive(true);
     }
     try {
-        const result = await checkForUpdate(this.config.version, this.config.cacheDir);
+        // Only the local cache is read here; the registry roundtrip happens in a
+        // detached child so it never delays the invoked command.
+        const result = await readCachedResult(this.config.version, this.config.cacheDir);
+        if (!result) {
+            spawnBackgroundRefresh(this.config.version, this.config.cacheDir);
+            return;
+        }
         if (!result.updateAvailable) {
             return;
         }
@@ -39,8 +47,9 @@ const hook = async function (opts) {
         ux.stdout(border);
         ux.stdout('');
     }
-    catch {
+    catch (error) {
         // Never block CLI execution
+        debug('Version banner failed: %O', error);
     }
 };
 export default hook;

package/dist/hooks/init.spec.js

@@ -1,9 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { checkForUpdate } from '#services/version_check.js';
+import { readCachedResult, spawnBackgroundRefresh } from '#services/version_check.js';
 import { setNonInteractive } from '#utils/interactive.js';
 vi.mock('#services/version_check.js', () => ({
-    checkForUpdate: vi.fn()
+    readCachedResult: vi.fn(),
+    spawnBackgroundRefresh: vi.fn()
 }));
 vi.mock('#utils/interactive.js', () => ({
     setNonInteractive: vi.fn()
@@ -23,15 +24,16 @@ describe('init hook', () => {
     const createHookContext = (version = '0.8.4') => ({
         config: { version, cacheDir: '/tmp/test-cache' }
     });
-    it('should display warning when update is available', async () => {
-        vi.mocked(checkForUpdate).mockResolvedValue({
+    it('should display warning when cached result says an update is available', async () => {
+        vi.mocked(readCachedResult).mockResolvedValue({
             updateAvailable: true,
             currentVersion: '0.8.4',
             latestVersion: '1.0.0'
         });
         const ctx = createHookContext();
         await hook.call(ctx, { argv: [], id: undefined });
-        expect(checkForUpdate).toHaveBeenCalledWith('0.8.4', '/tmp/test-cache');
+        expect(readCachedResult).toHaveBeenCalledWith('0.8.4', '/tmp/test-cache');
+        expect(spawnBackgroundRefresh).not.toHaveBeenCalled();
         expect(ux.stdout).toHaveBeenCalled();
         const output = vi.mocked(ux.stdout).mock.calls.map(c => c[0]).join('\n');
         expect(output).toContain('Uhoh');
@@ -40,17 +42,25 @@ describe('init hook', () => {
         expect(output).toContain('npx output update');
     });
     it('should not display anything when up to date', async () => {
-        vi.mocked(checkForUpdate).mockResolvedValue({
+        vi.mocked(readCachedResult).mockResolvedValue({
             updateAvailable: false,
             currentVersion: '0.8.4',
             latestVersion: '0.8.4'
         });
         const ctx = createHookContext();
         await hook.call(ctx, { argv: [], id: undefined });
+        expect(spawnBackgroundRefresh).not.toHaveBeenCalled();
+        expect(ux.stdout).not.toHaveBeenCalled();
+    });
+    it('should kick off a background refresh and stay silent when the cache is stale', async () => {
+        vi.mocked(readCachedResult).mockResolvedValue(null);
+        const ctx = createHookContext();
+        await hook.call(ctx, { argv: [], id: undefined });
+        expect(spawnBackgroundRefresh).toHaveBeenCalledWith('0.8.4', '/tmp/test-cache');
         expect(ux.stdout).not.toHaveBeenCalled();
     });
     it('should silently handle errors', async () => {
-        vi.mocked(checkForUpdate).mockRejectedValue(new Error('network failure'));
+        vi.mocked(readCachedResult).mockRejectedValue(new Error('cache failure'));
         const ctx = createHookContext();
         await hook.call(ctx, { argv: [], id: undefined });
         expect(ux.stdout).not.toHaveBeenCalled();
@@ -58,7 +68,7 @@ describe('init hook', () => {
     describe('global interactive flags', () => {
         const originalArgv = process.argv;
         beforeEach(() => {
-            vi.mocked(checkForUpdate).mockResolvedValue({
+            vi.mocked(readCachedResult).mockResolvedValue({
                 updateAvailable: false,
                 currentVersion: '0.8.4',
                 latestVersion: '0.8.4'

package/dist/scripts/refresh_version_check.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/refresh_version_check.js

@@ -0,0 +1,9 @@
+// Detached helper spawned by spawnBackgroundRefresh (version_check.ts):
+// refreshes the version-check cache off the critical path.
+// Args: <currentVersion> <cacheDir>
+import debugFactory from 'debug';
+import { bootstrapProxy } from '#utils/proxy.js';
+import { runRefresh } from '#services/version_check.js';
+const debug = debugFactory('output-cli:version-check');
+await bootstrapProxy().catch(error => debug('Proxy bootstrap failed: %O', error));
+process.exitCode = await runRefresh(process.argv);

package/dist/services/cost_calculator.d.ts

@@ -1,12 +1,8 @@
-import type { TraceNode, LLMCall, HTTPCall, TokenUsage, PricingConfig, ModelPricing, ServiceConfig, ServiceCostResult, CostReport } from '#types/cost.js';
+import type { TraceNode, LLMCall, HTTPCall, PricingConfig, ServiceConfig, ServiceCostResult, CostReport } from '#types/cost.js';
 export declare function extractValue(obj: unknown, path: string): unknown;
 export declare function loadPricingConfig(configPath?: string): PricingConfig;
 export declare function findLLMCalls(node: TraceNode, parentStepName?: string | null, seenIds?: Set<string>): LLMCall[];
 export declare function findHTTPCalls(node: TraceNode, parentStepName?: string | null, seenIds?: Set<string>): HTTPCall[];
-export declare function calculateLLMCallCost(usage: TokenUsage, modelPricing: ModelPricing | undefined): {
-    cost: number;
-    warning?: string;
-};
 export declare function identifyService(httpCall: HTTPCall, services: Record<string, ServiceConfig>): {
     serviceName: string;
     config: ServiceConfig;