@outputai/cli 0.2.1-next.7fd86e7.0 → 0.2.1-next.bc8ccee.0

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

@@ -162,6 +162,8 @@ export declare const WorkflowRunInfoStatus: {
 export interface WorkflowRunInfo {
     /** Unique identifier for this run */
     workflowId?: string;
+    /** The specific run id for this execution */
+    runId?: string;
     /** Name of the workflow definition */
     workflowType?: string;
     /** Current run status */
@@ -257,9 +259,9 @@ export interface ResetWorkflowResponse {
     runId?: string;
 }
 /**
- * Invalid request body or query (validation failed)
+ * Invalid request body, query, or pagination token
  */
-export type BadRequestResponse = ValidationErrorResponse;
+export type BadRequestResponse = ValidationErrorResponse | ErrorResponse;
 /**
  * Workflow execution, workflow type, or catalog not found
  */
@@ -344,6 +346,86 @@ export type PostWorkflowIdRunsRidTerminateBody = {
 export type PostWorkflowIdTerminateBody = {
     reason?: string;
 };
+export type GetWorkflowIdHistoryParams = {
+    /**
+     * Specific run ID. Required when using pageToken.
+     */
+    runId?: string;
+    /**
+     * Number of events per page
+     * @minimum 1
+     * @maximum 50
+     */
+    pageSize?: number;
+    /**
+     * Base64 pagination token from previous response
+     */
+    pageToken?: string;
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+};
+/**
+ * Workflow metadata (null on subsequent pages)
+ * @nullable
+ */
+export type GetWorkflowIdHistory200Workflow = {
+    [key: string]: unknown;
+} | null;
+export type GetWorkflowIdHistory200EventsItem = {
+    [key: string]: unknown;
+};
+export type GetWorkflowIdHistory200 = {
+    /**
+       * Workflow metadata (null on subsequent pages)
+       * @nullable
+       */
+    workflow?: GetWorkflowIdHistory200Workflow;
+    events?: GetWorkflowIdHistory200EventsItem[];
+    /** Resolved run ID. Echo this value as the runId query parameter when fetching subsequent pages. */
+    runId?: string;
+    /** @nullable */
+    nextPageToken?: string | null;
+};
+export type GetWorkflowIdRunsRidHistoryParams = {
+    /**
+     * Number of events per page
+     * @minimum 1
+     * @maximum 50
+     */
+    pageSize?: number;
+    /**
+     * Base64 pagination token from previous response
+     */
+    pageToken?: string;
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+};
+/**
+ * Workflow metadata (null on subsequent pages)
+ * @nullable
+ */
+export type GetWorkflowIdRunsRidHistory200Workflow = {
+    [key: string]: unknown;
+} | null;
+export type GetWorkflowIdRunsRidHistory200EventsItem = {
+    [key: string]: unknown;
+};
+export type GetWorkflowIdRunsRidHistory200 = {
+    /**
+       * Workflow metadata (null on subsequent pages)
+       * @nullable
+       */
+    workflow?: GetWorkflowIdRunsRidHistory200Workflow;
+    events?: GetWorkflowIdRunsRidHistory200EventsItem[];
+    /** The pinned run ID */
+    runId?: string;
+    /** @nullable */
+    nextPageToken?: string | null;
+};
 export type GetWorkflowCatalogId200 = {
     /** Each workflow available in this catalog */
     workflows?: Workflow[];
@@ -854,6 +936,63 @@ export type getWorkflowIdRunsRidTraceLogResponseError = (getWorkflowIdRunsRidTra
 export type getWorkflowIdRunsRidTraceLogResponse = (getWorkflowIdRunsRidTraceLogResponseSuccess | getWorkflowIdRunsRidTraceLogResponseError);
 export declare const getGetWorkflowIdRunsRidTraceLogUrl: (id: string, rid: string) => string;
 export declare const getWorkflowIdRunsRidTraceLog: (id: string, rid: string, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidTraceLogResponse>;
+/**
+ * Returns decoded Temporal history events with optional payload inclusion. First page includes workflow metadata; subsequent pages return events only.
+ * @summary Get paginated workflow execution history
+ */
+export type getWorkflowIdHistoryResponse200 = {
+    data: GetWorkflowIdHistory200;
+    status: 200;
+};
+export type getWorkflowIdHistoryResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdHistoryResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdHistoryResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdHistoryResponseSuccess = (getWorkflowIdHistoryResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryResponseError = (getWorkflowIdHistoryResponse400 | getWorkflowIdHistoryResponse404 | getWorkflowIdHistoryResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryResponse = (getWorkflowIdHistoryResponseSuccess | getWorkflowIdHistoryResponseError);
+export declare const getGetWorkflowIdHistoryUrl: (id: string, params?: GetWorkflowIdHistoryParams) => string;
+export declare const getWorkflowIdHistory: (id: string, params?: GetWorkflowIdHistoryParams, options?: ApiRequestOptions) => Promise<getWorkflowIdHistoryResponse>;
+/**
+ * @summary Get paginated workflow execution history for a specific run
+ */
+export type getWorkflowIdRunsRidHistoryResponse200 = {
+    data: GetWorkflowIdRunsRidHistory200;
+    status: 200;
+};
+export type getWorkflowIdRunsRidHistoryResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdRunsRidHistoryResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdRunsRidHistoryResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdRunsRidHistoryResponseSuccess = (getWorkflowIdRunsRidHistoryResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryResponseError = (getWorkflowIdRunsRidHistoryResponse400 | getWorkflowIdRunsRidHistoryResponse404 | getWorkflowIdRunsRidHistoryResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryResponse = (getWorkflowIdRunsRidHistoryResponseSuccess | getWorkflowIdRunsRidHistoryResponseError);
+export declare const getGetWorkflowIdRunsRidHistoryUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams) => string;
+export declare const getWorkflowIdRunsRidHistory: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryResponse>;
 /**
  * @summary Get a specific workflow catalog by ID
  */

package/dist/api/generated/api.js

@@ -194,6 +194,38 @@ export const getWorkflowIdRunsRidTraceLog = async (id, rid, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdHistoryUrl = (id, 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/${id}/history?${stringifiedParams}` : `/workflow/${id}/history`;
+};
+export const getWorkflowIdHistory = async (id, params, options) => {
+    return customFetchInstance(getGetWorkflowIdHistoryUrl(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getGetWorkflowIdRunsRidHistoryUrl = (id, rid, 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/${id}/runs/${rid}/history?${stringifiedParams}` : `/workflow/${id}/runs/${rid}/history`;
+};
+export const getWorkflowIdRunsRidHistory = async (id, rid, params, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidHistoryUrl(id, rid, params), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowCatalogIdUrl = (id) => {
     return `/workflow/catalog/${id}`;
 };

package/dist/api/http_client.js

@@ -14,26 +14,31 @@ export class HttpError extends Error {
         this.name = 'HttpError';
     }
 }
-const api = ky.create({
-    prefixUrl: config.apiUrl,
-    timeout: config.requestTimeout,
-    retry: {
-        limit: 2,
-        methods: ['get', 'put', 'head', 'delete', 'options', 'trace'],
-        statusCodes: [408, 413, 429, 502, 503, 504]
-    },
-    throwHttpErrors: false,
-    hooks: {
-        beforeRequest: [
-            request => {
-                // Add auth token if available
-                if (config.apiToken) {
-                    request.headers.set('Authorization', `Basic ${config.apiToken}`);
-                }
+const apiState = {};
+function getApi() {
+    if (!apiState.api) {
+        apiState.api = ky.create({
+            prefixUrl: config.apiUrl,
+            timeout: config.requestTimeout,
+            retry: {
+                limit: 2,
+                methods: ['get', 'put', 'head', 'delete', 'options', 'trace'],
+                statusCodes: [408, 413, 429, 502, 503, 504]
+            },
+            throwHttpErrors: false,
+            hooks: {
+                beforeRequest: [
+                    request => {
+                        if (config.apiToken) {
+                            request.headers.set('Authorization', `Basic ${config.apiToken}`);
+                        }
+                    }
+                ]
             }
-        ]
+        });
     }
-});
+    return apiState.api;
+}
 const stripLeadingSlash = (url) => url.startsWith('/') ? url.slice(1) : url;
 const buildKyOptions = (options) => {
     // Extract params, config, and body for special handling
@@ -55,7 +60,7 @@ const wrapResponse = (response, data) => ({
     headers: response.headers
 });
 export const customFetchInstance = async (url, options) => {
-    const response = await api(stripLeadingSlash(url), buildKyOptions(options));
+    const response = await getApi()(stripLeadingSlash(url), buildKyOptions(options));
     const data = await response.json().catch(() => undefined);
     // Throw for non-2xx responses so catch handlers can process errors
     if (!response.ok) {

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

@@ -81,7 +81,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.2.1-next.7fd86e7.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.2.1-next.bc8ccee.0}
     init: true
     networks:
       - main

package/dist/commands/init.d.ts

@@ -7,6 +7,7 @@ export default class Init extends Command {
     };
     static flags: {
         'skip-env': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'skip-git': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/init.js

@@ -18,12 +18,16 @@ export default class Init extends Command {
         'skip-env': Flags.boolean({
             description: 'Skip interactive environment variable configuration',
             default: false
+        }),
+        'skip-git': Flags.boolean({
+            description: 'Skip git repository initialization',
+            default: false
         })
     };
     async run() {
         try {
             const { args, flags } = await this.parse(Init);
-            await runInit(flags['skip-env'], args.folderName);
+            await runInit(flags['skip-env'], flags['skip-git'], args.folderName);
         }
         catch (error) {
             if (error instanceof UserCancelledError) {

package/dist/commands/init.spec.js

@@ -37,7 +37,7 @@ describe('init command', () => {
             Object.defineProperty(cmd, 'parse', {
                 value: vi.fn().mockResolvedValue({
                     args: { folderName: undefined, ...parsedArgs },
-                    flags: { 'skip-env': false, ...flags }
+                    flags: { 'skip-env': false, 'skip-git': false, ...flags }
                 }),
                 configurable: true
             });
@@ -52,10 +52,10 @@ describe('init command', () => {
             expect(cmd.run).toBeDefined();
             expect(typeof cmd.run).toBe('function');
         });
-        it('should call runInit with skip-env flag and folder name', async () => {
+        it('should call runInit with skip-env flag, skip-git flag, and folder name', async () => {
             const cmd = createTestCommand();
             await cmd.run();
-            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, undefined);
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, false, undefined);
         });
         it('should handle UserCancelledError', async () => {
             const error = new UserCancelledError();
@@ -89,12 +89,17 @@ describe('init command', () => {
         it('should pass skip-env flag to runInit when --skip-env is provided', async () => {
             const cmd = createTestCommand([], { 'skip-env': true });
             await cmd.run();
-            expect(projectScaffold.runInit).toHaveBeenCalledWith(true, undefined);
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(true, false, undefined);
+        });
+        it('should pass skip-git flag to runInit when --skip-git is provided', async () => {
+            const cmd = createTestCommand([], { 'skip-git': true });
+            await cmd.run();
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, true, undefined);
         });
         it('should pass folder name to runInit when provided', async () => {
             const cmd = createTestCommand([], {}, { folderName: 'my-project' });
             await cmd.run();
-            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, 'my-project');
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, false, 'my-project');
         });
     });
 });

package/dist/config.d.ts

@@ -1,44 +1,12 @@
-/**
- * CLI configuration
- */
 export declare const config: {
-    /**
-     * Base URL for the Output.ai API server
-     * Can be overridden with OUTPUT_API_URL environment variable
-     */
-    apiUrl: string;
-    /**
-     * API authentication token
-     * Set via OUTPUT_API_AUTH_TOKEN environment variable
-     */
-    apiToken: string | undefined;
-    /**
-     * Default timeout for API requests (in milliseconds)
-     */
+    readonly apiUrl: string;
+    readonly apiToken: string | undefined;
     requestTimeout: number;
-    /**
-     * Docker Compose project name
-     * Can be overridden with DOCKER_SERVICE_NAME environment variable
-     */
-    dockerServiceName: string;
-    /**
-     * Set the debug mode
-     */
-    debugMode: boolean;
-    /**
-     * Where the env vars are stored, defaults to `.env`
-     */
-    envFile: string;
-    /**
-     * Agent configuration directory name
-     */
+    readonly dockerServiceName: string;
+    readonly debugMode: boolean;
+    readonly envFile: string;
     agentConfigDir: string;
-    /**
-     * S3 configuration for remote trace storage
-     * Set via OUTPUT_TRACE_REMOTE_S3_BUCKET, OUTPUT_AWS_REGION,
-     * OUTPUT_AWS_ACCESS_KEY_ID, and OUTPUT_AWS_SECRET_ACCESS_KEY environment variables
-     */
-    s3: {
+    readonly s3: {
         bucket: string | undefined;
         region: string | undefined;
         accessKeyId: string | undefined;

package/dist/config.js

@@ -1,47 +1,27 @@
-/**
- * CLI configuration
- */
 export const config = {
-    /**
-     * Base URL for the Output.ai API server
-     * Can be overridden with OUTPUT_API_URL environment variable
-     */
-    apiUrl: process.env.OUTPUT_API_URL || 'http://localhost:3001',
-    /**
-     * API authentication token
-     * Set via OUTPUT_API_AUTH_TOKEN environment variable
-     */
-    apiToken: process.env.OUTPUT_API_AUTH_TOKEN,
-    /**
-     * Default timeout for API requests (in milliseconds)
-     */
+    get apiUrl() {
+        return process.env.OUTPUT_API_URL || 'http://localhost:3001';
+    },
+    get apiToken() {
+        return process.env.OUTPUT_API_AUTH_TOKEN;
+    },
     requestTimeout: 30000,
-    /**
-     * Docker Compose project name
-     * Can be overridden with DOCKER_SERVICE_NAME environment variable
-     */
-    dockerServiceName: process.env.DOCKER_SERVICE_NAME || 'output-sdk',
-    /**
-     * Set the debug mode
-     */
-    debugMode: process.env.OUTPUT_DEBUG === 'true',
-    /**
-     * Where the env vars are stored, defaults to `.env`
-     */
-    envFile: process.env.OUTPUT_CLI_ENV || '.env',
-    /**
-     * Agent configuration directory name
-     */
+    get dockerServiceName() {
+        return process.env.DOCKER_SERVICE_NAME || 'output-sdk';
+    },
+    get debugMode() {
+        return process.env.OUTPUT_DEBUG === 'true';
+    },
+    get envFile() {
+        return process.env.OUTPUT_CLI_ENV || '.env';
+    },
     agentConfigDir: '.outputai',
-    /**
-     * S3 configuration for remote trace storage
-     * Set via OUTPUT_TRACE_REMOTE_S3_BUCKET, OUTPUT_AWS_REGION,
-     * OUTPUT_AWS_ACCESS_KEY_ID, and OUTPUT_AWS_SECRET_ACCESS_KEY environment variables
-     */
-    s3: {
-        bucket: process.env.OUTPUT_TRACE_REMOTE_S3_BUCKET,
-        region: process.env.OUTPUT_AWS_REGION,
-        accessKeyId: process.env.OUTPUT_AWS_ACCESS_KEY_ID,
-        secretAccessKey: process.env.OUTPUT_AWS_SECRET_ACCESS_KEY
+    get s3() {
+        return {
+            bucket: process.env.OUTPUT_TRACE_REMOTE_S3_BUCKET,
+            region: process.env.OUTPUT_AWS_REGION,
+            accessKeyId: process.env.OUTPUT_AWS_ACCESS_KEY_ID,
+            secretAccessKey: process.env.OUTPUT_AWS_SECRET_ACCESS_KEY
+        };
     }
 };

package/dist/config.spec.d.ts

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

package/dist/config.spec.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { config } from '#config.js';
+describe('config', () => {
+    const envVars = [
+        'OUTPUT_API_URL',
+        'OUTPUT_API_AUTH_TOKEN',
+        'DOCKER_SERVICE_NAME',
+        'OUTPUT_DEBUG',
+        'OUTPUT_CLI_ENV',
+        'OUTPUT_TRACE_REMOTE_S3_BUCKET',
+        'OUTPUT_AWS_REGION',
+        'OUTPUT_AWS_ACCESS_KEY_ID',
+        'OUTPUT_AWS_SECRET_ACCESS_KEY'
+    ];
+    const saved = {};
+    beforeEach(() => {
+        for (const key of envVars) {
+            saved[key] = process.env[key];
+        }
+    });
+    afterEach(() => {
+        for (const key of envVars) {
+            if (saved[key] === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = saved[key];
+            }
+        }
+    });
+    it('reads env vars lazily, not at module evaluation time', () => {
+        process.env.OUTPUT_API_URL = 'https://lazy-test.example.com';
+        expect(config.apiUrl).toBe('https://lazy-test.example.com');
+        process.env.OUTPUT_API_URL = 'https://changed.example.com';
+        expect(config.apiUrl).toBe('https://changed.example.com');
+    });
+    it('falls back to defaults when env vars are unset', () => {
+        delete process.env.OUTPUT_API_URL;
+        delete process.env.DOCKER_SERVICE_NAME;
+        delete process.env.OUTPUT_DEBUG;
+        delete process.env.OUTPUT_CLI_ENV;
+        expect(config.apiUrl).toBe('http://localhost:3001');
+        expect(config.dockerServiceName).toBe('output-sdk');
+        expect(config.debugMode).toBe(false);
+        expect(config.envFile).toBe('.env');
+    });
+    it('reads apiToken from env', () => {
+        process.env.OUTPUT_API_AUTH_TOKEN = 'test-token-123';
+        expect(config.apiToken).toBe('test-token-123');
+        delete process.env.OUTPUT_API_AUTH_TOKEN;
+        expect(config.apiToken).toBeUndefined();
+    });
+    it('reads debugMode as boolean', () => {
+        process.env.OUTPUT_DEBUG = 'true';
+        expect(config.debugMode).toBe(true);
+        process.env.OUTPUT_DEBUG = 'false';
+        expect(config.debugMode).toBe(false);
+    });
+    it('reads s3 config lazily', () => {
+        process.env.OUTPUT_TRACE_REMOTE_S3_BUCKET = 'my-bucket';
+        process.env.OUTPUT_AWS_REGION = 'us-west-2';
+        process.env.OUTPUT_AWS_ACCESS_KEY_ID = 'AKIA123';
+        process.env.OUTPUT_AWS_SECRET_ACCESS_KEY = 'secret123';
+        expect(config.s3).toEqual({
+            bucket: 'my-bucket',
+            region: 'us-west-2',
+            accessKeyId: 'AKIA123',
+            secretAccessKey: 'secret123'
+        });
+    });
+    it('has static properties that are not env-derived', () => {
+        expect(config.requestTimeout).toBe(30000);
+        expect(config.agentConfigDir).toBe('.outputai');
+    });
+});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.2.1-next.7fd86e7.0"
+    "framework": "0.2.1-next.bc8ccee.0"
 }

package/dist/hooks/init.d.ts

@@ -1,3 +1,7 @@
 import { Hook } from '@oclif/core';
+export declare const INTERACTIVE_FLAGS: string[];
+export declare const GLOBAL_FLAGS: Set<string>;
+export declare const hasInteractiveFlag: (argv: string[]) => boolean;
+export declare const stripGlobalFlags: (argv: string[]) => void;
 declare const hook: Hook<'init'>;
 export default hook;

package/dist/hooks/init.js

@@ -1,8 +1,20 @@
 import { ux } from '@oclif/core';
 import { checkForUpdate } from '#services/version_check.js';
 import { setNonInteractive } from '#utils/interactive.js';
-const hook = async function () {
-    if (process.argv.includes('--yes') || process.argv.includes('--non-interactive')) {
+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));
+export const stripGlobalFlags = (argv) => {
+    const kept = argv.filter(arg => !GLOBAL_FLAGS.has(arg));
+    if (kept.length !== argv.length) {
+        argv.splice(0, argv.length, ...kept);
+    }
+};
+const hook = async function (opts) {
+    const interactive = hasInteractiveFlag(opts.argv) || hasInteractiveFlag(process.argv);
+    stripGlobalFlags(opts.argv);
+    stripGlobalFlags(process.argv);
+    if (interactive) {
         setNonInteractive(true);
     }
     try {

package/dist/hooks/init.spec.js

@@ -1,9 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { checkForUpdate } from '#services/version_check.js';
+import { setNonInteractive } from '#utils/interactive.js';
 vi.mock('#services/version_check.js', () => ({
     checkForUpdate: vi.fn()
 }));
+vi.mock('#utils/interactive.js', () => ({
+    setNonInteractive: vi.fn()
+}));
 vi.mock('@oclif/core', () => ({
     ux: {
         stdout: vi.fn(),
@@ -11,7 +15,7 @@ vi.mock('@oclif/core', () => ({
     }
 }));
 import { ux } from '@oclif/core';
-import hook from './init.js';
+import hook, { hasInteractiveFlag, stripGlobalFlags } from './init.js';
 describe('init hook', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -26,7 +30,7 @@ describe('init hook', () => {
             latestVersion: '1.0.0'
         });
         const ctx = createHookContext();
-        await hook.call(ctx, {});
+        await hook.call(ctx, { argv: [], id: undefined });
         expect(checkForUpdate).toHaveBeenCalledWith('0.8.4', '/tmp/test-cache');
         expect(ux.stdout).toHaveBeenCalled();
         const output = vi.mocked(ux.stdout).mock.calls.map(c => c[0]).join('\n');
@@ -42,13 +46,83 @@ describe('init hook', () => {
             latestVersion: '0.8.4'
         });
         const ctx = createHookContext();
-        await hook.call(ctx, {});
+        await hook.call(ctx, { argv: [], id: undefined });
         expect(ux.stdout).not.toHaveBeenCalled();
     });
     it('should silently handle errors', async () => {
         vi.mocked(checkForUpdate).mockRejectedValue(new Error('network failure'));
         const ctx = createHookContext();
-        await hook.call(ctx, {});
+        await hook.call(ctx, { argv: [], id: undefined });
         expect(ux.stdout).not.toHaveBeenCalled();
     });
+    describe('global interactive flags', () => {
+        const originalArgv = process.argv;
+        beforeEach(() => {
+            vi.mocked(checkForUpdate).mockResolvedValue({
+                updateAvailable: false,
+                currentVersion: '0.8.4',
+                latestVersion: '0.8.4'
+            });
+        });
+        afterEach(() => {
+            process.argv = originalArgv;
+        });
+        it('should mutate opts.argv in place to strip --yes', async () => {
+            process.argv = ['node', 'run.js', 'init', '--yes', 'my-project'];
+            const optsArgv = ['--yes', 'my-project'];
+            const argvRef = optsArgv;
+            const ctx = createHookContext();
+            await hook.call(ctx, { argv: optsArgv, id: 'init' });
+            expect(setNonInteractive).toHaveBeenCalledWith(true);
+            expect(optsArgv).toBe(argvRef);
+            expect(optsArgv).toEqual(['my-project']);
+            expect(process.argv).toEqual(['node', 'run.js', 'init', 'my-project']);
+        });
+        it('should mutate opts.argv in place to strip --non-interactive', async () => {
+            process.argv = ['node', 'run.js', 'init', '--non-interactive'];
+            const optsArgv = ['--non-interactive'];
+            const ctx = createHookContext();
+            await hook.call(ctx, { argv: optsArgv, id: 'init' });
+            expect(setNonInteractive).toHaveBeenCalledWith(true);
+            expect(optsArgv).toEqual([]);
+            expect(process.argv).toEqual(['node', 'run.js', 'init']);
+        });
+        it('should leave argv untouched when no global flag is present', async () => {
+            process.argv = ['node', 'run.js', 'init', '--skip-env'];
+            const optsArgv = ['--skip-env'];
+            const ctx = createHookContext();
+            await hook.call(ctx, { argv: optsArgv, id: 'init' });
+            expect(setNonInteractive).not.toHaveBeenCalled();
+            expect(optsArgv).toEqual(['--skip-env']);
+            expect(process.argv).toEqual(['node', 'run.js', 'init', '--skip-env']);
+        });
+    });
+    describe('hasInteractiveFlag', () => {
+        it('returns true when --yes is present', () => {
+            expect(hasInteractiveFlag(['init', '--yes', 'foo'])).toBe(true);
+        });
+        it('returns true when --non-interactive is present', () => {
+            expect(hasInteractiveFlag(['--non-interactive'])).toBe(true);
+        });
+        it('returns false for unrelated flags', () => {
+            expect(hasInteractiveFlag(['init', '--skip-env', '--skip-git'])).toBe(false);
+        });
+        it('returns false for an empty argv', () => {
+            expect(hasInteractiveFlag([])).toBe(false);
+        });
+    });
+    describe('stripGlobalFlags', () => {
+        it('mutates argv in place to remove global flags', () => {
+            const argv = ['init', '--yes', 'foo', '--non-interactive'];
+            const ref = argv;
+            stripGlobalFlags(argv);
+            expect(argv).toBe(ref);
+            expect(argv).toEqual(['init', 'foo']);
+        });
+        it('leaves argv untouched when no global flag is present', () => {
+            const argv = ['init', '--skip-env'];
+            stripGlobalFlags(argv);
+            expect(argv).toEqual(['init', '--skip-env']);
+        });
+    });
 });

package/dist/services/project_scaffold.d.ts

@@ -27,5 +27,5 @@ export declare function createSigintHandler(projectPath: string, folderCreated:
  * @param skipEnv - Whether to skip environment configuration prompts
  * @param folderName - Optional folder name to skip folder name prompt
  */
-export declare function runInit(skipEnv?: boolean, folderName?: string): Promise<void>;
+export declare function runInit(skipEnv?: boolean, skipGit?: boolean, folderName?: string): Promise<void>;
 export {};

package/dist/services/project_scaffold.js

@@ -119,6 +119,18 @@ async function executeNpmInstall(projectPath) {
 async function initializeAgents(projectPath) {
     await initializeAgentConfig({ projectRoot: projectPath, force: false });
 }
+async function maybeInitializeGit(projectPath) {
+    const shouldInit = await confirm({
+        message: 'Initialize a git repository?',
+        default: true
+    });
+    if (!shouldInit) {
+        return false;
+    }
+    return executeCommandWithMessages(async () => {
+        await executeCommand('git', ['init'], projectPath);
+    }, 'Initializing git repository...', 'Git repository initialized');
+}
 /**
  * Format error message for init errors
  * Single responsibility: only format error messages, no cleanup logic
@@ -172,7 +184,7 @@ function handleRunInitError(error, projectPath, projectFolderCreated) {
  * @param skipEnv - Whether to skip environment configuration prompts
  * @param folderName - Optional folder name to skip folder name prompt
  */
-export async function runInit(skipEnv = false, folderName) {
+export async function runInit(skipEnv = false, skipGit = false, folderName) {
     // Track state for SIGINT cleanup using an object to avoid let
     const state = {
         projectFolderCreated: false,
@@ -210,6 +222,9 @@ export async function runInit(skipEnv = false, folderName) {
         await fs.copyFile(path.join(config.projectPath, '.env.example'), path.join(config.projectPath, '.env'));
         await executeCommandWithMessages(() => initializeAgents(config.projectPath), 'Initializing agent system...', 'Agent system initialized');
         const installSuccess = await executeCommandWithMessages(() => executeNpmInstall(config.projectPath), 'Installing dependencies...', 'Dependencies installed');
+        if (!skipGit) {
+            await maybeInitializeGit(config.projectPath);
+        }
         const nextSteps = getProjectSuccessMessage(config.folderName, installSuccess, credentialsConfigured);
         ux.stdout('Project created successfully!');
         ux.stdout(nextSteps);

package/dist/utils/env_loader.js

@@ -7,11 +7,10 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import * as dotenv from 'dotenv';
 import debugFactory from 'debug';
-import { config } from '#config.js';
 const debug = debugFactory('output-cli:env-loader');
 export function loadEnvironment() {
     const cwd = process.cwd();
-    const envFile = config.envFile;
+    const envFile = process.env.OUTPUT_CLI_ENV || '.env';
     const envPath = resolve(cwd, envFile);
     if (!existsSync(envPath)) {
         debug(`Warning: Env file not found: ${envPath}`);

package/dist/utils/error_handler.js

@@ -1,11 +1,13 @@
 import { config } from '#config.js';
-const DEFAULT_MESSAGES = {
-    ECONNREFUSED: `Connection refused to ${config.apiUrl}. Is the API server running?`,
-    401: 'Authentication failed. Check your OUTPUT_API_AUTH_TOKEN.',
-    404: 'Resource not found.',
-    500: 'Server error.',
-    UNKNOWN: 'An unknown error occurred.'
-};
+function getDefaultMessages() {
+    return {
+        ECONNREFUSED: `Connection refused to ${config.apiUrl}. Is the API server running?`,
+        401: 'Authentication failed. Check your OUTPUT_API_AUTH_TOKEN.',
+        404: 'Resource not found.',
+        500: 'Server error.',
+        UNKNOWN: 'An unknown error occurred.'
+    };
+}
 /**
  * Extract error type and message from API response data
  */
@@ -49,7 +51,7 @@ function getDetailedErrorMessage(error) {
 }
 export function handleApiError(error, errorFn, overrides = {}) {
     const apiError = error;
-    const errorMessages = { ...DEFAULT_MESSAGES, ...overrides };
+    const errorMessages = { ...getDefaultMessages(), ...overrides };
     if (apiError.code === 'ECONNREFUSED' || apiError.cause?.code === 'ECONNREFUSED') {
         errorFn(errorMessages.ECONNREFUSED, { exit: 1 });
     }

package/dist/views/workflow/list.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect, useRef, useMemo } from 'react';
 import { Box, Text, useInput } from 'ink';
 import Spinner from 'ink-spinner';
-import { getWorkflowIdResult } from '#api/generated/api.js';
+import { getWorkflowIdRunsRidResult } from '#api/generated/api.js';
 import { StatusIcon, statusColor } from '#components/status_icon.js';
 import { elapsedMs, formatDurationCompact } from '#utils/date_formatter.js';
 import { CommandFooter } from '#components/command_footer.js';
@@ -59,17 +59,19 @@ export const WorkflowListView = ({ runs, onBack }) => {
     const clampedIndex = Math.min(selectedIndex, Math.max(0, sortedRuns.length - 1));
     const selectedRun = sortedRuns[clampedIndex];
     const selectedWorkflowId = selectedRun?.workflowId;
+    const selectedRunId = selectedRun?.runId;
     useEffect(() => {
         if (clampedIndex !== selectedIndex) {
             setSelectedIndex(clampedIndex);
         }
     }, [clampedIndex, selectedIndex]);
     useEffect(() => {
-        if (!selectedWorkflowId) {
+        if (!selectedWorkflowId || !selectedRunId) {
             setDetail(null);
             return;
         }
-        const cached = cacheRef.current.get(selectedWorkflowId);
+        const cacheKey = `${selectedWorkflowId}:${selectedRunId}`;
+        const cached = cacheRef.current.get(cacheKey);
         if (cached) {
             setDetail(cached);
             setDetailLoading(false);
@@ -77,13 +79,13 @@ export const WorkflowListView = ({ runs, onBack }) => {
         }
         const currentFetchId = ++fetchIdRef.current;
         setDetailLoading(true);
-        getWorkflowIdResult(selectedWorkflowId)
+        getWorkflowIdRunsRidResult(selectedWorkflowId, selectedRunId)
             .then(response => {
             if (fetchIdRef.current !== currentFetchId) {
                 return;
             }
             const data = response.data;
-            cacheRef.current.set(selectedWorkflowId, data);
+            cacheRef.current.set(cacheKey, data);
             setDetail(data);
             setDetailLoading(false);
         })
@@ -94,7 +96,7 @@ export const WorkflowListView = ({ runs, onBack }) => {
             setDetail(null);
             setDetailLoading(false);
         });
-    }, [selectedWorkflowId]);
+    }, [selectedWorkflowId, selectedRunId]);
     useInput((input, key) => {
         if (key.upArrow) {
             setSelectedIndex(i => Math.max(0, i - 1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.2.1-next.7fd86e7.0",
+  "version": "0.2.1-next.bc8ccee.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -36,9 +36,9 @@
     "semver": "7.7.4",
     "undici": "8.0.2",
     "yaml": "^2.8.3",
-    "@outputai/evals": "0.2.1-next.7fd86e7.0",
-    "@outputai/credentials": "0.2.1-next.7fd86e7.0",
-    "@outputai/llm": "0.2.1-next.7fd86e7.0"
+    "@outputai/credentials": "0.2.1-next.bc8ccee.0",
+    "@outputai/evals": "0.2.1-next.bc8ccee.0",
+    "@outputai/llm": "0.2.1-next.bc8ccee.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",