@outputai/cli 0.10.1-next.09ed166.0 → 0.10.1-next.52bedcf.0

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.10.1-next.09ed166.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.10.1-next.52bedcf.0}
     init: true
     networks:
       - main

package/dist/commands/dev/index.js

@@ -110,7 +110,28 @@ export default class Dev extends Command {
         // `instance` ref is filled in once `render()` returns; until then,
         // signal handlers just stop docker and exit.
         const instanceRef = { current: null };
-        process.on('exit', exitAltScreenOnce);
+        // Single terminal-restore sequence shared by every exit path: stop Ink
+        // (frees raw mode) then leave the alt-screen. The `finally` guarantees
+        // the alt-screen is left even if `unmount()` throws — otherwise a crash
+        // could strand the user in the blank alt buffer. This is the one place
+        // the unmount → leave-alt-screen order lives, so the paths can't drift.
+        const restoreTerminal = () => {
+            try {
+                instanceRef.current?.unmount();
+            }
+            finally {
+                exitAltScreenOnce();
+            }
+        };
+        // Collect a disposer for every process listener so registration and
+        // teardown can't drift: a handler added through `on` is always removed by
+        // the `finally` below, with no separate removeListener list to keep in sync.
+        const disposers = [];
+        const on = (event, handler) => {
+            process.on(event, handler);
+            disposers.push(() => process.removeListener(event, handler));
+        };
+        on('exit', exitAltScreenOnce);
         // `process.on` doesn't await the handler, so the cleanup promise would
         // float and any rejection would surface as an unhandled rejection.
         // Wrap the async work in a sync registration that explicitly logs
@@ -124,10 +145,35 @@ export default class Dev extends Command {
                 exitAltScreenOnce();
                 console.error('Cleanup failed:', getErrorMessage(err));
             })
-                .finally(() => instanceRef.current?.unmount());
+                .finally(restoreTerminal);
         };
-        process.on('SIGINT', handleSignal);
-        process.on('SIGTERM', handleSignal);
+        on('SIGINT', handleSignal);
+        on('SIGTERM', handleSignal);
+        // A fatal crash (uncaught exception / unhandled rejection) skips both the
+        // clean-exit path and the signal handlers. Tear docker down via cleanup()
+        // FIRST, then restore the terminal and print the crash: unmounting Ink
+        // resolves the awaited waitUntilExit(), which resumes run() and strips the
+        // signal listeners — so unmounting before cleanup would drop them
+        // mid-teardown and let a Ctrl+C orphan the stack. Print the raw error so
+        // Node's stack trace survives, then re-exit non-zero. Fire-once: a second
+        // catchable crash during teardown is a no-op. A hard V8 abort() (SIGABRT)
+        // is uncatchable and not covered here.
+        const fatalState = { handled: false };
+        const handleFatalError = (err) => {
+            if (fatalState.handled) {
+                return;
+            }
+            fatalState.handled = true;
+            cleanup()
+                .catch(cleanupErr => console.error('Cleanup failed:', getErrorMessage(cleanupErr)))
+                .finally(() => {
+                restoreTerminal();
+                console.error(err);
+                process.exit(1);
+            });
+        };
+        on('uncaughtException', handleFatalError);
+        on('unhandledRejection', handleFatalError);
         try {
             enterAltScreen();
             const instance = render(React.createElement(DevApp, { dockerComposePath, onCleanup: cleanup }), { exitOnCtrlC: false });
@@ -158,9 +204,14 @@ export default class Dev extends Command {
             exitAltScreenOnce();
         }
         catch (error) {
-            instanceRef.current?.unmount();
-            exitAltScreenOnce();
+            restoreTerminal();
             this.error(getErrorMessage(error), { exit: 1 });
         }
+        finally {
+            // Remove every process-global listener registered above; otherwise each
+            // run() (test invocations included) leaks a live handler that force-
+            // exits the process on the next stray signal or rejection.
+            disposers.forEach(dispose => dispose());
+        }
     }
 }

package/dist/commands/dev/index.spec.js

@@ -328,6 +328,61 @@ describe('dev command', () => {
             expect(cmd.error).not.toHaveBeenCalled();
         });
     });
+    describe('fatal error handling', () => {
+        it('restores the terminal and exits non-zero on an uncaught exception', async () => {
+            const inkInstance = createControllableInkInstance();
+            vi.mocked(render).mockReturnValue(inkInstance);
+            // Capture the registered handlers instead of letting them attach to the
+            // real process, and neutralize process.exit so firing one doesn't kill
+            // the test runner.
+            const handlers = {};
+            const onSpy = vi.spyOn(process, 'on').mockImplementation(((event, handler) => {
+                handlers[event] = handler;
+                return process;
+            }));
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined));
+            const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            const runPromise = cmd.run();
+            await new Promise(resolve => setImmediate(resolve));
+            expect(handlers.uncaughtException).toBeInstanceOf(Function);
+            expect(handlers.unhandledRejection).toBeInstanceOf(Function);
+            const crash = new Error('boom');
+            handlers.uncaughtException(crash);
+            // Terminal restore, the crash print, and exit all run after docker
+            // teardown settles, so they land a tick later.
+            await new Promise(resolve => setImmediate(resolve));
+            // Docker is torn down before exit, so a crash doesn't orphan the
+            // compose stack.
+            expect(dockerService.stopDockerCompose).toHaveBeenCalled();
+            expect(inkInstance.unmount).toHaveBeenCalled();
+            expect(stdoutSpy).toHaveBeenCalledWith('\x1b[?1049l');
+            expect(errorSpy).toHaveBeenCalledWith(crash);
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            // Discriminating order: docker must be fully torn down BEFORE Ink
+            // unmounts. Unmounting resolves waitUntilExit() and resumes run(),
+            // which strips the signal listeners — so an unmount-first ordering
+            // would drop the SIGINT handler mid-teardown and risk orphaning the
+            // stack on a Ctrl+C.
+            expect(vi.mocked(dockerService.stopDockerCompose).mock.invocationCallOrder[0])
+                .toBeLessThan(inkInstance.unmount.mock.invocationCallOrder[0]);
+            // Within the restore, Ink unmounts before the alt-screen is left, and
+            // the crash prints only after — otherwise console.error paints into a
+            // buffer the user never sees.
+            const leaveAltScreenCall = stdoutSpy.mock.invocationCallOrder[stdoutSpy.mock.calls.findIndex(([seq]) => seq === '\x1b[?1049l')];
+            expect(inkInstance.unmount.mock.invocationCallOrder[0]).toBeLessThan(leaveAltScreenCall);
+            expect(leaveAltScreenCall).toBeLessThan(errorSpy.mock.invocationCallOrder[0]);
+            onSpy.mockRestore();
+            runPromise.catch(() => { });
+        });
+    });
     describe('image pull policy', () => {
         it('should pass pull policy to startDockerCompose', async () => {
             const cmd = new Dev([], {});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.10.1-next.09ed166.0"
+    "framework": "0.10.1-next.52bedcf.0"
 }

package/dist/views/dev/hooks/use_run_detail.js

@@ -3,13 +3,15 @@ import { readFile } from 'node:fs/promises';
 import { getWorkflowIdResult, getWorkflowIdRunsRidResult, getWorkflowIdTraceLog, getWorkflowIdRunsRidTraceLog } from '#api/generated/api.js';
 import { normalizeWorkflowStatus } from '#utils/normalize_workflow_status.js';
 import { TERMINAL_STATUSES } from '#utils/format_workflow_result.js';
+import { createBoundedCache } from '#views/dev/utils/bounded_cache.js';
 const EMPTY_DETAIL = {
     result: null,
     trace: null,
     steps: [],
     loading: false
 };
-const runDetailCache = new Map();
+const RUN_DETAIL_CACHE_MAX = 50;
+const runDetailCache = createBoundedCache(RUN_DETAIL_CACHE_MAX);
 const stepNameOf = (node) => {
     if (node.name) {
         return node.name;

package/dist/views/dev/hooks/use_step_graph.js

@@ -3,6 +3,7 @@ import { fetchWorkflowHistory } from '#services/workflow_history.js';
 import buildSpanLabels from '#utils/span_labels.js';
 import { isTerminalRunStatus } from '#views/dev/hooks/use_run_detail.js';
 import { usePoll, POLL_INTERVAL_MS } from '#views/dev/hooks/use_poll.js';
+import { createBoundedCache } from '#views/dev/utils/bounded_cache.js';
 const EMPTY_GRAPH = {
     spans: [],
     totalDurationMs: 0,
@@ -11,7 +12,8 @@ const EMPTY_GRAPH = {
     loading: false,
     error: null
 };
-const stepGraphCache = new Map();
+const STEP_GRAPH_CACHE_MAX = 50;
+const stepGraphCache = createBoundedCache(STEP_GRAPH_CACHE_MAX);
 /**
  * Fetches a run's correlated step spans for the dev TUI's waterfall overlay,
  * reusing the same `fetchWorkflowHistory` path as the `workflow history` CLI

package/dist/views/dev/utils/bounded_cache.d.ts

@@ -0,0 +1,14 @@
+export interface BoundedCache<K, V extends {}> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    clear(): void;
+    size(): number;
+}
+/**
+ * A small LRU cache backed by an insertion-ordered `Map`, capped at `maxSize`
+ * entries. Reading a key refreshes its recency; once the cap is exceeded the
+ * least-recently-used entries are evicted. Drop-in compatible with the
+ * `Map.get` / `Map.set` calls it replaces.
+ */
+export declare const createBoundedCache: <K, V extends {}>(maxSize: number) => BoundedCache<K, V>;

package/dist/views/dev/utils/bounded_cache.js

@@ -0,0 +1,42 @@
+/**
+ * A small LRU cache backed by an insertion-ordered `Map`, capped at `maxSize`
+ * entries. Reading a key refreshes its recency; once the cap is exceeded the
+ * least-recently-used entries are evicted. Drop-in compatible with the
+ * `Map.get` / `Map.set` calls it replaces.
+ */
+export const createBoundedCache = (maxSize) => {
+    if (maxSize < 1) {
+        throw new Error('createBoundedCache: maxSize must be >= 1');
+    }
+    const entries = new Map();
+    return {
+        get(key) {
+            const value = entries.get(key);
+            if (value === undefined) {
+                return value;
+            }
+            entries.delete(key);
+            entries.set(key, value);
+            return value;
+        },
+        set(key, value) {
+            entries.delete(key);
+            entries.set(key, value);
+            if (entries.size > maxSize) {
+                const oldest = entries.keys().next();
+                if (!oldest.done) {
+                    entries.delete(oldest.value);
+                }
+            }
+        },
+        has(key) {
+            return entries.has(key);
+        },
+        clear() {
+            entries.clear();
+        },
+        size() {
+            return entries.size;
+        }
+    };
+};

package/dist/views/dev/utils/bounded_cache.spec.d.ts

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

package/dist/views/dev/utils/bounded_cache.spec.js

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import { createBoundedCache } from './bounded_cache.js';
+describe('createBoundedCache', () => {
+    it('round-trips set and get', () => {
+        const cache = createBoundedCache(3);
+        cache.set('a', 1);
+        expect(cache.get('a')).toBe(1);
+        expect(cache.get('missing')).toBeUndefined();
+    });
+    it('evicts the oldest entry once maxSize is exceeded', () => {
+        const cache = createBoundedCache(2);
+        cache.set('a', 1);
+        cache.set('b', 2);
+        cache.set('c', 3);
+        expect(cache.has('a')).toBe(false);
+        expect(cache.get('b')).toBe(2);
+        expect(cache.get('c')).toBe(3);
+    });
+    it('refreshes recency on get so the touched entry survives eviction', () => {
+        const cache = createBoundedCache(2);
+        cache.set('a', 1);
+        cache.set('b', 2);
+        // Touch 'a' so 'b' becomes the least-recently-used entry.
+        expect(cache.get('a')).toBe(1);
+        cache.set('c', 3);
+        expect(cache.has('a')).toBe(true);
+        expect(cache.has('b')).toBe(false);
+        expect(cache.has('c')).toBe(true);
+    });
+    it('updates an existing key in place without growing', () => {
+        const cache = createBoundedCache(2);
+        cache.set('a', 1);
+        cache.set('a', 2);
+        expect(cache.get('a')).toBe(2);
+        expect(cache.size()).toBe(1);
+    });
+    it('supports has and clear', () => {
+        const cache = createBoundedCache(2);
+        cache.set('a', 1);
+        expect(cache.has('a')).toBe(true);
+        cache.clear();
+        expect(cache.has('a')).toBe(false);
+        expect(cache.size()).toBe(0);
+    });
+    it('never exceeds maxSize', () => {
+        const cache = createBoundedCache(3);
+        Array.from({ length: 100 }, (_, i) => i).forEach(i => {
+            cache.set(`key-${i}`, i);
+            expect(cache.size()).toBeLessThanOrEqual(3);
+        });
+        expect(cache.size()).toBe(3);
+    });
+});

package/oclif.manifest.json

@@ -1671,5 +1671,5 @@
       ]
     }
   },
-  "version": "0.10.1-next.09ed166.0"
+  "version": "0.10.1-next.52bedcf.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.10.1-next.09ed166.0",
+  "version": "0.10.1-next.52bedcf.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -38,9 +38,9 @@
     "semver": "7.7.4",
     "undici": "8.5.0",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.10.1-next.09ed166.0",
-    "@outputai/llm": "0.10.1-next.09ed166.0",
-    "@outputai/evals": "0.10.1-next.09ed166.0"
+    "@outputai/credentials": "0.10.1-next.52bedcf.0",
+    "@outputai/llm": "0.10.1-next.52bedcf.0",
+    "@outputai/evals": "0.10.1-next.52bedcf.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",